diff --git a/.gitignore b/.gitignore
index cdf34f18d..9bd049424 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,6 +31,7 @@ src/aig/ddb/
 *.plg
 
 *.zip
+*.DS_Store
 
 abcspaceext.dsw
 abcext.dsp
diff --git a/Makefile b/Makefile
index dc909bb63..a546f65fd 100644
--- a/Makefile
+++ b/Makefile
@@ -26,9 +26,9 @@ MODULES := \
 	src/misc/vec src/misc/hash src/misc/tim src/misc/bzlib src/misc/zlib \
 	src/misc/mem src/misc/bar src/misc/bbl src/misc/parse \
 	src/opt/cut src/opt/fxu src/opt/fxch src/opt/rwr src/opt/mfs src/opt/sim \
-	src/opt/ret src/opt/fret src/opt/res src/opt/lpk src/opt/nwk src/opt/rwt \
+	src/opt/ret src/opt/fret src/opt/res src/opt/lpk src/opt/nwk src/opt/rwt src/opt/rar \
 	src/opt/cgt src/opt/csw src/opt/dar src/opt/dau src/opt/dsc src/opt/sfm src/opt/sbd \
-	src/sat/bsat src/sat/xsat src/sat/satoko src/sat/csat src/sat/msat src/sat/psat src/sat/cnf src/sat/bmc src/sat/glucose src/sat/glucose2 \
+	src/sat/bsat src/sat/xsat src/sat/satoko src/sat/csat src/sat/msat src/sat/psat src/sat/cnf src/sat/bmc src/sat/glucose src/sat/glucose2 src/sat/kissat src/sat/cadical \
 	src/bool/bdc src/bool/deco src/bool/dec src/bool/kit src/bool/lucky \
 	src/bool/rsb src/bool/rpo \
 	src/proof/pdr src/proof/abs src/proof/live src/proof/ssc src/proof/int \
diff --git a/abclib.dsp b/abclib.dsp
index 559d59d2a..921030b34 100644
--- a/abclib.dsp
+++ b/abclib.dsp
@@ -691,6 +691,10 @@ SOURCE=.\src\base\io\ioWriteGml.c
 # End Source File
 # Begin Source File
 
+SOURCE=.\src\base\io\ioWriteHMetis.c
+# End Source File
+# Begin Source File
+
 SOURCE=.\src\base\io\ioWriteList.c
 # End Source File
 # Begin Source File
@@ -2514,6 +2518,742 @@ SOURCE=.\src\sat\glucose2\Vec.h
 SOURCE=.\src\sat\glucose2\XAlloc.h
 # End Source File
 # End Group
+# Begin Group "kissat"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\allocate.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\analyze.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\ands.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\arena.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\assign.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\averages.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\backbone.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\backtrack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\build.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\bump.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\check.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\classify.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\clause.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\collect.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\colors.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\compact.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\config.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\congruence.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\decide.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\deduce.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\definition.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\dense.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\dump.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\eliminate.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\equivalences.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\error.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\extend.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\factor.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\fastel.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\file.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\flags.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\format.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\forward.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\gates.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\heap.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\ifthenelse.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\import.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\internal.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\kimits.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\kissatSolver.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\kissatTest.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\kitten.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\kptions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\krite.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\kucky.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\learn.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\logging.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\minimize.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\mode.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\phases.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\preprocess.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\print.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\probe.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\profile.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\promote.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\proof.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\propbeyond.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\propdense.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\propinitially.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\proprobe.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\propsearch.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\queue.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\reduce.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\reluctant.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\reorder.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\rephase.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\report.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\resize.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\resolve.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\resources.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\restart.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\search.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\shrink.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\smooth.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\sort.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\statistics.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\strengthen.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\substitute.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\sweep.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\terminate.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\tiers.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\trail.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\transitive.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\utilities.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\vector.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\vivify.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\walk.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\warmup.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\watch.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\kissat\weaken.c
+# End Source File
+# End Group
+# Begin Group "cadical"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_kitten.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_analyze.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_arena.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_assume.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_averages.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_backtrack.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_backward.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_bins.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_block.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_ccadical.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_checker.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_clause.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_collect.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_compact.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_condition.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_config.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_congruence.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_constrain.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_contract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_cover.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_decide.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_decompose.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_deduplicate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_definition.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_drattracer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_elim.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_elimfast.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_ema.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_extend.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_external.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_external_propagate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_factor.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_file.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_flags.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_flip.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_format.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_frattracer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_gates.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_idruptracer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_instantiate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_internal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_ipasir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_lidruptracer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_limit.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_logging.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_lookahead.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_lratchecker.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_lrattracer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_lucky.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_message.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_minimize.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_occs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_options.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_parse.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_phases.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_probe.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_profile.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_proof.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_propagate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_queue.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_random.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_reap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_reduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_rephase.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_report.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_resources.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_restart.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_restore.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_score.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_shrink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_signal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_solution.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_solver.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_stable.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_stats.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_subsume.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_sweep.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_terminal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_ternary.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_tier.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_transred.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_unstable.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_util.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_var.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_veripbtracer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_version.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_vivify.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_walk.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadical_watch.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadicalSolver.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\sat\cadical\cadicalTest.c
+# End Source File
+# End Group
 # End Group
 # Begin Group "opt"
 
@@ -2578,6 +3318,54 @@ SOURCE=.\src\opt\fxu\fxuSingle.c
 SOURCE=.\src\opt\fxu\fxuUpdate.c
 # End Source File
 # End Group
+# Begin Group "rar"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_map.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_miaig.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_rar.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_rng.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_time.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_tt.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_vec.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_map.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_miaig.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_rar.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\src\opt\rar\rewire_rng.c
+# End Source File
+# End Group
 # Begin Group "rwr"
 
 # PROP Default_Filter ""
@@ -4111,6 +4899,10 @@ SOURCE=.\src\misc\util\utilBridge.c
 # End Source File
 # Begin Source File
 
+SOURCE=.\src\misc\util\utilBSet.c
+# End Source File
+# Begin Source File
+
 SOURCE=.\src\misc\util\utilCex.c
 # End Source File
 # Begin Source File
@@ -5207,6 +5999,10 @@ SOURCE=.\src\aig\gia\giaRex.c
 # End Source File
 # Begin Source File
 
+SOURCE=.\src\aig\gia\giaRrr.cpp
+# End Source File
+# Begin Source File
+
 SOURCE=.\src\aig\gia\giaSat3.c
 # End Source File
 # Begin Source File
diff --git a/src/aig/gia/gia.h b/src/aig/gia/gia.h
index bb9e7ad7a..b950da4be 100644
--- a/src/aig/gia/gia.h
+++ b/src/aig/gia/gia.h
@@ -249,6 +249,11 @@ struct Gia_Man_t_
     int            iFirstPoId;
     int            iFirstAndObj;
     int            iFirstPoObj;
+    Vec_Str_t *    vTTISOPs;      // truth tables from ISOP computation
+    Vec_Int_t *    vTTLut;      // truth tables from ISOP computation
+    Vec_Int_t *    vMFFCsInfo;    // MFFC information
+    Vec_Int_t *    vMFFCsLuts;        // MFFCs for each lut
+    Vec_Ptr_t *    vLutsRankings;     // LUTs rankings of inputs
 };
 
 
@@ -1431,6 +1436,7 @@ extern void                Gia_ManEquivFixOutputPairs( Gia_Man_t * p );
 extern int                 Gia_ManCheckTopoOrder( Gia_Man_t * p );
 extern int *               Gia_ManDeriveNexts( Gia_Man_t * p );
 extern void                Gia_ManDeriveReprs( Gia_Man_t * p );
+extern void                Gia_ManDeriveReprsFromSibls( Gia_Man_t *p );
 extern int                 Gia_ManEquivCountLits( Gia_Man_t * p );
 extern int                 Gia_ManEquivCountLitsAll( Gia_Man_t * p );
 extern int                 Gia_ManEquivCountClasses( Gia_Man_t * p );
@@ -1801,6 +1807,9 @@ extern Gia_Man_t *         Gia_ManTtoptCare( Gia_Man_t * p, int nIns, int nOuts,
 extern Gia_Man_t *         Gia_ManTransductionBdd( Gia_Man_t * pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t * pExdc, int fNewLine, int nVerbose );
 extern Gia_Man_t *         Gia_ManTransductionTt( Gia_Man_t * pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t * pExdc, int fNewLine, int nVerbose );
 
+/*=== giaRrr.cpp ===========================================================*/
+extern Gia_Man_t *         Gia_ManRrr( Gia_Man_t *pGia, int iSeed, int nWords, int nTimeout, int nSchedulerVerbose, int nPartitionerVerbose, int nOptimizerVerbose, int nAnalyzerVerbose, int nSimulatorVerbose, int nSatSolverVerbose, int fUseBddCspf, int fUseBddMspf, int nConflictLimit, int nSortType, int nOptimizerFlow, int nSchedulerFlow, int nDistance, int nRestarts, int nThreads, int nWindowSize, int fDeterministic );
+
 /*=== giaCTas.c ===========================================================*/
 typedef struct Tas_Man_t_  Tas_Man_t;
 extern Tas_Man_t *         Tas_ManAlloc( Gia_Man_t * pAig, int nBTLimit );
@@ -1843,6 +1852,8 @@ extern void                 Bnd_ManPrintStats();
 // util
 extern Gia_Man_t*           Bnd_ManCutBoundary( Gia_Man_t *p, Vec_Int_t* vEI, Vec_Int_t* vEO, Vec_Bit_t* vEI_phase, Vec_Bit_t* vEO_phase );
 
+extern int                  Gia_ObjCheckMffc( Gia_Man_t * p, Gia_Obj_t * pRoot, int Limit, Vec_Int_t * vNodes, Vec_Int_t * vLeaves, Vec_Int_t * vInners );
+
 ABC_NAMESPACE_HEADER_END
 
 
diff --git a/src/aig/gia/giaAig.c b/src/aig/gia/giaAig.c
index c764a0993..07bab5fec 100644
--- a/src/aig/gia/giaAig.c
+++ b/src/aig/gia/giaAig.c
@@ -19,10 +19,12 @@
 ***********************************************************************/
 
 #include "giaAig.h"
+#include "aig/gia/gia.h"
 #include "proof/fra/fra.h"
 #include "proof/dch/dch.h"
 #include "opt/dar/dar.h"
 #include "opt/dau/dau.h"
+#include <assert.h>
 
 ABC_NAMESPACE_IMPL_START
 
@@ -191,6 +193,8 @@ Gia_Man_t * Gia_ManFromAigChoices( Aig_Man_t * p )
     Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) );
     //assert( Gia_ManObjNum(pNew) == Aig_ManObjNum(p) );
     //Gia_ManCheckChoices( pNew );
+    if ( pNew->pSibls )
+        Gia_ManDeriveReprsFromSibls( pNew );
     return pNew;
 }
 
diff --git a/src/aig/gia/giaAigerExt.c b/src/aig/gia/giaAigerExt.c
index d149b0a5e..d9f86f294 100644
--- a/src/aig/gia/giaAigerExt.c
+++ b/src/aig/gia/giaAigerExt.c
@@ -314,7 +314,7 @@ int Gia_AigerWriteCellMappingInstance( Gia_Man_t * p, unsigned char * pBuffer, i
 Vec_Str_t * Gia_AigerWriteCellMappingDoc( Gia_Man_t * p )
 {
     unsigned char * pBuffer;
-    int i, iFan, nCells = 0, nInstances = 0, nSize = 8, nSize2 = 0;
+    int i, nCells = 0, nInstances = 0, nSize = 8, nSize2 = 0;
     Mio_Cell2_t * pCells = Mio_CollectRootsNewDefault2( 6, &nCells, 0 );
     assert( pCells );
 
diff --git a/src/aig/gia/giaDeep.c b/src/aig/gia/giaDeep.c
index 8d563726f..3698c2cd7 100644
--- a/src/aig/gia/giaDeep.c
+++ b/src/aig/gia/giaDeep.c
@@ -162,6 +162,65 @@ Gia_Man_t * Gia_ManDeepSyn( Gia_Man_t * pGia, int nIters, int nNoImpr, int TimeO
     return pBest;
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Generating one AIG by applying a randomized script.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Gia_Man_t * Gia_ManRandSyn( Gia_Man_t * p, unsigned random_seed )
+{
+    char * pCompress2rs = "balance -l; resub -K 6 -l; rewrite -l; resub -K 6 -N 2 -l; refactor -l; resub -K 8 -l; balance -l; resub -K 8 -N 2 -l; rewrite -l; resub -K 10 -l; rewrite -z -l; resub -K 10 -N 2 -l; balance -l; resub -K 12 -l; refactor -z -l; resub -K 12 -N 2 -l; rewrite -z -l; balance -l";
+    unsigned Rand = random_seed;
+    int fDch = Rand & 1;
+    //int fCom = (Rand >> 1) & 3;
+    int fCom = (Rand >> 1) & 1;
+    int fFx  = (Rand >> 2) & 1;
+    int fUseTwo = 0;
+    int KLut = fUseTwo ? 2 + (Rand % 5) : 3 + (Rand % 4);
+    //int fChange = 0;
+    char Command[2000];
+    char pComp[1000];
+    if ( fCom == 3 )
+        sprintf( pComp, "; &put; %s; %s; %s; &get", pCompress2rs, pCompress2rs, pCompress2rs );
+    else if ( fCom == 2 )
+        sprintf( pComp, "; &put; %s; %s; &get", pCompress2rs, pCompress2rs );
+    else if ( fCom == 1 )
+        sprintf( pComp, "; &put; %s; &get", pCompress2rs );
+    else if ( fCom == 0 )
+        sprintf( pComp, "; &dc2" );
+    sprintf( Command, "&dch%s; &if -a -K %d; &mfs -e -W 20 -L 20%s%s",
+        fDch ? " -f" : "", KLut, fFx ? "; &fx; &st" : "", pComp );
+    Gia_Man_t * pOld = Abc_FrameGetGia(Abc_FrameGetGlobalFrame());
+    Abc_FrameUpdateGia( Abc_FrameGetGlobalFrame(), Gia_ManDup(p) );
+    if ( Abc_FrameIsBatchMode() )
+    {
+        if ( Cmd_CommandExecute(Abc_FrameGetGlobalFrame(), Command) )
+        {
+            Abc_Print( 1, "Something did not work out with the command \"%s\".\n", Command );
+            return NULL;
+        }
+    }
+    else
+    {
+        Abc_FrameSetBatchMode( 1 );
+        if ( Cmd_CommandExecute(Abc_FrameGetGlobalFrame(), Command) )
+        {
+            Abc_Print( 1, "Something did not work out with the command \"%s\".\n", Command );
+            return NULL;
+        }
+        Abc_FrameSetBatchMode( 0 );
+    }
+    Gia_Man_t * pRes = Abc_FrameGetGia(Abc_FrameGetGlobalFrame());
+    Abc_FrameUpdateGia( Abc_FrameGetGlobalFrame(), pOld );
+    return pRes;
+}
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/aig/gia/giaEquiv.c b/src/aig/gia/giaEquiv.c
index 09def827d..36e604153 100644
--- a/src/aig/gia/giaEquiv.c
+++ b/src/aig/gia/giaEquiv.c
@@ -310,6 +310,39 @@ void Gia_ManDeriveReprs( Gia_Man_t * p )
     }
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Given pSibls, derives original representitives and nexts.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void Gia_ManDeriveReprsFromSibls( Gia_Man_t *p )
+{
+    
+    int i, iObj;
+    assert( !p->pReprs && p->pSibls );
+    p->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(p) );
+    for ( i = 0; i < Gia_ManObjNum(p); i++ )
+        Gia_ObjSetRepr( p, i, GIA_VOID );
+    for ( i = 0; i < Gia_ManObjNum(p); i++ )
+    {
+        if ( p->pSibls[i] == 0 )
+            continue;
+        if ( p->pReprs[i].iRepr != GIA_VOID )
+            continue;
+        for ( iObj = p->pSibls[i]; iObj; iObj = p->pSibls[iObj] )
+            p->pReprs[iObj].iRepr = i;
+    }
+    ABC_FREE( p->pNexts );
+    p->pNexts = Gia_ManDeriveNexts( p );
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -2770,7 +2803,10 @@ void Gia_ManTransferEquivs2( Gia_Man_t * p, Gia_Man_t * pOld )
     {
         Vec_IntClear( vClass );
         Gia_ClassForEachObj( p, i, k )
-            Vec_IntPushUnique( vClass, Abc_Lit2Var(Gia_ManObj(p, k)->Value) );
+            if ( (int)Gia_ManObj(p, k)->Value >= 0 )
+                Vec_IntPushUnique( vClass, Abc_Lit2Var(Gia_ManObj(p, k)->Value) );
+        if ( Vec_IntSize( vClass ) <= 1 )
+            continue;
         assert( Vec_IntSize( vClass ) > 1 );
         Vec_IntSort( vClass, 0 );
         iRepr = Vec_IntEntry( vClass, 0 );
diff --git a/src/aig/gia/giaFx.c b/src/aig/gia/giaFx.c
index c20241ed1..7517072e7 100644
--- a/src/aig/gia/giaFx.c
+++ b/src/aig/gia/giaFx.c
@@ -217,7 +217,9 @@ Vec_Wec_t * Gia_ManFxRetrieve( Gia_Man_t * p, Vec_Str_t ** pvCompl, int fReverse
         int nVars = Gia_ObjLutSize( p, i );
         int * pVars = Gia_ObjLutFanins( p, i );
         word * pTruth = Vec_WrdEntryP( vTruths, Counter++ * nWords );
+        Abc_TtFlipVar5( pTruth, nVars );
         int Status = Kit_TruthIsop( (unsigned *)pTruth, nVars, vCover, 1 );
+        Abc_TtFlipVar5( pTruth, nVars );
         if ( Vec_IntSize(vCover) == 0 || (Vec_IntSize(vCover) == 1 && Vec_IntEntry(vCover,0) == 0) )
         {
             Vec_StrWriteEntry( *pvCompl, pObj->Value, (char)(Vec_IntSize(vCover) == 0) );
diff --git a/src/aig/gia/giaGen.c b/src/aig/gia/giaGen.c
index 03b194e7c..a807fe60f 100644
--- a/src/aig/gia/giaGen.c
+++ b/src/aig/gia/giaGen.c
@@ -1302,6 +1302,65 @@ Gia_Man_t * Gia_ManGenMux( int nIns, char * pNums )
     return p;
 }
 
+
+/**Function*************************************************************
+
+  Synopsis    [Generates N-bit sorter using pair-wise sorting algorithm.]
+
+  Description [https://en.wikipedia.org/wiki/Pairwise_sorting_network]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Gia_ManGenSorterOne( Gia_Man_t * p, int * pLits, int i, int k )
+{
+    int Lit1 = Gia_ManAppendAnd( p, pLits[i], pLits[k] );
+    int Lit2 = Gia_ManAppendOr ( p, pLits[i], pLits[k] );
+    pLits[i] = Lit1;
+    pLits[k] = Lit2;
+}
+static inline void Gia_ManGenSorterConstrMerge( Gia_Man_t * p, int * pLits, int lo, int hi, int r )
+{
+    int i, step = r * 2;
+    if ( step < hi - lo ) 
+    {
+        Gia_ManGenSorterConstrMerge( p, pLits, lo, hi-r, step );
+        Gia_ManGenSorterConstrMerge( p, pLits, lo+r, hi, step );
+        for ( i = lo+r; i < hi-r; i += step )
+            Gia_ManGenSorterOne( p, pLits, i, i+r );
+    }
+}
+static inline void Gia_ManGenSorterConstrRange( Gia_Man_t * p, int * pLits, int lo, int hi )
+{
+    if ( hi - lo >= 1 )
+    {
+        int i, mid = lo + (hi - lo) / 2;
+        for ( i = lo; i <= mid; i++ )
+            Gia_ManGenSorterOne( p, pLits, i, i + (hi - lo + 1) / 2 );
+        Gia_ManGenSorterConstrRange( p, pLits, lo, mid );
+        Gia_ManGenSorterConstrRange( p, pLits, mid+1, hi );
+        Gia_ManGenSorterConstrMerge( p, pLits, lo, hi, 1 );
+    }
+}
+Gia_Man_t * Gia_ManGenSorter( int LogN )
+{
+    int i, nVars = 1 << LogN;
+    int nVarsAlloc = nVars + 2 * (nVars * LogN * (LogN-1) / 4 + nVars - 1);
+    Vec_Int_t * vLits = Vec_IntAlloc( nVars );
+    Gia_Man_t * p = Gia_ManStart( 1 + 2*nVars + nVarsAlloc ); 
+    p->pName = Abc_UtilStrsav( "sorter" );
+    for ( i = 0; i < nVars; i++ )
+        Vec_IntPush( vLits, Gia_ManAppendCi(p) );
+    Gia_ManGenSorterConstrRange( p, Vec_IntArray(vLits), 0, nVars - 1 );
+    for ( i = 0; i < nVars; i++ )
+        Gia_ManAppendCo( p, Vec_IntEntry(vLits, i) );
+    Vec_IntFree( vLits );
+    return p;
+}
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/aig/gia/giaMan.c b/src/aig/gia/giaMan.c
index 8ce1db834..d0af551b0 100644
--- a/src/aig/gia/giaMan.c
+++ b/src/aig/gia/giaMan.c
@@ -807,7 +807,7 @@ void Gia_ManPrintNpnClasses( Gia_Man_t * p )
     int i, k, iFan, Class, OtherClasses, OtherClasses2, nTotal, Counter, Counter2;
     unsigned * pTruth; int nLutSize = 0;
     assert( Gia_ManHasMapping(p) );
-    assert(  Gia_ManLutSizeMax( p ) <= 4 );
+    //assert(  Gia_ManLutSizeMax( p ) <= 4 );
     vLeaves   = Vec_IntAlloc( 100 );
     vVisited  = Vec_IntAlloc( 100 );
     vTruth    = Vec_IntAlloc( (1<<16) );
diff --git a/src/aig/gia/giaMfs.c b/src/aig/gia/giaMfs.c
index f4a841510..81eb298d3 100644
--- a/src/aig/gia/giaMfs.c
+++ b/src/aig/gia/giaMfs.c
@@ -422,7 +422,9 @@ Gia_Man_t * Gia_ManInsertMfs( Gia_Man_t * p, Sfm_Ntk_t * pNtk, int fAllBoxes )
                 int nVarsNew;
                 Abc_TtSimplify( pTruth, Vec_IntArray(vLeaves), Vec_IntSize(vLeaves), &nVarsNew );
                 Vec_IntShrink( vLeaves, nVarsNew );
+                Abc_TtFlipVar5( pTruth, Vec_IntSize(vLeaves) );
                 iLitNew = Gia_ManFromIfLogicCreateLut( pNew, pTruth, vLeaves, vCover, vMapping, vMapping2 );
+                Abc_TtFlipVar5( pTruth, Vec_IntSize(vLeaves) );
                 if ( MapSize < Vec_IntSize(vMapping2) )
                 {
                     assert( Vec_IntEntryLast(vMapping2) == Abc_Lit2Var(iLitNew) );
@@ -430,7 +432,11 @@ Gia_Man_t * Gia_ManInsertMfs( Gia_Man_t * p, Sfm_Ntk_t * pNtk, int fAllBoxes )
                 }
             }
             else
+            {
+                Abc_TtFlipVar5( pTruth, Vec_IntSize(vLeaves) );
                 iLitNew = Gia_ManFromIfLogicCreateLut( pNew, pTruth, vLeaves, vCover, vMapping, vMapping2 );
+                Abc_TtFlipVar5( pTruth, Vec_IntSize(vLeaves) );
+            }
         }
         else // internal CO
         {
diff --git a/src/aig/gia/giaMini.c b/src/aig/gia/giaMini.c
index 5f7ca0d57..5ebedfb78 100644
--- a/src/aig/gia/giaMini.c
+++ b/src/aig/gia/giaMini.c
@@ -555,6 +555,23 @@ char * Abc_FrameGiaOutputMiniLutAttr( Abc_Frame_t * pAbc, void * pMiniLut )
         printf( "Current network in ABC framework is not defined.\n" );
     return Gia_ManToMiniLutAttr( pGia, pMiniLut );
 }
+int * Abc_FrameGiaOutputMiniLutObj( Abc_Frame_t * pAbc )
+{
+    int * pRes = NULL;
+    if ( pAbc == NULL )
+        printf( "ABC framework is not initialized by calling Abc_Start()\n" );
+    if ( pAbc->vMiniLutObjs == NULL )
+        printf( "MiniLut objects are not defined.\n" );
+    pRes = Vec_IntReleaseArray( pAbc->vMiniLutObjs );
+    Vec_IntFreeP( &pAbc->vMiniLutObjs );    
+    return pRes;
+}
+void Abc_FrameSetObjDelays( Abc_Frame_t * pAbc, int * pDelays, int nDelays )
+{
+    Vec_IntFreeP( &pAbc->vObjDelays );
+    pAbc->vObjDelays = Vec_IntAllocArrayCopy( pDelays, nDelays );
+}
+
 
 /**Function*************************************************************
 
diff --git a/src/aig/gia/giaNf.c b/src/aig/gia/giaNf.c
index f41d8dd49..f70a63135 100644
--- a/src/aig/gia/giaNf.c
+++ b/src/aig/gia/giaNf.c
@@ -1172,7 +1172,10 @@ void Nf_ManCutMatchOne( Nf_Man_t * p, int iObj, int * pCut, int * pCutSet )
             if ( ArrivalA + pC->iDelays[k] <= Required && Required != SCL_INFINITY )
             {
                 Delay = Abc_MaxInt( Delay, ArrivalA + pC->iDelays[k] );
-                AreaF += pBestF[iFanin]->M[fComplF][1].F;
+                if ( AreaF >= (float)1e32 || pBestF[iFanin]->M[fComplF][1].F >= (float)1e32 )
+                    AreaF = (float)1e32;
+                else
+                    AreaF += pBestF[iFanin]->M[fComplF][1].F;
             }
             else 
             {
@@ -1617,8 +1620,7 @@ int Nf_ManSetMapRefs( Nf_Man_t * p )
                 p->pPars->Area++;
                 p->nInvs++;
             }            
-            reqTime = Abc_MinInt( Nf_ObjRequired(p, i, 0), Nf_ObjRequired(p, i, 1) );
-            Tim_ManSetCiRequired( p->pManTim, Gia_ObjCioId(pObj), reqTime );            
+            Tim_ManSetCiRequired( p->pManTim, Gia_ObjCioId(pObj), Nf_ObjRequired(p, i, 0) );            
             continue;
         }
         if ( Gia_ObjIsCo(pObj) ) 
@@ -1930,7 +1932,9 @@ void Nf_ManResetMatches( Nf_Man_t * p, int Round )
     Nf_Mat_t * pDc, * pAc, * pMfan, * pM[2]; 
     int i, c, Arrival;
     // go through matches in the topo order
-    Gia_ManForEachAnd( p->pGia, pObj, i )
+    if ( p->pManTim )
+        Tim_ManIncrementTravId( p->pManTim );      
+    Gia_ManForEachObjWithBoxes( p->pGia, pObj, i )
     {
         if ( Gia_ObjIsBuf(pObj) )
         {
@@ -1947,6 +1951,18 @@ void Nf_ManResetMatches( Nf_Man_t * p, int Round )
             }
             continue;
         }
+        if ( Gia_ObjIsCi(pObj) ) 
+        {
+            Arrival = Tim_ManGetCiArrival( p->pManTim, Gia_ObjCioId(pObj) );
+            Nf_ObjPrepareCi( p, i, Arrival );
+            continue;
+        }
+        if ( Gia_ObjIsCo(pObj) ) 
+        {
+            Arrival = Nf_ObjMatchD( p, Gia_ObjFaninId0(pObj, i), Gia_ObjFaninC0(pObj) )->D;
+            Tim_ManSetCoArrival( p->pManTim, Gia_ObjCioId(pObj), Arrival );
+            continue;
+        }
         // select the best match for each phase
         for ( c = 0; c < 2; c++ )
         {
@@ -2019,29 +2035,38 @@ void Nf_ManComputeMappingEla( Nf_Man_t * p )
     Mio_Cell2_t * pCell;
     Nf_Mat_t Mb, * pMb = &Mb, * pM;
     word AreaBef, AreaAft, Gain = 0;
-    int i, c, iVar, Id, fCompl, k, * pCut, reqTime;
-    int Required;
-    Nf_ManSetOutputRequireds( p, 1 );
+    int i, c, iVar, Id, fCompl, k, * pCut, Required;
     Nf_ManResetMatches( p, p->Iter - p->pPars->nRounds );
+    Nf_ManSetOutputRequireds( p, 1 );
     Gia_ManForEachObjReverseWithBoxes( p->pGia, pObj, i )
     {
         if ( Gia_ObjIsBuf(pObj) )
         {
             if ( Nf_ObjMapRefNum(p, i, 1) )
                 Nf_ObjUpdateRequired( p, i, 0, Nf_ObjRequired(p, i, 1) - p->InvDelayI );
-            Nf_ObjUpdateRequired( p, Gia_ObjFaninId0(pObj, i), Gia_ObjFaninC0(pObj), Nf_ObjRequired(p, i, 0) );
+            int reqTime = Nf_ObjRequired(p, i, 0);
+            int iObj    = Gia_ObjFaninId0p(p->pGia, pObj);
+            int fCompl  = Gia_ObjFaninC0(pObj);
+            Nf_ObjUpdateRequired( p, iObj, fCompl, reqTime );
+            if ( iObj > 0 && Nf_ObjMatchBest(p, iObj, fCompl)->fCompl )
+                Nf_ObjUpdateRequired( p, iObj, !fCompl, reqTime - p->InvDelayI );
             continue;
         }
         if ( Gia_ObjIsCi(pObj) ) 
         {
-            reqTime = Abc_MinInt( Nf_ObjRequired(p, i, 0), Nf_ObjRequired(p, i, 1) );
-            Tim_ManSetCiRequired( p->pManTim, Gia_ObjCioId(pObj), reqTime );            
+            if ( Nf_ObjMapRefNum(p, i, 1) )
+                Nf_ObjUpdateRequired( p, i, 0, Nf_ObjRequired(p, i, 1) - p->InvDelayI ); 
+            Tim_ManSetCiRequired( p->pManTim, Gia_ObjCioId(pObj), Nf_ObjRequired(p, i, 0) );            
             continue;
         }
         if ( Gia_ObjIsCo(pObj) ) 
         {
-            reqTime = Tim_ManGetCoRequired( p->pManTim, Gia_ObjCioId(pObj) );
-            Nf_ObjUpdateRequired( p, Gia_ObjFaninId0(pObj, i), Gia_ObjFaninC0(pObj), reqTime );        
+            int reqTime = Tim_ManGetCoRequired( p->pManTim, Gia_ObjCioId(pObj) );
+            int iObj    = Gia_ObjFaninId0p(p->pGia, pObj);
+            int fCompl  = Gia_ObjFaninC0(pObj);
+            Nf_ObjUpdateRequired( p, iObj, fCompl, reqTime );
+            if ( iObj > 0 && Nf_ObjMatchBest(p, iObj, fCompl)->fCompl )
+                Nf_ObjUpdateRequired( p, iObj, !fCompl, reqTime - p->InvDelayI );
             continue;
         }        
         for ( c = 0; c < 2; c++ )
diff --git a/src/aig/gia/giaPat2.c b/src/aig/gia/giaPat2.c
index 93c4b1da9..b0839f5d4 100644
--- a/src/aig/gia/giaPat2.c
+++ b/src/aig/gia/giaPat2.c
@@ -965,6 +965,12 @@ Vec_Wec_t * Min_ManComputeCexes( Gia_Man_t * p, Vec_Int_t * vOuts0, int nMaxTrie
         if ( Vec_IntEntry(vStats[2], i) >= nMinCexes || Vec_IntEntry(vStats[1], i) > 10*Vec_IntEntry(vStats[2], i) )
             continue;
         {
+            assert( Gia_ObjIsCo(pObj) );
+            if ( Gia_ObjFaninId0p(p, pObj) == 0 ) {
+                if ( fVerbose )
+                    printf( "Output %d is driven by constant %d.\n", Gia_ObjCioId(pObj), Gia_ObjFaninC0(pObj) );
+                continue;
+            }
             abctime clk = Abc_Clock();
             int iObj  = Min_ManCo(pNew, i);
             int Index = Gia_ObjCioId(pObj);
diff --git a/src/aig/gia/giaResub.c b/src/aig/gia/giaResub.c
index fc6fd7bf0..a4141a050 100644
--- a/src/aig/gia/giaResub.c
+++ b/src/aig/gia/giaResub.c
@@ -68,7 +68,7 @@ int Gia_ObjCheckMffc_rec( Gia_Man_t * p,Gia_Obj_t * pObj, int Limit, Vec_Int_t *
         return 0;
     return 1;
 }
-static inline int Gia_ObjCheckMffc( Gia_Man_t * p, Gia_Obj_t * pRoot, int Limit, Vec_Int_t * vNodes, Vec_Int_t * vLeaves, Vec_Int_t * vInners )
+int Gia_ObjCheckMffc( Gia_Man_t * p, Gia_Obj_t * pRoot, int Limit, Vec_Int_t * vNodes, Vec_Int_t * vLeaves, Vec_Int_t * vInners )
 {
     int RetValue, iObj, i;
     Vec_IntClear( vNodes );
diff --git a/src/aig/gia/giaRrr.cpp b/src/aig/gia/giaRrr.cpp
new file mode 100644
index 000000000..df3b91e60
--- /dev/null
+++ b/src/aig/gia/giaRrr.cpp
@@ -0,0 +1,37 @@
+#include "aig/gia/gia.h"
+
+#include "opt/rrr/rrr.h"
+#include "opt/rrr/rrrAbc.h"
+
+ABC_NAMESPACE_IMPL_START
+
+Gia_Man_t *Gia_ManRrr(Gia_Man_t *pGia, int iSeed, int nWords, int nTimeout, int nSchedulerVerbose, int nPartitionerVerbose, int nOptimizerVerbose, int nAnalyzerVerbose, int nSimulatorVerbose, int nSatSolverVerbose, int fUseBddCspf, int fUseBddMspf, int nConflictLimit, int nSortType, int nOptimizerFlow, int nSchedulerFlow, int nDistance, int nRestarts, int nThreads, int nWindowSize, int fDeterministic) {
+  rrr::AndNetwork ntk;
+  ntk.Read(pGia, rrr::GiaReader<rrr::AndNetwork>);
+  rrr::Parameter Par;
+  Par.iSeed = iSeed;
+  Par.nWords = nWords;
+  Par.nTimeout = nTimeout;
+  Par.nSchedulerVerbose = nSchedulerVerbose;
+  Par.nPartitionerVerbose = nPartitionerVerbose;
+  Par.nOptimizerVerbose = nOptimizerVerbose;
+  Par.nAnalyzerVerbose = nAnalyzerVerbose;
+  Par.nSimulatorVerbose = nSimulatorVerbose;
+  Par.nSatSolverVerbose = nSatSolverVerbose;
+  Par.fUseBddCspf = fUseBddCspf;
+  Par.fUseBddMspf = fUseBddMspf;
+  Par.nConflictLimit = nConflictLimit;
+  Par.nSortType = nSortType;
+  Par.nOptimizerFlow = nOptimizerFlow;
+  Par.nSchedulerFlow = nSchedulerFlow;
+  Par.nDistance = nDistance;
+  Par.nRestarts = nRestarts;
+  Par.nThreads = nThreads;
+  Par.nWindowSize = nWindowSize;
+  Par.fDeterministic = fDeterministic;
+  rrr::Perform(&ntk, &Par);
+  Gia_Man_t *pNew = rrr::CreateGia(&ntk);
+  return pNew;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/aig/gia/giaSatLut.c b/src/aig/gia/giaSatLut.c
index 20074b46d..ba25ec90e 100644
--- a/src/aig/gia/giaSatLut.c
+++ b/src/aig/gia/giaSatLut.c
@@ -25,6 +25,12 @@
 #include "map/scl/sclCon.h"
 #include "misc/vec/vecHsh.h"
 
+#ifdef _MSC_VER
+#define unlink _unlink
+#else
+#include <unistd.h>
+#endif
+
 ABC_NAMESPACE_IMPL_START
 
 
@@ -1216,6 +1222,351 @@ void Gia_ManLutSat( Gia_Man_t * pGia, int LutSize, int nNumber, int nImproves, i
     Vec_IntFreeP( &pGia->vPacking );
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Gia_RunKadical( char * pFileNameIn, char * pFileNameOut, int nBTLimit, int TimeOut, int fVerbose )
+{
+    extern Vec_Int_t * Exa4_ManParse( char *pFileName );
+    int fVerboseSolver = 0;
+    abctime clkTotal = Abc_Clock();
+    Vec_Int_t * vRes = NULL;
+#ifdef _WIN32
+    char * pKadical = "kadical.exe";
+#else
+    char * pKadical = "kadical";
+#endif
+    char Command[1000], * pCommand = (char *)&Command;
+    if ( nBTLimit ) {
+        if ( TimeOut )
+            sprintf( pCommand, "%s -c %d -t %d %s %s > %s", pKadical, nBTLimit, TimeOut, fVerboseSolver ? "": "-q", pFileNameIn, pFileNameOut );
+        else
+            sprintf( pCommand, "%s -c %d  %s %s > %s", pKadical, nBTLimit, fVerboseSolver ? "": "-q", pFileNameIn, pFileNameOut );
+    }
+    else {
+        if ( TimeOut )
+            sprintf( pCommand, "%s -t %d %s %s > %s", pKadical, TimeOut, fVerboseSolver ? "": "-q", pFileNameIn, pFileNameOut );
+        else
+            sprintf( pCommand, "%s %s %s > %s", pKadical, fVerboseSolver ? "": "-q", pFileNameIn, pFileNameOut );
+    }
+#ifdef __wasm
+    if ( 1 )
+#else
+    if ( system( pCommand ) == -1 )
+#endif
+    {
+        fprintf( stdout, "Command \"%s\" did not succeed.\n", pCommand );
+        return 0;
+    }
+    vRes = Exa4_ManParse( pFileNameOut );
+    if ( fVerbose )
+    {
+        if ( vRes )
+            printf( "The problem has a solution. " );
+        else if ( vRes == NULL && TimeOut == 0 )
+            printf( "The problem has no solution. " );
+        else if ( vRes == NULL )
+            printf( "The problem has no solution or reached a resource limit after %d sec. ", TimeOut );
+        Abc_PrintTime( 1, "SAT solver time", Abc_Clock() - clkTotal );
+    }
+    return vRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Gia_SatVarReqPos( int i ) { return i*7+0; } // p
+int Gia_SatVarReqNeg( int i ) { return i*7+1; } // n
+int Gia_SatVarAckPos( int i ) { return i*7+2; } // P
+int Gia_SatVarAckNeg( int i ) { return i*7+3; } // N
+int Gia_SatVarInv   ( int i ) { return i*7+4; } // i
+int Gia_SatVarFan0  ( int i ) { return i*7+5; } // 0
+int Gia_SatVarFan1  ( int i ) { return i*7+6; } // 1
+
+int Gia_SatValReqPos( Vec_Int_t * p, int i ) { return Vec_IntEntry(p, i*7+0); } // p
+int Gia_SatValReqNeg( Vec_Int_t * p, int i ) { return Vec_IntEntry(p, i*7+1); } // n
+int Gia_SatValAckPos( Vec_Int_t * p, int i ) { return Vec_IntEntry(p, i*7+2); } // P
+int Gia_SatValAckNeg( Vec_Int_t * p, int i ) { return Vec_IntEntry(p, i*7+3); } // N
+int Gia_SatValInv   ( Vec_Int_t * p, int i ) { return Vec_IntEntry(p, i*7+4); } // i
+int Gia_SatValFan0  ( Vec_Int_t * p, int i ) { return Vec_IntEntry(p, i*7+5); } // 0
+int Gia_SatValFan1  ( Vec_Int_t * p, int i ) { return Vec_IntEntry(p, i*7+6); } // 1
+
+void Gia_SatDumpClause( Vec_Str_t * vStr, int * pLits, int nLits )
+{
+    for ( int i = 0; i < nLits; i++ )
+        Vec_StrPrintF( vStr, "%d ", Abc_LitIsCompl(pLits[i]) ? -Abc_Lit2Var(pLits[i])-1 : Abc_Lit2Var(pLits[i])+1 );
+    Vec_StrPrintF( vStr, "0\n" );        
+}
+void Gia_SatDumpLiteral( Vec_Str_t * vStr, int Lit )
+{
+    Gia_SatDumpClause( vStr, &Lit, 1 );
+}
+void Gia_SatDumpKlause( Vec_Str_t * vStr, int nIns, int nAnds, int nBound )
+{
+    int i, nVars = nIns + 7*nAnds;
+    Vec_StrPrintF( vStr, "k %d ", nVars - nBound );
+    // counting primary inputs: n
+    for ( i = 0; i < nIns; i++ )
+        Vec_StrPrintF( vStr, "-%d ", Gia_SatVarReqNeg(1+i)+1 );
+    // counting internal nodes: p, n, P, N, i, 0, 1
+    for ( i = 0; i < 7*nAnds; i++ )
+        Vec_StrPrintF( vStr, "-%d ", (1+nIns)*7+i+1 );
+    Vec_StrPrintF( vStr, "0\n" );
+}
+
+Vec_Str_t * Gia_ManSimpleCnf( Gia_Man_t * p, int nBound )
+{
+    Vec_Str_t * vStr = Vec_StrAlloc( 10000 );    
+    Gia_SatDumpKlause( vStr, Gia_ManCiNum(p), Gia_ManAndNum(p), nBound );    
+    int i, n, m, Id, pLits[4]; Gia_Obj_t * pObj;
+    for ( n = 0; n < 7; n++ )
+        Gia_SatDumpLiteral( vStr, Abc_Var2Lit(n, 1) );    
+    // acknowledge positive PI literals
+    Gia_ManForEachCiId( p, Id, i )
+        for ( n = 0; n < 7; n++ )  if ( n != 1 )
+            Gia_SatDumpLiteral( vStr, Abc_Var2Lit(Gia_SatVarReqPos(Id)+n, n>0) );
+    // require driving PO literals
+    Gia_ManForEachCo( p, pObj, i )
+        Gia_SatDumpLiteral( vStr, Abc_Var2Lit( Gia_SatVarReqPos(Gia_ObjFaninId0p(p, pObj)) + Gia_ObjFaninC0(pObj), 0 ) );
+    // internal nodes
+    Gia_ManForEachAnd( p, pObj, i ) {
+        int fCompl[2] = { Gia_ObjFaninC0(pObj), Gia_ObjFaninC1(pObj) };
+        int iFans[2]  = { Gia_ObjFaninId0(pObj, i), Gia_ObjFaninId1(pObj, i) };
+        Gia_Obj_t * pFans[2] = { Gia_ObjFanin0(pObj), Gia_ObjFanin1(pObj) };
+        // require inverter: p & !n & N -> i, n & !p & P -> i
+        for ( n = 0; n < 2; n++ ) {
+            pLits[0] = Abc_Var2Lit( Gia_SatVarReqPos(i)+n, 1 );
+            pLits[1] = Abc_Var2Lit( Gia_SatVarReqNeg(i)-n, 0 );
+            pLits[2] = Abc_Var2Lit( Gia_SatVarAckNeg(i)-n, 1 );
+            pLits[3] = Abc_Var2Lit( Gia_SatVarInv   (i), 0 );
+            Gia_SatDumpClause( vStr, pLits, 4 );
+        }
+        // exclusive acknowledge: !P + !N
+        pLits[0] = Abc_Var2Lit( Gia_SatVarAckPos(i), 1 );
+        pLits[1] = Abc_Var2Lit( Gia_SatVarAckNeg(i), 1 );
+        Gia_SatDumpClause( vStr, pLits, 2 );
+        // required acknowledge: p -> P + N, n -> P + N
+        pLits[1] = Abc_Var2Lit( Gia_SatVarAckPos(i), 0 );
+        pLits[2] = Abc_Var2Lit( Gia_SatVarAckNeg(i), 0 );
+        pLits[0] = Abc_Var2Lit( Gia_SatVarReqPos(i), 1 );
+        Gia_SatDumpClause( vStr, pLits, 3 );
+        pLits[0] = Abc_Var2Lit( Gia_SatVarReqNeg(i), 1 );
+        Gia_SatDumpClause( vStr, pLits, 3 );
+        // forbid acknowledge: !p & !n -> !P, !p & !n -> !N
+        pLits[0] = Abc_Var2Lit( Gia_SatVarReqPos(i), 0 );
+        pLits[1] = Abc_Var2Lit( Gia_SatVarReqNeg(i), 0 );
+        pLits[2] = Abc_Var2Lit( Gia_SatVarAckPos(i), 1 );
+        Gia_SatDumpClause( vStr, pLits, 3 );
+        pLits[2] = Abc_Var2Lit( Gia_SatVarAckNeg(i), 1 );
+        Gia_SatDumpClause( vStr, pLits, 3 );
+        // when fanins can be used: !N & !P -> !0, !N & !P -> !1
+        pLits[0] = Abc_Var2Lit( Gia_SatVarAckPos(i), 0 );
+        pLits[1] = Abc_Var2Lit( Gia_SatVarAckNeg(i), 0 );
+        pLits[2] = Abc_Var2Lit( Gia_SatVarFan0(i), 1 );
+        Gia_SatDumpClause( vStr, pLits, 3 );
+        pLits[2] = Abc_Var2Lit( Gia_SatVarFan1(i), 1 );
+        Gia_SatDumpClause( vStr, pLits, 3 );
+        // when fanins are not used: 0 -> !N, 0 -> !P, 1 -> !N, 1 -> !P
+        for ( m = 0; m < 2; m++ )
+        for ( n = 0; n < 2; n++ ) {
+            pLits[0] = Abc_Var2Lit( Gia_SatVarFan0(i)+n, 1 );
+            pLits[1] = Abc_Var2Lit( Gia_SatVarReqPos(iFans[n])+m, 1 );
+            Gia_SatDumpClause( vStr, pLits, 2 );
+        }
+        // can only extend both when both complemented: !(C0 & C1) -> !0 + !1 
+        pLits[0] = Abc_Var2Lit( Gia_SatVarFan0(i), 1 );
+        pLits[1] = Abc_Var2Lit( Gia_SatVarFan1(i), 1 );
+        if ( !fCompl[0] || !fCompl[1] )
+            Gia_SatDumpClause( vStr, pLits, 2 );
+        // if fanin is a primary input, cannot extend it (pi -> !0 or pi -> !1)
+        for ( n = 0; n < 2; n++ )
+            if ( Gia_ObjIsCi(pFans[n]) )
+                Gia_SatDumpLiteral( vStr, Abc_Var2Lit( Gia_SatVarFan0(i)+n, 1 ) );
+        // propagating assignments when fanin is not used
+        // P & !0 -> C0 ? P0 : N0
+        // N & !0 -> C0 ? N0 : P0
+        // P & !1 -> C1 ? P1 : N1
+        // N & !1 -> C1 ? N1 : P1
+        for ( m = 0; m < 2; m++ )
+        for ( n = 0; n < 2; n++ ) {
+            pLits[0] = Abc_Var2Lit( Gia_SatVarAckPos(i)+m, 1 );
+            pLits[1] = Abc_Var2Lit( Gia_SatVarFan0(i)+n, 0 );
+            pLits[2] = Abc_Var2Lit( Gia_SatVarReqPos(iFans[n]) + !(m ^ fCompl[n]), 0 );
+            Gia_SatDumpClause( vStr, pLits, 3 );
+        }
+        // propagating assignments when fanins are used
+        // P & 0 -> (C0 ^ C00) ? P00 : N00
+        // P & 0 -> (C0 ^ C01) ? P01 : N01
+        // N & 0 -> (C0 ^ C00) ? N00 : P00
+        // N & 0 -> (C0 ^ C01) ? N01 : P01
+        // P & 1 -> (C1 ^ C10) ? P10 : N10
+        // P & 1 -> (C1 ^ C11) ? P11 : N11
+        // N & 1 -> (C1 ^ C10) ? N10 : P10
+        // N & 1 -> (C1 ^ C11) ? N11 : P11
+        for ( m = 0; m < 2; m++ ) 
+        for ( n = 0; n < 2; n++ )
+        if ( Gia_ObjIsAnd(pFans[n]) ) {
+            pLits[0] = Abc_Var2Lit( Gia_SatVarAckPos(i)+m, 1 );
+            pLits[1] = Abc_Var2Lit( Gia_SatVarFan0(i)+n, 1 );
+            pLits[2] = Abc_Var2Lit( Gia_SatVarReqPos(Gia_ObjFaninId0p(p, pFans[n])) + !(m ^ fCompl[n] ^ Gia_ObjFaninC0(pFans[n])), 0 );
+            Gia_SatDumpClause( vStr, pLits, 3 );
+            pLits[2] = Abc_Var2Lit( Gia_SatVarReqPos(Gia_ObjFaninId1p(p, pFans[n])) + !(m ^ fCompl[n] ^ Gia_ObjFaninC1(pFans[n])), 0 );
+            Gia_SatDumpClause( vStr, pLits, 3 );
+        }
+    }
+    Vec_StrPush( vStr, '\0' );
+    return vStr;
+}
+
+typedef enum { 
+    GIA_GATE_ZERO,     // 0: 
+    GIA_GATE_ONE,      // 1: 
+    GIA_GATE_BUF,      // 2: 
+    GIA_GATE_INV,      // 3: 
+    GIA_GATE_NAN2,     // 4: 
+    GIA_GATE_NOR2,     // 5: 
+    GIA_GATE_AOI21,    // 6: 
+    GIA_GATE_NAN3,     // 7: 
+    GIA_GATE_NOR3,     // 8: 
+    GIA_GATE_OAI21,    // 9: 
+    GIA_GATE_AOI22,    // 10: 
+    GIA_GATE_OAI22,    // 11: 
+    RTM_VAL_VOID       // 12: unused value
+} Gia_ManGate_t;
+
+Vec_Int_t * Gia_ManDeriveSimpleMapping( Gia_Man_t * p, Vec_Int_t * vRes )
+{
+    Vec_Int_t * vMapping = Vec_IntStart( 2*Gia_ManObjNum(p) );
+    int i, Id; Gia_Obj_t * pObj;
+    Gia_ManForEachCiId( p, Id, i )
+        if ( Gia_SatValReqNeg(vRes, Id) )
+            Vec_IntWriteEntry( vMapping, Abc_Var2Lit(Id, 1), -1 );
+    Gia_ManForEachAnd( p, pObj, i )
+    {
+        if ( Gia_SatValAckPos(vRes, i) + Gia_SatValAckNeg(vRes, i) == 0 )
+            continue;
+        assert( Gia_SatValAckPos(vRes, i) != Gia_SatValAckNeg(vRes, i) );
+        if ( (Gia_SatValReqPos(vRes, i) && Gia_SatValReqNeg(vRes, i)) || Gia_SatValInv(vRes, i) )
+            Vec_IntWriteEntry( vMapping, Abc_Var2Lit(i, Gia_SatValAckPos(vRes, i)), -1 );
+        int fComp = Gia_SatValAckNeg(vRes, i);
+        int fFan0 = Gia_SatValFan0(vRes, i);
+        int fFan1 = Gia_SatValFan1(vRes, i);
+        Gia_Obj_t * pFans[2] = { Gia_ObjFanin0(pObj), Gia_ObjFanin1(pObj) };
+        Vec_IntWriteEntry( vMapping, Abc_Var2Lit(i, fComp), Vec_IntSize(vMapping) );
+        if ( fFan0 && fFan1 ) {
+            assert( Gia_ObjFaninC0(pObj) && Gia_ObjFaninC1(pObj) );
+            Vec_IntPush( vMapping, 4 );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId0p(p, pFans[0]), !(fComp ^ Gia_ObjFaninC0(pObj) ^ Gia_ObjFaninC0(pFans[0]))) );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId1p(p, pFans[0]), !(fComp ^ Gia_ObjFaninC0(pObj) ^ Gia_ObjFaninC1(pFans[0]))) );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId0p(p, pFans[1]), !(fComp ^ Gia_ObjFaninC1(pObj) ^ Gia_ObjFaninC0(pFans[1]))) );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId1p(p, pFans[1]), !(fComp ^ Gia_ObjFaninC1(pObj) ^ Gia_ObjFaninC1(pFans[1]))) );
+            Vec_IntPush( vMapping, fComp ? GIA_GATE_OAI22 : GIA_GATE_AOI22 );
+        } else if ( fFan0 ) {
+            Vec_IntPush( vMapping, 3 );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId0p(p, pFans[0]), !(fComp ^ Gia_ObjFaninC0(pObj) ^ Gia_ObjFaninC0(pFans[0]))) );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId1p(p, pFans[0]), !(fComp ^ Gia_ObjFaninC0(pObj) ^ Gia_ObjFaninC1(pFans[0]))) );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId1p(p, pObj),     !(fComp ^ Gia_ObjFaninC1(pObj))) );
+            if ( Gia_ObjFaninC0(pObj) )
+                Vec_IntPush( vMapping, fComp ? GIA_GATE_OAI21 : GIA_GATE_AOI21 );
+            else
+                Vec_IntPush( vMapping, fComp ? GIA_GATE_NAN3 : GIA_GATE_NOR3 );
+        } else if ( fFan1 ) {
+            Vec_IntPush( vMapping, 3 );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId0p(p, pFans[1]), !(fComp ^ Gia_ObjFaninC1(pObj) ^ Gia_ObjFaninC0(pFans[1]))) );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId1p(p, pFans[1]), !(fComp ^ Gia_ObjFaninC1(pObj) ^ Gia_ObjFaninC1(pFans[1]))) );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId0p(p, pObj),     !(fComp ^ Gia_ObjFaninC0(pObj))) );
+            if ( Gia_ObjFaninC1(pObj) )
+                Vec_IntPush( vMapping, fComp ? GIA_GATE_OAI21 : GIA_GATE_AOI21 );
+            else
+                Vec_IntPush( vMapping, fComp ? GIA_GATE_NAN3 : GIA_GATE_NOR3 );
+        } else {
+            Vec_IntPush( vMapping, 2 );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId0p(p, pObj),     !(fComp ^ Gia_ObjFaninC0(pObj))) );
+            Vec_IntPush( vMapping, Abc_Var2Lit(Gia_ObjFaninId1p(p, pObj),     !(fComp ^ Gia_ObjFaninC1(pObj))) );
+            Vec_IntPush( vMapping, fComp ? GIA_GATE_NAN2 : GIA_GATE_NOR2 );
+        }
+    }
+    return vMapping;
+}
+void Gia_ManSimplePrintMapping( Vec_Int_t * vRes, int nIns )
+{    
+    int i, k, nObjs = Vec_IntSize(vRes)/7, nSteps = Abc_Base10Log(nObjs);
+    int nCard = Vec_IntSum(vRes) - nIns; char NumStr[10];
+    printf( "Solution with cardinality %d:\n", nCard );
+    for ( k = 0; k < nSteps; k++ ) {        
+        printf( "  " );
+        for ( i = 0; i < nObjs; i++ ) {            
+            sprintf( NumStr, "%02d", i );
+            printf( "%c", NumStr[k] );
+        }
+        printf( "\n" );
+    }
+    for ( k = 0; k < 7; k++ ) {
+        printf( "%c ", "pnPNi01"[k] );
+        for ( i = 0; i < nObjs; i++ )
+            if ( Vec_IntEntry( vRes, i*7+k ) == 0 )
+                printf( " " );
+            else
+                printf( "1" );
+        printf( "\n" );
+    }
+}
+int Gia_ManDumpCnf( char * pFileName, Vec_Str_t * vStr, int nVars )
+{
+    FILE * pFile = fopen( pFileName, "wb" );
+    if ( pFile == NULL ) { printf( "Cannot open input file \"%s\".\n", pFileName ); return 0; }
+    fprintf( pFile, "p knf %d %d\n%s\n", nVars, Vec_StrCountEntry(vStr, '\n'), Vec_StrArray(vStr) );
+    fclose( pFile );
+    return 1;
+}
+int Gia_ManSimpleMapping( Gia_Man_t * p, int nBound, int nBTLimit, int nTimeout, int fVerbose )
+{
+    char * pFileNameI = (char *)"__temp__.cnf"; 
+    char * pFileNameO = (char *)"__temp__.out";
+    if ( nBound == 0 ) 
+        nBound = 5 * Gia_ManAndNum(p);
+    Vec_Str_t * vStr = Gia_ManSimpleCnf( p, nBound/2 );
+    int nVars = 7*(Gia_ManObjNum(p)-Gia_ManCoNum(p));
+    if ( !Gia_ManDumpCnf(pFileNameI, vStr, nVars) ) {
+        Vec_StrFree( vStr );
+        return 0;
+    }
+    if ( fVerbose )
+        printf( "SAT variables = %d. SAT clauses = %d. Cardinality bound = %d. Conflict limit = %d. Timeout = %d.\n", 
+            nVars, Vec_StrCountEntry(vStr, '\n'), nBound, nBTLimit, nTimeout );
+    //char pFileName[100]; sprintf( pFileName, "temp%02d.cnf", nBound/2 );
+    //Gia_ManDumpCnf( pFileName, vStr, nVars );
+    Vec_StrFree( vStr );
+    Vec_Int_t * vRes = Gia_RunKadical( pFileNameI, pFileNameO, nBTLimit, nTimeout, 1 );
+    unlink( pFileNameI );
+    //unlink( pFileNameO );
+    if ( vRes == NULL )
+        return 0;
+    Vec_IntFreeP( &p->vCellMapping );
+    assert( p->vCellMapping == NULL );
+    Vec_IntDrop( vRes, 0 );
+    if ( fVerbose ) Gia_ManSimplePrintMapping( vRes, Gia_ManCiNum(p) );
+    p->vCellMapping = Gia_ManDeriveSimpleMapping( p, vRes );
+    Vec_IntFree( vRes );
+    return 1;
+}
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/aig/gia/giaSif.c b/src/aig/gia/giaSif.c
index c52ab4dd9..4df5c47f7 100644
--- a/src/aig/gia/giaSif.c
+++ b/src/aig/gia/giaSif.c
@@ -645,6 +645,25 @@ Gia_Man_t * Gia_ManSifPerform( Gia_Man_t * p, int nLutSize, int fEvalOnly, int f
         pNew = Gia_ManSifTransform( p, vCuts, vTimes, nLutSize, Upper, fVerbose );
     Vec_IntFree( vCuts );
     Vec_IntFree( vTimes );
+    //Gia_ManTransferTiming( pNew, p );
+    if ( p->vNamesIn ) {
+        char * pName; int i;
+        pNew->vNamesIn     = p->vNamesIn;     p->vNamesIn     = NULL;
+        Vec_PtrForEachEntryStart( char *, pNew->vNamesIn, pName, i, Gia_ManPiNum(pNew) )
+            ABC_FREE( pName );
+        Vec_PtrShrink( pNew->vNamesIn, Gia_ManPiNum(pNew) );
+        for ( i = 0; i < Gia_ManRegNum(pNew); i++ )
+            Vec_PtrPush( pNew->vNamesIn, Abc_UtilStrsavNum("_fo", i) );
+    }
+    if ( p->vNamesOut ) {
+        char * pName; int i;
+        pNew->vNamesOut    = p->vNamesOut;    p->vNamesOut    = NULL;
+        Vec_PtrForEachEntryStart( char *, pNew->vNamesOut, pName, i, Gia_ManPoNum(pNew) )
+            ABC_FREE( pName );
+        Vec_PtrShrink( pNew->vNamesOut, Gia_ManPoNum(pNew) );
+        for ( i = 0; i < Gia_ManRegNum(pNew); i++ )
+            Vec_PtrPush( pNew->vNamesOut, Abc_UtilStrsavNum("_fi", i) );
+    }
     return pNew;
 }
 
diff --git a/src/aig/gia/giaSwitch.c b/src/aig/gia/giaSwitch.c
index bf94ad72d..26e29591c 100644
--- a/src/aig/gia/giaSwitch.c
+++ b/src/aig/gia/giaSwitch.c
@@ -612,7 +612,7 @@ Vec_Int_t * Gia_ManSwiSimulate( Gia_Man_t * pAig, Gia_ParSwi_t * pPars )
     else if ( pPars->fProbTrans )
     {
         Gia_ManForEachObj( pAig, pObj, i )
-            pSwitching[i] = Gia_ManSwiComputeProbOne( p->pData1[i], pPars->nWords*(pPars->nIters-pPars->nPref) );
+            pSwitching[i] = Gia_ManSwiComputeSwitching( p->pData1[i], pPars->nWords*(pPars->nIters-pPars->nPref) );
     }
     else
     {
diff --git a/src/aig/gia/giaTruth.c b/src/aig/gia/giaTruth.c
index c24748ede..0845eae96 100644
--- a/src/aig/gia/giaTruth.c
+++ b/src/aig/gia/giaTruth.c
@@ -559,6 +559,11 @@ void Gia_ObjComputeTruthTableStart( Gia_Man_t * p, int nVarsMax )
     p->vTtMemory = Vec_WrdStart( p->nTtWords * 64 );
     p->vTtNums   = Vec_IntAlloc( Gia_ManObjNum(p) + 1000 );
     Vec_IntFill( p->vTtNums, Vec_IntCap(p->vTtNums), -ABC_INFINITY );
+    if ( nVarsMax >= 6 ) {
+        word * pTruth; int i;
+        Vec_PtrForEachEntry( word *, p->vTtInputs, pTruth, i )
+            Abc_TtFlipVar5( pTruth, nVarsMax );
+    }
 }
 void Gia_ObjComputeTruthTableStop( Gia_Man_t * p )
 {
diff --git a/src/aig/gia/giaUtil.c b/src/aig/gia/giaUtil.c
index 41c56c1fa..de7149935 100644
--- a/src/aig/gia/giaUtil.c
+++ b/src/aig/gia/giaUtil.c
@@ -3453,6 +3453,117 @@ Gia_Man_t * Gia_ManDupInsertWindows( Gia_Man_t * p, Vec_Ptr_t * vvIns, Vec_Ptr_t
     return pNew;
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Computing equivalent nodes across the two AIGs.]
+
+  Description [Assumes that both AIGs are structurally hashed without dandling nodes.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Gia_Man_t * Gia_ManCreateDualOutputMiter( Gia_Man_t * p0, Gia_Man_t * p1 )
+{
+    Gia_Man_t * pNew; Gia_Obj_t * pObj; int i;
+    assert( Gia_ManCiNum(p0) == Gia_ManCiNum(p1) );
+    assert( Gia_ManCoNum(p0) == Gia_ManCoNum(p1) );
+    // start the manager
+    pNew = Gia_ManStart( Gia_ManObjNum(p0) + Gia_ManObjNum(p1) );
+    pNew->pName = Abc_UtilStrsav( "miter" );
+    Gia_ManFillValue( p0 );
+    Gia_ManFillValue( p1 );
+    // map combinational inputs
+    Gia_ManConst0(p0)->Value = 0;
+    Gia_ManConst0(p1)->Value = 0;
+    Gia_ManForEachCi( p0, pObj, i )
+        Gia_ManCi(p1, i)->Value = pObj->Value = Gia_ManAppendCi( pNew );
+    // map internal nodes and outputs
+    Gia_ManHashAlloc( pNew );
+    Gia_ManForEachAnd( p0, pObj, i )
+        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
+    assert( Gia_ManAndNum(pNew) == Gia_ManAndNum(p0) ); // the input AIG p0 is structurally hashed
+    Gia_ManForEachAnd( p1, pObj, i )
+        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
+    // add the outputs
+    Gia_ManForEachCo( p0, pObj, i )
+        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
+    Gia_ManForEachCo( p1, pObj, i )
+        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
+    printf( "The two AIGs have %d structurally equivalent nodes.\n", Gia_ManAndNum(p0) + Gia_ManAndNum(p1) - Gia_ManAndNum(pNew) );
+    // there should be no dangling nodes (otherwise, the second AIG may not be structurally hashed)
+    int nDangling = Gia_ManMarkDangling(pNew);
+    assert( nDangling == 0 );
+    Gia_ManCleanMark01(pNew);
+    return pNew;
+}
+Vec_Int_t * Gia_ManFindMutualEquivs( Gia_Man_t * p0, Gia_Man_t * p1, int nConflictLimit, int fVerbose )
+{
+    Vec_Int_t * vPairs = Vec_IntAlloc( 100 );
+    // derive the miter
+    Gia_Man_t * pMiter = Gia_ManCreateDualOutputMiter( p0, p1 );
+    //Gia_ManPrintStats( pMiter, NULL );
+    //Gia_AigerWrite( pMiter, "out.aig", 0, 0, 0 );
+    // perform SAT sweeping
+    extern Gia_Man_t * Cec4_ManSimulateTest3( Gia_Man_t * p, int nBTLimit, int fVerbose );
+    Gia_Man_t * pNew = Cec4_ManSimulateTest3( pMiter, nConflictLimit, fVerbose );
+    Gia_ManStop( pNew );
+    // now, pMiter is annotated with the equiv class info
+
+    // here we collect AIG node pairs with the following properties:
+    // - the first node belongs to p0; the second node belongs to p1
+    // - both nodes are internal nodes of p0 and p1 (not primary inputs/outputs)
+    // - these nodes are combinationally equivalent (possibly up to the complement)
+    // - these nodes are "singleton" equivalences (no other nodes in p0 and p1 are equivalent to them)
+    // - these nodes are not structurally equivalent (that is, they have structurally different TFI logic cones)
+
+    // count the number of nodes in each equivalence class
+    Vec_Int_t * vCounts = Vec_IntStart( Gia_ManObjNum(pMiter) );
+    Gia_Obj_t * pObj; int i, k;
+    Gia_ManForEachClass( pMiter, i ) 
+        Gia_ClassForEachObj( pMiter, i, k )
+            Vec_IntAddToEntry( vCounts, i, 1 );
+
+    // map each miter node coming from p1 into the corresponding node in p1
+    Vec_Int_t * vMap = Vec_IntStartFull( Gia_ManObjNum(pMiter) );
+    int iStartP1 = 1 + Gia_ManPiNum(p0) + Gia_ManAndNum(p0);
+    Gia_ManForEachAnd( p1, pObj, i )
+        if ( Abc_Lit2Var(pObj->Value) >= iStartP1 ) // node from p1 (not from p0)
+            Vec_IntWriteEntry( vMap, Abc_Lit2Var(pObj->Value), i );
+
+    // go through functionally (not structurally!) equivalent nodes in the second AIG
+    // and collect those node pairs from p0 and p1 whose equivalence class contains exactly two nodes
+    for ( i = iStartP1; i < Gia_ManObjNum(pMiter) - Gia_ManCoNum(pMiter); i++ ) {
+        assert( Gia_ObjIsAnd(Gia_ManObj(pMiter, i)) );
+        int Repr = Gia_ObjRepr(pMiter, i);
+        if ( Repr == GIA_VOID || Repr >= iStartP1 || Vec_IntEntry(vCounts, Repr) != 2 )
+            continue;
+        assert( Repr < iStartP1 );           // node in p0
+        assert( Vec_IntEntry(vMap, i) > 0 ); // node in p1
+        Vec_IntPushTwo( vPairs, Repr, Vec_IntEntry(vMap, i) );
+    }
+    // cleanup
+    Vec_IntFree( vMap );
+    Vec_IntFree( vCounts );
+    Gia_ManStop( pMiter );
+    return vPairs;
+}
+void Gia_ManFindMutualEquivsTest()
+{
+    Gia_Man_t * p0 = Gia_AigerRead( "p0.aig", 0, 0, 0 );
+    Gia_Man_t * p1 = Gia_AigerRead( "p1.aig", 0, 0, 0 );    
+    Vec_Int_t * vPairs = Gia_ManFindMutualEquivs( p0, p1, 0, 0 );
+    printf( "Pair     Aig0 node     Aig1 node\n" );
+    int i, Obj0, Obj1;
+    Vec_IntForEachEntryDouble( vPairs, Obj0, Obj1, i )
+        printf( "%3d      %6d       %6d\n", i/2, Obj0, Obj1 );
+    Gia_ManStop( p0 );
+    Gia_ManStop( p1 );
+    Vec_IntFree( vPairs );
+}
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/aig/gia/module.make b/src/aig/gia/module.make
index 27240f443..2e64d1d1b 100644
--- a/src/aig/gia/module.make
+++ b/src/aig/gia/module.make
@@ -73,6 +73,7 @@ SRC +=    src/aig/gia/giaAig.c \
     src/aig/gia/giaResub6.c \
     src/aig/gia/giaRetime.c \
     src/aig/gia/giaRex.c \
+    src/aig/gia/giaRrr.cpp \
     src/aig/gia/giaSatEdge.c \
     src/aig/gia/giaSatLE.c \
     src/aig/gia/giaSatLut.c \
@@ -111,4 +112,4 @@ SRC +=    src/aig/gia/giaAig.c \
     src/aig/gia/giaTtopt.cpp \
     src/aig/gia/giaUnate.c \
     src/aig/gia/giaUtil.c \
-    src/aig/gia/giaBound.c
\ No newline at end of file
+    src/aig/gia/giaBound.c
diff --git a/src/aig/miniaig/ndr.h b/src/aig/miniaig/ndr.h
index 193730636..1d2211f96 100644
--- a/src/aig/miniaig/ndr.h
+++ b/src/aig/miniaig/ndr.h
@@ -219,7 +219,8 @@ static inline void Ndr_DataPushString( Ndr_Data_t * p, int ObjType, int Type, ch
     {
         //word Truth = (word)pFunc;
         //Ndr_DataPushArray( p, Type, 2, (int *)&Truth );
-        Ndr_DataPushArray( p, Type, 2, (int *)&pFunc );
+        int nInts = (strlen(pFunc) + 1 + sizeof(int) - 1) / sizeof(int); 
+        Ndr_DataPushArray( p, Type, nInts, (int *)&pFunc );
     }
     else
     {
diff --git a/src/base/abc/abc.h b/src/base/abc/abc.h
index 73d218438..ada1f499f 100644
--- a/src/base/abc/abc.h
+++ b/src/base/abc/abc.h
@@ -640,6 +640,7 @@ extern ABC_DLL Vec_Ptr_t *        Abc_AigDfsMap( Abc_Ntk_t * pNtk );
 extern ABC_DLL Vec_Vec_t *        Abc_DfsLevelized( Abc_Obj_t * pNode, int  fTfi );
 extern ABC_DLL Vec_Vec_t *        Abc_NtkLevelize( Abc_Ntk_t * pNtk );
 extern ABC_DLL int                Abc_NtkLevel( Abc_Ntk_t * pNtk );
+extern ABC_DLL int                Abc_NtkLevelR( Abc_Ntk_t * pNtk );
 extern ABC_DLL int                Abc_NtkLevelReverse( Abc_Ntk_t * pNtk );
 extern ABC_DLL int                Abc_NtkIsAcyclic( Abc_Ntk_t * pNtk );
 extern ABC_DLL int                Abc_NtkIsAcyclicWithBoxes( Abc_Ntk_t * pNtk );
diff --git a/src/base/abc/abcDfs.c b/src/base/abc/abcDfs.c
index a1345db8c..68c005a5e 100644
--- a/src/base/abc/abcDfs.c
+++ b/src/base/abc/abcDfs.c
@@ -1514,6 +1514,14 @@ int Abc_NtkLevelReverse( Abc_Ntk_t * pNtk )
     }
     return LevelsMax;
 }
+int Abc_NtkLevelR( Abc_Ntk_t * pNtk )
+{
+    int i, LevelMax = Abc_NtkLevelReverse( pNtk );
+    Abc_Obj_t * pNode;
+    Abc_NtkForEachObj( pNtk, pNode, i )
+        pNode->Level = (int)(LevelMax - pNode->Level + 1);
+    return LevelMax;
+}
 
  
 /**Function*************************************************************
diff --git a/src/base/abc/abcNtk.c b/src/base/abc/abcNtk.c
index 3c8fd383e..c9eeb79c6 100644
--- a/src/base/abc/abcNtk.c
+++ b/src/base/abc/abcNtk.c
@@ -1344,10 +1344,11 @@ Abc_Ntk_t * Abc_NtkCreateWithNodes( Vec_Ptr_t * vSop )
     Abc_NodeFreeNames( vNames );
     // create the node, add PIs as fanins, set the function
     Vec_PtrForEachEntry( char *, vSop, pSop, i )
-    {
+    {        
         pNode = Abc_NtkCreateNode( pNtkNew );
-        Abc_NtkForEachPi( pNtkNew, pFanin, k )
-            Abc_ObjAddFanin( pNode, pFanin );
+        if ( Abc_SopGetVarNum(pSop) > 0 )
+            Abc_NtkForEachPi( pNtkNew, pFanin, k )
+                Abc_ObjAddFanin( pNode, pFanin );
         pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtkNew->pManFunc, pSop );
         // create the only PO
         pNodePo = Abc_NtkCreatePo(pNtkNew);
diff --git a/src/base/abci/abc.c b/src/base/abci/abc.c
index ed4a88f6d..c126df352 100644
--- a/src/base/abci/abc.c
+++ b/src/base/abci/abc.c
@@ -60,6 +60,7 @@
 #include "opt/sbd/sbd.h"
 #include "bool/rpo/rpo.h"
 #include "map/mpm/mpm.h"
+#include "map/mio/mio.h"
 #include "opt/fret/fretime.h"
 #include "opt/nwk/nwkMerge.h"
 #include "base/acb/acbPar.h"
@@ -153,7 +154,9 @@ static int Abc_CommandResubCore              ( Abc_Frame_t * pAbc, int argc, cha
 static int Abc_CommandResubCheck             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandRr                     ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandCascade                ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandLutCasDec              ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandLutCas                 ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandBsEval                 ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandExtract                ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandVarMin                 ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandFaultClasses           ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -286,11 +289,13 @@ static int Abc_CommandRecMerge3              ( Abc_Frame_t * pAbc, int argc, cha
 static int Abc_CommandMap                    ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAmap                   ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandPhaseMap               ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandStochMap               ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandUnmap                  ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAttach                 ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandSuperChoice            ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandSuperChoiceLut         ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandTimeScale              ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandRewire                 ( Abc_Frame_t * pAbc, int argc, char ** argv );
 
 //static int Abc_CommandFpga                   ( Abc_Frame_t * pAbc, int argc, char ** argv );
 //static int Abc_CommandFpgaFast               ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -476,6 +481,7 @@ static int Abc_CommandAbc9Scorr              ( Abc_Frame_t * pAbc, int argc, cha
 static int Abc_CommandAbc9Choice             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Sat                ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9SatEnum            ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandAbc9AdvGenSim             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Fraig              ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9CFraig             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Srm                ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -506,6 +512,7 @@ static int Abc_CommandAbc9Lf                 ( Abc_Frame_t * pAbc, int argc, cha
 static int Abc_CommandAbc9Mf                 ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Nf                 ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Of                 ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandAbc9Simap              ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Pack               ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Edge               ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9SatLut             ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -517,6 +524,8 @@ static int Abc_CommandAbc9LNetOpt            ( Abc_Frame_t * pAbc, int argc, cha
 static int Abc_CommandAbc9Ttopt              ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Transduction       ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9TranStoch          ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandAbc9Rrr                ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandAbc9Rewire             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 //#endif
 static int Abc_CommandAbc9LNetMap            ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Unmap              ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -582,6 +591,7 @@ static int Abc_CommandAbc9Exorcism           ( Abc_Frame_t * pAbc, int argc, cha
 static int Abc_CommandAbc9Mfs                ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Mfsd               ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9DeepSyn            ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandAbc9RandSyn            ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9SatSyn             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9StochSyn           ( Abc_Frame_t * pAbc, int argc, char ** argv );
 //static int Abc_CommandAbc9PoPart2            ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -616,6 +626,7 @@ static int Abc_CommandAbc9Odc                ( Abc_Frame_t * pAbc, int argc, cha
 static int Abc_CommandAbc9GenRel             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9GenMux             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9GenComp            ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandAbc9GenSorter          ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9GenNeuron          ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Window             ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9FunAbs             ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -952,7 +963,9 @@ void Abc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "Synthesis",    "resub_check",   Abc_CommandResubCheck,       0 );
 //    Cmd_CommandAdd( pAbc, "Synthesis",    "rr",            Abc_CommandRr,               1 );
     Cmd_CommandAdd( pAbc, "Synthesis",    "cascade",       Abc_CommandCascade,          1 );
+    Cmd_CommandAdd( pAbc, "Synthesis",    "lutcasdec",     Abc_CommandLutCasDec,        1 );
     Cmd_CommandAdd( pAbc, "Synthesis",    "lutcas",        Abc_CommandLutCas,           1 );
+    Cmd_CommandAdd( pAbc, "Synthesis",    "bseval",        Abc_CommandBsEval,           0 );
     Cmd_CommandAdd( pAbc, "Synthesis",    "extract",       Abc_CommandExtract,          1 );
     Cmd_CommandAdd( pAbc, "Synthesis",    "varmin",        Abc_CommandVarMin,           0 );
     Cmd_CommandAdd( pAbc, "Synthesis",    "faultclasses",  Abc_CommandFaultClasses,     0 );
@@ -1083,11 +1096,13 @@ void Abc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "SC mapping",   "map",           Abc_CommandMap,              1 );
     Cmd_CommandAdd( pAbc, "SC mapping",   "amap",          Abc_CommandAmap,             1 );
     Cmd_CommandAdd( pAbc, "SC mapping",   "phase_map",     Abc_CommandPhaseMap,         1 );
+    Cmd_CommandAdd( pAbc, "SC mapping",   "stochmap",      Abc_CommandStochMap,         1 );
     Cmd_CommandAdd( pAbc, "SC mapping",   "unmap",         Abc_CommandUnmap,            1 );
     Cmd_CommandAdd( pAbc, "SC mapping",   "attach",        Abc_CommandAttach,           1 );
     Cmd_CommandAdd( pAbc, "SC mapping",   "superc",        Abc_CommandSuperChoice,      1 );
     Cmd_CommandAdd( pAbc, "SC mapping",   "supercl",       Abc_CommandSuperChoiceLut,   1 );
     Cmd_CommandAdd( pAbc, "SC mapping",   "timescale",     Abc_CommandTimeScale,        0 );
+    Cmd_CommandAdd( pAbc, "SC mapping",   "rewire",        Abc_CommandRewire,           1 );
 
 //    Cmd_CommandAdd( pAbc, "FPGA mapping", "fpga",          Abc_CommandFpga,             1 );
 //    Cmd_CommandAdd( pAbc, "FPGA mapping", "ffpga",         Abc_CommandFpgaFast,         1 );
@@ -1274,6 +1289,7 @@ void Abc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "ABC9",         "&choice",       Abc_CommandAbc9Choice,       0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&sat",          Abc_CommandAbc9Sat,          0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&satenum",      Abc_CommandAbc9SatEnum,      0 );
+    Cmd_CommandAdd( pAbc, "ABC9",         "&adv_sim_gen",      Abc_CommandAbc9AdvGenSim,        0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&fraig",        Abc_CommandAbc9Fraig,        0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&cfraig",       Abc_CommandAbc9CFraig,       0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&srm",          Abc_CommandAbc9Srm,          0 );
@@ -1304,6 +1320,7 @@ void Abc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "ABC9",         "&mf",           Abc_CommandAbc9Mf,           0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&nf",           Abc_CommandAbc9Nf,           0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&of",           Abc_CommandAbc9Of,           0 );
+    Cmd_CommandAdd( pAbc, "ABC9",         "&simap",        Abc_CommandAbc9Simap,        0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&pack",         Abc_CommandAbc9Pack,         0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&edge",         Abc_CommandAbc9Edge,         0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&satlut",       Abc_CommandAbc9SatLut,       0 );
@@ -1315,6 +1332,8 @@ void Abc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "ABC9",         "&ttopt",        Abc_CommandAbc9Ttopt,        0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&transduction", Abc_CommandAbc9Transduction, 0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&transtoch"   , Abc_CommandAbc9TranStoch,    0 );
+    Cmd_CommandAdd( pAbc, "ABC9",         "&rrr",          Abc_CommandAbc9Rrr,          0 );
+    Cmd_CommandAdd( pAbc, "ABC9",         "&rewire"      , Abc_CommandAbc9Rewire,       0 );
 //#endif
     Cmd_CommandAdd( pAbc, "ABC9",         "&lnetmap",      Abc_CommandAbc9LNetMap,      0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&unmap",        Abc_CommandAbc9Unmap,        0 );
@@ -1380,6 +1399,7 @@ void Abc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "ABC9",         "&mfs",          Abc_CommandAbc9Mfs,          0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&mfsd",         Abc_CommandAbc9Mfsd,         0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&deepsyn",      Abc_CommandAbc9DeepSyn,      0 );
+    Cmd_CommandAdd( pAbc, "ABC9",         "&randsyn",      Abc_CommandAbc9RandSyn,      0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&satsyn",       Abc_CommandAbc9SatSyn,       0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&stochsyn",     Abc_CommandAbc9StochSyn,     0 );
 //    Cmd_CommandAdd( pAbc, "ABC9",         "&popart2",      Abc_CommandAbc9PoPart2,      0 );
@@ -1420,6 +1440,7 @@ void Abc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "ABC9",         "&genrel",       Abc_CommandAbc9GenRel,                 0 );    
     Cmd_CommandAdd( pAbc, "ABC9",         "&genmux",       Abc_CommandAbc9GenMux,                 0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&gencomp",      Abc_CommandAbc9GenComp,                0 );
+    Cmd_CommandAdd( pAbc, "ABC9",         "&gensorter",    Abc_CommandAbc9GenSorter,              0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&genneuron",    Abc_CommandAbc9GenNeuron,              0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&window",       Abc_CommandAbc9Window,                 0 );    
     Cmd_CommandAdd( pAbc, "ABC9",         "&funabs",       Abc_CommandAbc9FunAbs,                 0 );    
@@ -1605,7 +1626,7 @@ usage:
     Abc_Print( -2, "\t-f    : toggles printing the literal count in the factored forms [default = %s]\n", fFactor? "yes": "no" );
     Abc_Print( -2, "\t-b    : toggles saving the best logic network in \"best.blif\" [default = %s]\n", fSaveBest? "yes": "no" );
     Abc_Print( -2, "\t-d    : toggles dumping statistics about the network into file [default = %s]\n", fDumpResult? "yes": "no" );
-    Abc_Print( -2, "\t-l    : toggles printing delay of LUT mapping using LUT library [default = %s]\n", fSaveBest? "yes": "no" );
+    Abc_Print( -2, "\t-l    : toggles printing delay of LUT mapping using LUT library [default = %s]\n", fUseLutLib? "yes": "no" );
     Abc_Print( -2, "\t-t    : toggles printing runtime statistics [default = %s]\n", fPrintTime? "yes": "no" );
     Abc_Print( -2, "\t-m    : toggles printing MUX statistics [default = %s]\n", fPrintMuxes? "yes": "no" );
     Abc_Print( -2, "\t-p    : toggles printing power dissipation due to switching [default = %s]\n", fPower? "yes": "no" );
@@ -3852,7 +3873,7 @@ usage:
     Abc_Print( -2, "usage: strash [-acrih]\n" );
     Abc_Print( -2, "\t        transforms combinational logic into an AIG\n" );
     Abc_Print( -2, "\t-a    : toggles between using all nodes and DFS nodes [default = %s]\n", fAllNodes? "all": "DFS" );
-    Abc_Print( -2, "\t-c    : toggles cleanup to remove the dagling AIG nodes [default = %s]\n", fCleanup? "all": "DFS" );
+    Abc_Print( -2, "\t-c    : toggles cleanup to remove the dangling AIG nodes [default = %s]\n", fCleanup? "all": "DFS" );
     Abc_Print( -2, "\t-r    : toggles using the record of AIG subgraphs [default = %s]\n", fRecord? "yes": "no" );
     Abc_Print( -2, "\t-i    : toggles complementing the POs of the AIG [default = %s]\n", fComplOuts? "yes": "no" );
     Abc_Print( -2, "\t-h    : print the command usage\n");
@@ -7439,14 +7460,58 @@ usage:
 ***********************************************************************/
 int Abc_CommandRunGen( Abc_Frame_t * pAbc, int argc, char ** argv )
 {
-    extern void Acb_NtkRunGen( char * pFileNames[2], int fVerbose );
-    char * pFileNames[4] = {NULL};
-    int c, fVerbose = 0;
+    extern void Acb_NtkRunGen( int nInputs, int nMints, int nFuncs, int Seed, int fVerbose, char * pScript );
+    int c, nInputs = 10, nMints = 10, nFuncs = 10, Seed = 0, fVerbose = 0; char * pScript = NULL;
     Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "vh" ) ) != EOF )
+    while ( ( c = Extra_UtilGetopt( argc, argv, "IMRSCvh" ) ) != EOF )
     {
         switch ( c )
         {
+        case 'I':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-I\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nInputs = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'M':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-M\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nMints = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'R':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-R\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nFuncs = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            Seed = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'C':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-C\" should be followed by a script.\n" );
+                goto usage;
+            }
+            pScript = argv[globalUtilOptind];
+            globalUtilOptind++;
+            break;
         case 'v':
             fVerbose ^= 1;
             break;
@@ -7456,21 +7521,24 @@ int Abc_CommandRunGen( Abc_Frame_t * pAbc, int argc, char ** argv )
             goto usage;
         }
     }
-    if ( argc - globalUtilOptind != 2 )
+    if ( pScript == NULL ) 
     {
-        Abc_Print( 1, "Expecting two file names on the command line.\n" );
-        goto usage;
+        Abc_Print( -1, "Command line switch \"-C\" should be specified and followed by a string.\n" );
+        goto usage;        
     }
-    for ( c = 0; c < 2; c++ )
-        pFileNames[c] = argv[globalUtilOptind+c];
-    Acb_NtkRunGen( pFileNames, fVerbose );
+    Acb_NtkRunGen( nInputs, nMints, nFuncs, Seed, fVerbose, pScript );
     return 0;
 
 usage:
-    Abc_Print( -2, "usage: rungen [-vh] <file1> <file2>\n" );
-    Abc_Print( -2, "\t         experimental command\n" );
-    Abc_Print( -2, "\t-v     : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
-    Abc_Print( -2, "\t-h     : print the command usage\n");
+    Abc_Print( -2, "usage: rungen [-IMRS num] [-C script] [-vh]\n" );
+    Abc_Print( -2, "\t           running the script on a set of randomly generated functions\n" );
+    Abc_Print( -2, "\t-I <num> : the number of input variables [default = %d]\n", nInputs );
+    Abc_Print( -2, "\t-M <num> : the number of positive minterms in the random function [default = %d]\n", nMints );
+    Abc_Print( -2, "\t-R <num> : the number of random functions to try [default = %d]\n", nFuncs );
+    Abc_Print( -2, "\t-S <num> : the random seed [default = %d]\n", Seed );
+    Abc_Print( -2, "\t-C <num> : the script to apply [default = provided by the user]\n" );
+    Abc_Print( -2, "\t-v       : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
+    Abc_Print( -2, "\t-h       : print the command usage\n");
     return 1;
 }
 
@@ -8791,7 +8859,7 @@ int Abc_CommandCascade( Abc_Frame_t * pAbc, int argc, char ** argv )
 
     if ( pNtk == NULL )
     {
-        Abc_Print( -1, "Empty network.\n" );
+        Abc_Print( -1, "Empty neAtwork.\n" );
         return 1;
     }
 
@@ -8834,6 +8902,7 @@ usage:
     return 1;
 }
 
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -8845,13 +8914,14 @@ usage:
   SeeAlso     []
 
 ***********************************************************************/
-int Abc_CommandLutCas( Abc_Frame_t * pAbc, int argc, char ** argv )
+int Abc_CommandLutCasDec( Abc_Frame_t * pAbc, int argc, char ** argv )
 {
-    extern Abc_Ntk_t * Abc_NtkLutCascade( Abc_Ntk_t * pNtk, int nLutSize, int fVerbose );
-    Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc), * pNtkRes;
-    int c, nLutSize = 6, fVerbose = 0;
+    extern Abc_Ntk_t * Abc_NtkLutCascadeGen( int nLutSize, int nStages, int nRails, int nShared, int fVerbose );
+    extern Abc_Ntk_t * Abc_NtkLutCascade2( Abc_Ntk_t * pNtk, int nLutSize, int nLuts, int nRails, int nIters, int fVerbose, char * pGuide );
+    Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc), * pNtkRes; char * pGuide = NULL;
+    int c, nLutSize = 6, nStages = 8, nRails = 1, nShared = 2, nIters = 1, fGen = 0, fVerbose = 0;
     Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "Kvh" ) ) != EOF )
+    while ( ( c = Extra_UtilGetopt( argc, argv, "KMRSIgvh" ) ) != EOF )
     {
         switch ( c )
         {
@@ -8866,6 +8936,53 @@ int Abc_CommandLutCas( Abc_Frame_t * pAbc, int argc, char ** argv )
             if ( nLutSize < 0 )
                 goto usage;
             break;
+        case 'M':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-M\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nStages = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nStages < 0 )
+                goto usage;
+            break;
+        case 'R':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-R\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nRails = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nRails < 0 )
+                goto usage;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nShared = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nShared < 0 )
+                goto usage;
+            break;
+        case 'I':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-I\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nIters = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nIters < 0 )
+                goto usage;
+            break;
+        case 'g':
+            fGen ^= 1;
+            break;
         case 'v':
             fVerbose ^= 1;
             break;
@@ -8875,6 +8992,17 @@ int Abc_CommandLutCas( Abc_Frame_t * pAbc, int argc, char ** argv )
             goto usage;
         }
     }
+    if ( fGen )
+    {
+        pNtkRes = Abc_NtkLutCascadeGen( nLutSize, nStages, nRails, nShared, fVerbose );
+        if ( pNtkRes == NULL )
+        {
+            Abc_Print( -1, "LUT cascade generation failed.\n" );
+            return 1;
+        }
+        Abc_FrameReplaceCurrentNetwork( pAbc, pNtkRes );
+        return 0;
+    }
 
     if ( pNtk == NULL )
     {
@@ -8891,7 +9019,15 @@ int Abc_CommandLutCas( Abc_Frame_t * pAbc, int argc, char ** argv )
         Abc_Print( -1, "Run command \"strash\" to convert the network into an AIG.\n" );
         return 1;
     }
-    pNtkRes = Abc_NtkLutCascade( pNtk, nLutSize, fVerbose );
+    if ( Abc_NtkCiNum(pNtk) > nLutSize + (nLutSize - nRails) * (nStages - 1) )
+    {
+        Abc_Print( -1, "Cannot decompose %d-input function into a %d-rail cascade of %d %d-LUTs (max suppose size = %d).\n", 
+            Abc_NtkCiNum(pNtk), nRails, nStages, nLutSize, nLutSize + (nLutSize - nRails) * (nStages - 1) );
+        return 1;
+    }
+    if ( argc == globalUtilOptind + 1 )
+        pGuide = argv[globalUtilOptind];
+    pNtkRes = Abc_NtkLutCascade2( pNtk, nLutSize, nStages, nRails, nIters, fVerbose, pGuide );
     if ( pNtkRes == NULL )
     {
         Abc_Print( -1, "LUT cascade mapping failed.\n" );
@@ -8901,14 +9037,304 @@ int Abc_CommandLutCas( Abc_Frame_t * pAbc, int argc, char ** argv )
     return 0;
 
 usage:
-    Abc_Print( -2, "usage: lutcas [-K <num>] [-vh]\n" );
-    Abc_Print( -2, "\t           derives single-rail LUT cascade for the primary output function\n" );
+    Abc_Print( -2, "usage: lutcasdec [-KMRSI <num>] [-vh]\n" );
+    Abc_Print( -2, "\t           decomposes the primary output functions into LUT cascades\n" );
     Abc_Print( -2, "\t-K <num> : the number of LUT inputs [default = %d]\n", nLutSize );
+    Abc_Print( -2, "\t-M <num> : the maximum delay (the number of stages) [default = %d]\n", nStages );
+    Abc_Print( -2, "\t-R <num> : the number of direct connections (rails) [default = %d]\n", nRails );
+    Abc_Print( -2, "\t-S <num> : the number of shared variables in each stage [default = %d]\n", nShared );
+    Abc_Print( -2, "\t-I <num> : the number of iterations when looking for a solution [default = %d]\n", nIters );
+    Abc_Print( -2, "\t-g       : toggle generating random cascade with these parameters [default = %s]\n", fGen? "yes": "no" );
     Abc_Print( -2, "\t-v       : toggle verbose printout [default = %s]\n", fVerbose? "yes": "no" );
     Abc_Print( -2, "\t-h       : print the command usage\n");
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandLutCas( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern Abc_Ntk_t * Abc_NtkLutCascadeMap( Abc_Ntk_t * pNtk, int nLutsMax, int nIters, int fDelayLut, int fDelayRoute, int fDelayDirect, int fVerbose );
+    Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc), * pNtkRes;
+    int c, nLutSize = 6, nLutsMax = 8, nIters = 1000, Seed = 0, fVerbose = 0;
+    int fDelayLut = 10, fDelayRoute = 30, fDelayDirect = 3;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "KMISLWDfvh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'K':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-K\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nLutSize = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nLutSize < 0 )
+                goto usage;
+            break;
+        case 'M':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-M\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nLutsMax = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nLutsMax < 0 )
+                goto usage;
+            break;
+        case 'I':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-I\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nIters = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nIters < 0 )
+                goto usage;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            Seed = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( Seed < 0 )
+                goto usage;
+            break;
+        case 'L':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-L\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            fDelayLut = atof(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( fDelayLut < 0 )
+                goto usage;
+            break;
+        case 'W':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-W\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            fDelayRoute = atof(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( fDelayRoute < 0 )
+                goto usage;
+            break;
+        case 'D':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-D\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            fDelayDirect = atof(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( fDelayDirect < 0 )
+                goto usage;
+            break;
+        case 'v':
+            fVerbose ^= 1;
+            break;
+        case 'h':
+            goto usage;
+        default:
+            goto usage;
+        }
+    }
+
+    if ( pNtk == NULL )
+    {
+        Abc_Print( -1, "Empty network.\n" );
+        return 1;
+    }
+    if ( !Abc_NtkIsLogic(pNtk) )
+    {
+        Abc_Print( -1, "Run command \"if\" or any other LUT mapper to map the current network into LUTs.\n" );
+        return 1;
+    }
+    if ( Abc_NtkGetFaninMax(pNtk) > nLutSize )
+    {
+        Abc_Print( -1, "The current network contains nodes with fanin count (%d) exceeding the LUT size (%d).\n", Abc_NtkGetFaninMax(pNtk), nLutSize );
+        return 1;            
+    }
+    srand( Seed );
+    pNtkRes = Abc_NtkLutCascadeMap( pNtk, nLutsMax, nIters, fDelayLut, fDelayRoute, fDelayDirect, fVerbose );
+    if ( pNtkRes == NULL )
+    {
+        Abc_Print( -1, "LUT cascade mapping failed.\n" );
+        return 1;
+    }
+    Abc_FrameReplaceCurrentNetwork( pAbc, pNtkRes );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: lutcas [-KMISLWD <num>] [-vh]\n" );
+    Abc_Print( -2, "\t           decomposes the current network into LUT cascades\n" );
+    Abc_Print( -2, "\t-K <num> : the number of LUT inputs [default = %d]\n", nLutSize );
+    Abc_Print( -2, "\t-M <num> : the maximum number of LUTs in the cascade [default = %d]\n", nLutsMax );
+    Abc_Print( -2, "\t-I <num> : the number of iterations when looking for a solution [default = %d]\n", nIters );
+    Abc_Print( -2, "\t-S <num> : the random seed used to randimize solutions [default = %d]\n", Seed );
+    Abc_Print( -2, "\t-L <num> : the intrinsic LUT delay [default = %d]\n", fDelayLut );
+    Abc_Print( -2, "\t-W <num> : the routable wire delay [default = %d]\n", fDelayRoute );
+    Abc_Print( -2, "\t-D <num> : the non-routable wire delay [default = %d]\n", fDelayDirect );
+    Abc_Print( -2, "\t-v       : toggle verbose printout [default = %s]\n", fVerbose? "yes": "no" );
+    Abc_Print( -2, "\t-h       : print the command usage\n");
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandBsEval( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern void Abc_BSEvalOneTest( word * pT, int nVars, int nBVars, int fVerbose );
+    extern void Abc_BSEvalBestTest( word * pIn, int nVars, int nBVars, int fShared, int fVerbose );
+    extern void Abc_BSEvalBestGen( int nVars, int nBVars, int nFuncs, int nMints, int fTryAll, int fShared, int fVerbose );
+    int c, nVars = 0, nBVars = 0, nSVars = 0, nFuncs = 0, nMints = 0, fTryAll = 0, fVerbose = 0; char * pTtStr = NULL;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "IBSRMavh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'I':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-I\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nVars = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nVars < 2 || nVars > 16 )
+                goto usage;
+            break;
+        case 'B':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-B\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nBVars = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nBVars < 1 || nBVars > 16 )
+                goto usage;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nSVars = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nSVars < 0 || nSVars > 16 )
+                goto usage;
+            break;
+        case 'R':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-R\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nFuncs = atoi(argv[globalUtilOptind]);
+            if ( nFuncs < 1 )
+                goto usage;
+            globalUtilOptind++;
+            break;
+        case 'M':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-M\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nMints = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'a':
+            fTryAll ^= 1;
+            break;
+        case 'v':
+            fVerbose ^= 1;
+            break;
+        case 'h':
+            goto usage;
+        default:
+            goto usage;
+        }
+    }
+    if ( argc == globalUtilOptind + 1 )
+        pTtStr = argv[globalUtilOptind];
+    if ( pTtStr ) 
+    {
+        nVars = Abc_Base2Log((int)strlen(pTtStr)) + 2;
+        if ( (1 << (nVars-2)) != (int)strlen(pTtStr) )
+        {
+            Abc_Print( -1, "Truth table is expected to have %d hex digits (instead of %d).\n", (1 << (nVars-2)), strlen(pTtStr) );
+            return 1;
+        }
+    }
+    if ( nVars == 0 )
+    {
+        Abc_Print( -1, "The number of variables should be specified on the command line.\n" );
+        return 1;
+    }
+    if ( nBVars == 0 )
+    {
+        Abc_Print( -1, "The bound set size should be specified on the command line.\n" );
+        return 1;
+    }
+    if ( nFuncs ) 
+        Abc_BSEvalBestGen( nVars, nBVars, nFuncs, nMints, fTryAll, nSVars == 1, fVerbose );
+    else if ( pTtStr ) 
+    {
+        word pTruth[1024] = {0}; 
+        Abc_TtReadHex( pTruth, pTtStr );
+        if ( fTryAll )
+            Abc_BSEvalBestTest( pTruth, nVars, nBVars, nSVars == 1, fVerbose );
+        else
+            Abc_BSEvalOneTest( pTruth, nVars, nBVars, fVerbose );
+    }
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: bseval [-IBSRM <num>] [-avh] <hex>\n" );
+    Abc_Print( -2, "\t           bound set evaluation\n" );
+    Abc_Print( -2, "\t-I <num> : the number of input variables [default = %d]\n", nVars );
+    Abc_Print( -2, "\t-B <num> : the number of bound set variables [default = %d]\n", nBVars );
+    Abc_Print( -2, "\t-S <num> : the number of shared variables [default = %d]\n", nSVars );
+    Abc_Print( -2, "\t-R <num> : the number of random functions to try [default = unused]\n" );
+    Abc_Print( -2, "\t-M <num> : the number of positive minterms in the random function [default = unused]\n" );
+    Abc_Print( -2, "\t-a       : toggle trying all bound sets of this size [default = %s]\n", fTryAll ? "yes" : "no" );
+    Abc_Print( -2, "\t-v       : toggle verbose printout [default = %s]\n", fVerbose ? "yes" : "no" );
+    Abc_Print( -2, "\t-h       : print the command usage\n" );
+    Abc_Print( -2, "\t<hex>    : truth table in hex notation\n" );
+    return 1;
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -9786,8 +10212,7 @@ usage:
     Abc_Print( -2, "\t           synthesizes the smallest circuit composed of two-input gates\n" );
     Abc_Print( -2, "\t           for the only NPN class of 5-input functions that requires 12 gates;\n" );
     Abc_Print( -2, "\t           all other functions can be realized with 11 two-input gates or less\n" );
-    Abc_Print( -2, "\t           (see Section 7.1.2 \"Boolean evaluation\" in the book by Donald Knuth\n" );
-    Abc_Print( -2, "\t           http://www.cs.utsa.edu/~wagner/knuth/fasc0c.pdf)\n" );
+    Abc_Print( -2, "\t           (see Section 7.1.2 \"Boolean evaluation\" in the book The Art of Computer Programming by Donald Knuth)\n" );
     return 1;
 }
 
@@ -9804,13 +10229,14 @@ usage:
 ***********************************************************************/
 int Abc_CommandLutExact( Abc_Frame_t * pAbc, int argc, char ** argv )
 {
-    extern void Exa3_ManExactSynthesis( Bmc_EsPar_t * pPars );
+    extern int  Exa3_ManExactSynthesis( Bmc_EsPar_t * pPars );
     extern void Exa3_ManExactSynthesis2( Bmc_EsPar_t * pPars );
+    extern void Exa3_ManExactSynthesisRand( Bmc_EsPar_t * pPars );
     int c;
     Bmc_EsPar_t Pars, * pPars = &Pars;
     Bmc_EsParSetDefault( pPars );
     Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "INKTiaocgvh" ) ) != EOF )
+    while ( ( c = Extra_UtilGetopt( argc, argv, "INKTSRMiaocgvh" ) ) != EOF )
     {
         switch ( c )
         {
@@ -9858,6 +10284,33 @@ int Abc_CommandLutExact( Abc_Frame_t * pAbc, int argc, char ** argv )
             if ( pPars->RuntimeLim < 0 )
                 goto usage;
             break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->pSymStr = argv[globalUtilOptind];
+            globalUtilOptind++;
+            break;
+        case 'R':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-R\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->nRandFuncs = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'M':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-M\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->nMintNum = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
         case 'i':
             pPars->fUseIncr ^= 1;
             break;
@@ -9884,16 +10337,21 @@ int Abc_CommandLutExact( Abc_Frame_t * pAbc, int argc, char ** argv )
     }
     if ( argc == globalUtilOptind + 1 )
         pPars->pTtStr = argv[globalUtilOptind];
-    if ( pPars->pTtStr == NULL )
+    if ( pPars->pTtStr == NULL && pPars->pSymStr == NULL && pPars->nRandFuncs == 0 )
     {
         Abc_Print( -1, "Truth table should be given on the command line.\n" );
         return 1;
     }
-    if ( (1 << (pPars->nVars-2)) != (int)strlen(pPars->pTtStr) )
+    if ( pPars->pTtStr && (1 << (pPars->nVars-2)) != (int)strlen(pPars->pTtStr) )
     {
         Abc_Print( -1, "Truth table is expected to have %d hex digits (instead of %d).\n", (1 << (pPars->nVars-2)), strlen(pPars->pTtStr) );
         return 1;
     }
+    if ( pPars->pSymStr && pPars->nVars+1 != strlen(pPars->pSymStr) )
+    {
+        Abc_Print( -1, "The char string of the %d-variable symmetric function should have %d zeros and ones (instead of %d).\n", pPars->nVars, pPars->nVars+1, strlen(pPars->pSymStr) );
+        return 1;
+    }
     if ( pPars->nVars > pPars->nNodes * (pPars->nLutSize - 1) + 1 )
     {
         Abc_Print( -1, "Function with %d variales cannot be implemented with %d %d-input LUTs.\n", pPars->nVars, pPars->nNodes, pPars->nLutSize );
@@ -9909,19 +10367,26 @@ int Abc_CommandLutExact( Abc_Frame_t * pAbc, int argc, char ** argv )
         Abc_Print( -1, "Node size should not be more than 6 inputs.\n" );
         return 1;
     }
-    if ( pPars->fGlucose )
+    if ( pPars->nRandFuncs ) {
+        pPars->fGlucose = 1;
+        Exa3_ManExactSynthesisRand( pPars );
+    }
+    else if ( pPars->fGlucose )
         Exa3_ManExactSynthesis( pPars );
     else
         Exa3_ManExactSynthesis2( pPars );
     return 0;
 
 usage:
-    Abc_Print( -2, "usage: lutexact [-INKT <num>] [-iaocgvh] <hex>\n" );
+    Abc_Print( -2, "usage: lutexact [-INKTRM <num>] [-S string] [-iaocgvh] <hex>\n" );
     Abc_Print( -2, "\t           exact synthesis of I-input function using N K-input gates\n" );
     Abc_Print( -2, "\t-I <num> : the number of input variables [default = %d]\n", pPars->nVars );
     Abc_Print( -2, "\t-N <num> : the number of K-input nodes [default = %d]\n", pPars->nNodes );
     Abc_Print( -2, "\t-K <num> : the number of node fanins [default = %d]\n", pPars->nLutSize );
     Abc_Print( -2, "\t-T <num> : the runtime limit in seconds [default = %d]\n", pPars->RuntimeLim );
+    Abc_Print( -2, "\t-R <num> : the number of random functions to try [default = unused]\n" );
+    Abc_Print( -2, "\t-M <num> : the number of positive minterms in the random function [default = unused]\n" );
+    Abc_Print( -2, "\t-S <str> : charasteristic string of a symmetric function [default = %d]\n", pPars->pSymStr );
     Abc_Print( -2, "\t-i       : toggle using incremental solving [default = %s]\n", pPars->fUseIncr ? "yes" : "no" );
     Abc_Print( -2, "\t-a       : toggle using only AND-gates when K = 2 [default = %s]\n", pPars->fOnlyAnd ? "yes" : "no" );
     Abc_Print( -2, "\t-o       : toggle using additional optimizations [default = %s]\n", pPars->fFewerVars ? "yes" : "no" );
@@ -19038,7 +19503,7 @@ int Abc_CommandMap( Abc_Frame_t * pAbc, int argc, char ** argv )
     int fUseBuffs;
     int fVerbose;
     int c;
-    extern Abc_Ntk_t * Abc_NtkMap( Abc_Ntk_t * pNtk, double DelayTarget, double AreaMulti, double DelayMulti, float LogFan, float Slew, float Gain, int nGatesMin, int fRecovery, int fSwitching, int fSkipFanout, int fUseProfile, int fUseBuffs, int fVerbose );
+    extern Abc_Ntk_t * Abc_NtkMap( Abc_Ntk_t * pNtk, Mio_Library_t* userLib, double DelayTarget, double AreaMulti, double DelayMulti, float LogFan, float Slew, float Gain, int nGatesMin, int fRecovery, int fSwitching, int fSkipFanout, int fUseProfile, int fUseBuffs, int fVerbose );
     extern int Abc_NtkFraigSweep( Abc_Ntk_t * pNtk, int fUseInv, int fExdc, int fVerbose, int fVeryVerbose );
 
     pNtk = Abc_FrameReadNtk(pAbc);
@@ -19189,7 +19654,7 @@ int Abc_CommandMap( Abc_Frame_t * pAbc, int argc, char ** argv )
         }
         Abc_Print( 0, "The network was strashed and balanced before mapping.\n" );
         // get the new network
-        pNtkRes = Abc_NtkMap( pNtk, DelayTarget, AreaMulti, DelayMulti, LogFan, Slew, Gain, nGatesMin, fRecovery, fSwitching, fSkipFanout, fUseProfile, fUseBuffs, fVerbose );
+        pNtkRes = Abc_NtkMap( pNtk, /*userLib=*/NULL, DelayTarget, AreaMulti, DelayMulti, LogFan, Slew, Gain, nGatesMin, fRecovery, fSwitching, fSkipFanout, fUseProfile, fUseBuffs, fVerbose );
         if ( pNtkRes == NULL )
         {
             Abc_NtkDelete( pNtk );
@@ -19201,7 +19666,7 @@ int Abc_CommandMap( Abc_Frame_t * pAbc, int argc, char ** argv )
     else
     {
         // get the new network
-        pNtkRes = Abc_NtkMap( pNtk, DelayTarget, AreaMulti, DelayMulti, LogFan, Slew, Gain, nGatesMin, fRecovery, fSwitching, fSkipFanout, fUseProfile, fUseBuffs, fVerbose );
+        pNtkRes = Abc_NtkMap( pNtk, /*userLib=*/NULL, DelayTarget, AreaMulti, DelayMulti, LogFan, Slew, Gain, nGatesMin, fRecovery, fSwitching, fSkipFanout, fUseProfile, fUseBuffs, fVerbose );
         if ( pNtkRes == NULL )
         {
             Abc_Print( -1, "Mapping has failed.\n" );
@@ -19481,6 +19946,124 @@ usage:
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandStochMap( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
+    extern void Abc_NtkStochMap( int nSuppMax, int nIters, int TimeOut, int Seed, int fVerbose, char * pScript, int nProcs );
+    int c, nMaxSize = 14, nIters = 1, TimeOut = 0, Seed = 0, nProcs = 1, fVerbose = 0; char * pScript;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "NITSPvh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'N':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-N\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nMaxSize = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nMaxSize < 0 )
+                goto usage;
+            break;
+        case 'I':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-I\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nIters = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nIters < 0 )
+                goto usage;
+            break;
+        case 'T':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-T\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            TimeOut = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( TimeOut < 0 )
+                goto usage;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            Seed = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( Seed < 0 )
+                goto usage;
+            break;
+        case 'P':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-P\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            nProcs = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nProcs < 0 )
+                goto usage;
+            break;            
+        case 'v':
+            fVerbose ^= 1;
+            break;
+        case 'h':
+            goto usage;
+        default:
+            goto usage;
+        }
+    }
+    if ( pNtk == NULL )
+    {
+        Abc_Print( -1, "Abc_CommandStochMap(): There is no AIG.\n" );
+        return 0;
+    }
+    if ( !Abc_NtkIsMappedLogic(pNtk) )
+    {
+        Abc_Print( -1, "Abc_CommandStochMap(): Expecting a mapped current newtork as input.\n" );
+        return 0;
+    }    
+    if ( argc != globalUtilOptind + 1 )
+    {
+        printf( "Expecting a synthesis script in quotes on the command line (for example: \"&st; &dch; &if\").\n" );
+        goto usage;
+    }
+    pScript = Abc_UtilStrsav( argv[globalUtilOptind] );
+    Abc_NtkStochMap( nMaxSize, nIters, TimeOut, Seed, fVerbose, pScript, nProcs );
+    ABC_FREE( pScript );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: stochmap [-NITSP <num>] [-tvh] <script>\n" );
+    Abc_Print( -2, "\t           performs stochastic mapping\n" );
+    Abc_Print( -2, "\t-N <num> : the max support size of a partition [default = %d]\n",        nMaxSize );
+    Abc_Print( -2, "\t-I <num> : the number of optimization iterations [default = %d]\n",      nIters  );
+    Abc_Print( -2, "\t-T <num> : the timeout in seconds (0 = no timeout) [default = %d]\n",    TimeOut );
+    Abc_Print( -2, "\t-S <num> : user-specified random seed (0 <= num <= 100) [default = %d]\n", Seed  );
+    Abc_Print( -2, "\t-P <num> : the number of concurrent processes (1 <= num <= 100) [default = %d]\n", nProcs );
+    Abc_Print( -2, "\t-v       : toggle printing optimization summary [default = %s]\n",       fVerbose? "yes": "no" );
+    Abc_Print( -2, "\t-h       : print the command usage\n");
+    Abc_Print( -2, "\t<script> : synthesis script to use for each partition\n");
+    return 1;
+}
 
 /**Function*************************************************************
 
@@ -19825,6 +20408,162 @@ usage:
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandRewire( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern Abc_Ntk_t *Abc_ManRewire(Abc_Ntk_t *pNtk, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose);
+    Abc_Ntk_t *pNtk, *pTemp;
+    int c, nIters = 100000, nExpands = 128, nGrowth = 4, nDivs = -1, nFaninMax = 8, nSeed = 1, nTimeOut = 0, nVerbose = 1, nMode = 0, nDist = 0;
+    Extra_UtilGetoptReset();
+    // Cmd_CommandExecute
+
+    pNtk = Abc_FrameReadNtk(pAbc);
+
+    while ( ( c = Extra_UtilGetopt( argc, argv, "IEGDFSTMLVh" ) ) != EOF ) {
+        switch ( c ) {
+        case 'I':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-I\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nIters = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'E':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-E\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nExpands = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'G':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-G\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nGrowth = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'D':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-D\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nDivs = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'F':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-F\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nFaninMax = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nSeed = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'T':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nTimeOut = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'M':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-M\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nMode = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'L':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-L\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nDist = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'V':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-V\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'h':
+        default:
+            goto usage;
+        }
+    }
+    if ( argc > globalUtilOptind + 1 )
+    {
+        Abc_Print( -1, "Wrong number of auguments.\n" );
+        goto usage;
+    }
+    if ( pNtk == NULL )
+    {
+        Abc_Print( -1, "Empty network.\n" );
+        return 1;
+    }
+    if ( nMode == 1 && Abc_FrameReadLibGen2() == NULL )
+    {
+        Abc_Print( -1, "Library is not available.\n" );
+        return 1;
+    }
+
+    pTemp = Abc_ManRewire( pNtk, nIters, nExpands, nGrowth, nDivs, nFaninMax, nTimeOut, nMode, nDist, nSeed, nVerbose );
+    Abc_FrameReplaceCurrentNetwork( pAbc, pTemp );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: rewire [-IEGDFSTV <num>]\n" );
+    Abc_Print( -2, "\t             performs AIG re-wiring\n" );
+    Abc_Print( -2, "\t-I <num>  :  the number of iterations [default = %d]\n",                 nIters );
+    Abc_Print( -2, "\t-E <num>  :  the number of fanins to add to all nodes [default = %d]\n", nExpands );
+    Abc_Print( -2, "\t-G <num>  :  the number of fanins to add to one node [default = %d]\n",  nGrowth );
+    Abc_Print( -2, "\t-D <num>  :  the number of shared divisors to extract [default = %d]\n", nDivs );
+    Abc_Print( -2, "\t-F <num>  :  the limit on the fanin count at a node [default = %d]\n",   nFaninMax);
+    Abc_Print( -2, "\t-L <num>  :  localization distances [default = %d]\n",                   nDist);
+    Abc_Print( -2, "\t-M <num>  :  optimization target [default = %s]\n",                      nMode ? "transistor" : "node" );
+    Abc_Print( -2, "\t-S <num>  :  the random seed [default = %d]\n",                          nSeed );
+    Abc_Print( -2, "\t-T <num>  :  the timeout in seconds [default = unused]\n" );
+    Abc_Print( -2, "\t-V <num>  :  the verbosity level [default = %d]\n",                      nVerbose );
+    Abc_Print( -2, "\t-h        :  prints the command usage\n" );
+    Abc_Print( -2, "\n\tThis command was contributed by Jiun-Hao Chen from National Taiwan University.\n" );
+    return 1;
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -23065,7 +23804,7 @@ int Abc_CommandSeqSweep2( Abc_Frame_t * pAbc, int argc, char ** argv )
     // set defaults
     Ssw_ManSetDefaultParams( pPars );
     Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "PQFCLSIVMNXcmplkodsefqvwh" ) ) != EOF )
+    while ( ( c = Extra_UtilGetopt( argc, argv, "PQFCLSIVMNXRBcmplkodsefqvwh" ) ) != EOF )
     {
         switch ( c )
         {
@@ -23190,6 +23929,28 @@ int Abc_CommandSeqSweep2( Abc_Frame_t * pAbc, int argc, char ** argv )
             if ( pPars->nLimitMax < 0 )
                 goto usage;
             break;
+        case 'R':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-R\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->nSkip = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( pPars->nSkip < 0 )
+                goto usage;
+            break;
+        case 'B':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-B\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->nSkipLimit = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( pPars->nSkipLimit < 0 )
+                goto usage;
+            break;
         case 'c':
             pPars->fConstrs ^= 1;
             break;
@@ -23311,7 +24072,7 @@ int Abc_CommandSeqSweep2( Abc_Frame_t * pAbc, int argc, char ** argv )
     return 0;
 
 usage:
-    Abc_Print( -2, "usage: scorr [-PQFCLSIVMNX <num>] [-cmplkodsefqvwh]\n" );
+    Abc_Print( -2, "usage: scorr [-PQFCLSIVMNXRB <num>] [-cmplkodsefqvwh]\n" );
     Abc_Print( -2, "\t         performs sequential sweep using K-step induction\n" );
     Abc_Print( -2, "\t-P num : max partition size (0 = no partitioning) [default = %d]\n", pPars->nPartSize );
     Abc_Print( -2, "\t-Q num : partition overlap (0 = no overlap) [default = %d]\n", pPars->nOverSize );
@@ -23325,6 +24086,8 @@ usage:
     Abc_Print( -2, "\t-M num : min call num needed to recycle the SAT solver [default = %d]\n", pPars->nRecycleCalls2 );
     Abc_Print( -2, "\t-N num : set last <num> POs to be constraints (use with -c) [default = %d]\n", nConstrs );
     Abc_Print( -2, "\t-X num : the number of iterations of little or no improvement [default = %d]\n", pPars->nLimitMax );
+    Abc_Print( -2, "\t-R num : the number used to skip some constraints [default = %d]\n", pPars->nSkip );
+    Abc_Print( -2, "\t-B num : the limit on the size of constraints to skip [default = %d]\n", pPars->nSkipLimit );
     Abc_Print( -2, "\t-c     : toggle using explicit constraints [default = %s]\n", pPars->fConstrs? "yes": "no" );
     Abc_Print( -2, "\t-m     : toggle full merge if constraints are present [default = %s]\n", pPars->fMergeFull? "yes": "no" );
     Abc_Print( -2, "\t-p     : toggle aligning polarity of SAT variables [default = %s]\n", pPars->fPolarFlip? "yes": "no" );
@@ -27387,11 +28150,11 @@ int Abc_CommandAbc9Kissat( Abc_Frame_t * pAbc, int argc, char ** argv )
 {
     extern void Mf_ManDumpCnf( Gia_Man_t * p, char * pFileName, int nLutSize, int fCnfObjIds, int fAddOrCla, int fVerbose );
     extern void Gia_ManKissatCall( Abc_Frame_t * pAbc, char * pFileName, char * pArgs, int nConfs, int nTimeLimit, int fSat, int fUnsat, int fPrintCex, int fVerbose );
-    int c, nConfs = 0, nTimeLimit = 0, fSat = 0, fUnsat = 0, fPrintCex = 0, fVerbose = 0;
+    int c, nConfs = 0, nTimeLimit = 0, fSat = 0, fUnsat = 0, fPrintCex = 0, fKissat = 1, fVerbose = 0;
     char * pArgs = NULL;
 
     Extra_UtilGetoptReset();
-    while ( ( c = Extra_UtilGetopt( argc, argv, "CTAsucvh" ) ) != EOF )
+    while ( ( c = Extra_UtilGetopt( argc, argv, "CTAsuckvh" ) ) != EOF )
     {
         switch ( c )
         {
@@ -27435,6 +28198,9 @@ int Abc_CommandAbc9Kissat( Abc_Frame_t * pAbc, int argc, char ** argv )
         case 'c':
             fPrintCex ^= 1;
             break;
+        case 'k':
+            fKissat ^= 1;
+            break;
         case 'v':
             fVerbose ^= 1;
             break;
@@ -27455,6 +28221,18 @@ int Abc_CommandAbc9Kissat( Abc_Frame_t * pAbc, int argc, char ** argv )
         Abc_Print( -1, "Abc_CommandAbc9Satoko(): There is no AIG.\n" );
         return 1;
     }
+    else if ( fKissat )
+    {
+        extern Vec_Int_t * kissat_solve_cnf( Cnf_Dat_t * pCnf, char * pArgs, int nConfs, int nTimeLimit, int fSat, int fUnsat, int fPrintCex, int fVerbose );
+        extern void * Mf_ManGenerateCnf( Gia_Man_t * pGia, int nLutSize, int fCnfObjIds, int fAddOrCla, int fMapping, int fVerbose );
+        int nLutSize    = 8;
+        int fCnfObjIds  = 0;        
+        int fAddOrCla   = 1;
+        Cnf_Dat_t * pCnf = (Cnf_Dat_t *)Mf_ManGenerateCnf( pAbc->pGia, nLutSize, fCnfObjIds, fAddOrCla, 0, fVerbose );
+        Vec_Int_t * vRes = kissat_solve_cnf( pCnf, pArgs, nConfs, nTimeLimit, fSat, fUnsat, fPrintCex, 1 );
+        Vec_IntFreeP( &vRes );
+        Cnf_DataFree(pCnf);
+    }
     else
     {
         int nLutSize    = 8;
@@ -27468,18 +28246,20 @@ int Abc_CommandAbc9Kissat( Abc_Frame_t * pAbc, int argc, char ** argv )
     return 0;
 
 usage:
-    Abc_Print( -2, "usage: &kissat [-CT num] [-sucvh] [-A string] <file.cnf>\n" );
-    Abc_Print( -2, "\t             run SAT solver Kissat, by Armin Biere (https://github.com/arminbiere/kissat)\n" );
+    Abc_Print( -2, "usage: &kissat [-CT num] [-suckvh] [-A string] <file.cnf>\n" );
+    Abc_Print( -2, "\t             run SAT solver Kissat 4.0.2, by Armin Biere (https://github.com/arminbiere/kissat)\n" );
     Abc_Print( -2, "\t-C num     : limit on the number of conflicts [default = %d]\n", nConfs );
     Abc_Print( -2, "\t-T num     : runtime limit in seconds [default = %d]\n", nTimeLimit );
     Abc_Print( -2, "\t-s         : expect a satisfiable problem [default = %s]\n", fSat ? "yes": "no" );
     Abc_Print( -2, "\t-u         : expect an unsatisfiable problem [default = %s]\n", fUnsat ? "yes": "no" );
     Abc_Print( -2, "\t-c         : prints satisfying assignment if satisfiable [default = %s]\n", fPrintCex ? "yes": "no" );
+    Abc_Print( -2, "\t-k         : calls Kissat through programmable APIs [default = %s]\n", fKissat ? "yes": "no" );
     Abc_Print( -2, "\t-v         : prints verbose information [default = %s]\n", fVerbose ? "yes": "no" );
     Abc_Print( -2, "\t-A num     : string containing additional command-line args for the Kissat binary [default = %s]\n", pArgs ? pArgs : "unused" );
     Abc_Print( -2, "\t             (in particular, <&kissat -A \"--help\"> prints all command-line args of Kissat)\n" );
     Abc_Print( -2, "\t<file.cnf> : (optional) CNF file to solve\n");
     Abc_Print( -2, "\t-h         : print the command usage\n");
+    Abc_Print( -2, "\n\t             The solver was integrated into ABC by Yukio Miyasaka\n");
     return 1;
 }
 
@@ -32265,7 +33045,7 @@ int Abc_CommandAbc9Put( Abc_Frame_t * pAbc, int argc, char ** argv )
     else
     {
         Abc_Ntk_t * pNtkNoCh;
-        Abc_Print( -1, "Transforming AIG with %d choice nodes.\n", Gia_ManEquivCountClasses(pAbc->pGia) );
+        Abc_Print( 0, "Transforming AIG with %d choice nodes.\n", Gia_ManEquivCountClasses(pAbc->pGia) );
         // create network without choices
         pMan = Gia_ManToAig( pAbc->pGia, 0 );
         pNtkNoCh = Abc_NtkFromAigPhase( pMan );
@@ -32313,7 +33093,7 @@ int Abc_CommandAbc9Put( Abc_Frame_t * pAbc, int argc, char ** argv )
         Abc_Print( 0, "Internal nodes names are not transferred.\n" );
 
     // decouple CI/CO with the same name
-    if ( pAbc->pGia->vNamesIn || pAbc->pGia->vNamesOut )
+    if ( !Abc_NtkIsStrash(pNtk) && (pAbc->pGia->vNamesIn || pAbc->pGia->vNamesOut) )
         Abc_NtkRedirectCiCo( pNtk );
 
     // transfer timing information
@@ -39034,6 +39814,140 @@ usage:
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Abc_CommandAbc9AdvGenSim]
+
+  Description [This function calls SimGen tool]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+int Abc_CommandAbc9AdvGenSim( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern void Cec_SimGenSetParDefault( Cec_ParSimGen_t * pPars );
+    extern Gia_Man_t * Cec_SimGenRun( Gia_Man_t * pAig, Cec_ParSimGen_t * pPars );
+
+    Cec_ParSimGen_t ParsFra, * pPars = &ParsFra; Gia_Man_t * pTemp;
+    int c;
+    Cec_SimGenSetParDefault( pPars );
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "EOStiFwvV" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'E':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-E\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->expId = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( pPars->expId < 0 )
+                goto usage;
+            break;
+        case 'O':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-O\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->bitwidthOutgold = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( pPars->bitwidthOutgold <= 0 )
+                goto usage;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->nSimWords = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( pPars->nSimWords <= 0 )
+                goto usage;
+            break;
+        case 't':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-t\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->timeOutSim = atof(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( pPars->timeOutSim <= 0 )
+                goto usage;
+            break;
+        case 'i':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-i\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            pPars->nMaxIter = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( pPars->nMaxIter <= -2 )
+                goto usage;
+            break;
+        case 'F':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-F\" should be followed by a string.\n" );
+                goto usage;
+            }
+            pPars->pFileName = argv[globalUtilOptind];
+            globalUtilOptind++;
+            break;  
+        case 'w':
+            pPars->fUseWatchlist = 1;
+            break;
+        case 'v':
+            pPars->fVerbose = 1;
+            break;
+        case 'V':
+            pPars->fVeryVerbose = 1;
+            break;
+        default:
+            goto usage;
+        }
+    }
+    if ( pAbc->pGia == NULL )
+    {
+        Abc_Print( -1, "Abc_CommandAbc9Fraig(): There is no AIG.\n" );
+        return 1;
+    }
+    
+    pTemp = Cec_SimGenRun(pAbc->pGia, pPars );
+    if ( pAbc->pGia->pCexSeq != NULL )
+    {
+        pAbc->Status  = 0;
+        pAbc->nFrames = 0;
+        Abc_FrameReplaceCex( pAbc, &pAbc->pGia->pCexSeq );
+    }
+    Abc_FrameUpdateGia( pAbc, pTemp );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: &adv_sim_gen [-EOSsivV <num>] [-v] \n" );
+    Abc_Print( -2, "\t         generates simulation patterns for combinational SAT sweeping\n" );
+    Abc_Print( -2, "\t-E num : the experiment ID for different techniques [default = %d]\n", pPars->expId );
+    Abc_Print( -2, "\t-O num : the bitwidth of the output gold [default = %d]\n", pPars->bitwidthOutgold );
+    Abc_Print( -2, "\t-S num : the number of words in a round for random simulation [default = %d]\n", pPars->nSimWords );
+    Abc_Print( -2, "\t-t num : the timeout value [default = %.0f]\n", pPars->timeOutSim);
+    Abc_Print( -2, "\t-i num : the number of rounds of random simulation [default = %d]\n", pPars->nMaxIter );
+    Abc_Print( -2, "\t-F file: the file name to dump the generated patterns  [default = none]\n");
+    Abc_Print( -2, "\t-w     : activates the watchlist feature [default = %d]\n", pPars->fUseWatchlist);
+    Abc_Print( -2, "\t-v     : verbose [default = %d]\n", pPars->fVerbose );
+    Abc_Print( -2, "\t-V     : very verbose [default = %d]\n", pPars->fVeryVerbose );
+    Abc_Print( -2, "\t-h     : print the command usage\n");
+    return 1;
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -43469,6 +44383,93 @@ usage:
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandAbc9Simap( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern void Mio_IntallSimpleLibrary();
+    extern int Gia_ManSimpleMapping( Gia_Man_t * p, int nBound, int nBTLimit, int nTimeout, int fVerbose );
+    int c, nBTLimit = 0, nBound = 0, nTimeout = 0, fVerbose = 0;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "BCTvh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'B':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-N\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nBound = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nBound < 0 )
+            {
+                Abc_Print( -1, "Bound on a solution should be a positive integer.\n" );
+                goto usage;
+            }
+            break;
+        case 'C':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-C\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nBTLimit = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( nBTLimit < 0 )
+            {
+                Abc_Print( -1, "Conflict limit should be a positive integer.\n" );
+                goto usage;
+            }
+            break;
+        case 'T':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-T\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nTimeout = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;            
+        case 'v':
+            fVerbose ^= 1;
+            break;
+        case 'h':
+        default:
+            goto usage;
+        }
+    }
+    if ( pAbc->pGia == NULL )
+    {
+        Abc_Print( -1, "Empty GIA network.\n" );
+        return 1;
+    }
+    Mio_IntallSimpleLibrary();
+    if ( !Gia_ManSimpleMapping( pAbc->pGia, nBound, nBTLimit, nTimeout, fVerbose ) )
+        printf( "Simple mapping has failed.\n" );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: &simap [-BCT num] [-vh]\n" );
+    Abc_Print( -2, "\t           performs simple mapping of the AIG\n" );
+    Abc_Print( -2, "\t-B num   : the bound on the solution size [default = %d]\n", nBound );
+    Abc_Print( -2, "\t-C num   : the conflict limit [default = %d]\n", nBTLimit );
+    Abc_Print( -2, "\t-T num   : runtime limit in seconds [default = %d]\n", nTimeout );    
+    Abc_Print( -2, "\t-v       : toggles verbose output [default = %s]\n", fVerbose? "yes": "no" );
+    Abc_Print( -2, "\t-h       : prints the command usage\n");
+    return 1;
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -44544,6 +45545,314 @@ usage:
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandAbc9Rrr( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    Gia_Man_t *pNew;
+    int c;
+    int iSeed = 0, nWords = 10, nTimeout = 0, nSchedulerVerbose = 1, nPartitionerVerbose = 0, nOptimizerVerbose = 0, nAnalyzerVerbose = 0, nSimulatorVerbose = 0, nSatSolverVerbose = 0, fUseBddCspf = 0, fUseBddMspf = 0, nConflictLimit = 0, nSortType = 12, nOptimizerFlow = 0, nSchedulerFlow = 0, nDistance = 0, nRestarts = 0, nThreads = 1, nWindowSize = 0, fDeterministic = 1;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "XYNJKDRWTCGVPOAQSabdh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'X':
+            nOptimizerFlow = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'Y':
+            nSchedulerFlow = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'N':
+            nRestarts = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'J':
+            nThreads = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'K':
+            nWindowSize = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'D':
+            nDistance = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'R':
+            iSeed = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'W':
+            nWords = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'T':
+            nTimeout = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'C':
+            nConflictLimit = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'G':
+            nSortType = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'V':
+            nSchedulerVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'P':
+            nPartitionerVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'O':
+            nOptimizerVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'A':
+            nAnalyzerVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'Q':
+            nSimulatorVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'S':
+            nSatSolverVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'a':
+            fUseBddCspf ^= 1;
+            break;
+        case 'b':
+            fUseBddMspf ^= 1;
+            break;
+        case 'd':
+            fDeterministic ^= 1;
+            break;
+        case 'h':
+            goto usage;
+        default:
+            goto usage;
+        }
+    }
+
+    if ( argc > globalUtilOptind ) {
+        Abc_Print( -1, "Wrong number of auguments.\n" );
+        goto usage;
+    }
+
+    if ( pAbc->pGia == NULL )
+    {
+        Abc_Print( -1, "Empty GIA network.\n" );
+        return 1;
+    }
+    
+    pNew = Gia_ManRrr( pAbc->pGia, iSeed, nWords, nTimeout, nSchedulerVerbose, nPartitionerVerbose, nOptimizerVerbose, nAnalyzerVerbose, nSimulatorVerbose, nSatSolverVerbose, fUseBddCspf, fUseBddMspf, nConflictLimit, nSortType, nOptimizerFlow, nSchedulerFlow, nDistance, nRestarts, nThreads, nWindowSize, fDeterministic );
+
+    Abc_FrameUpdateGia( pAbc, pNew );
+    
+    return 0;
+
+usage:
+      Abc_Print( -2, "usage: rrr [-XYNJKDRWTCGVPOAQS num] [-abdh]\n" );
+      Abc_Print( -2, "\t        perform optimization\n" );
+      Abc_Print( -2, "\t-X num : method [default = %d]\n", nOptimizerFlow );
+      Abc_Print( -2, "\t                0: single-add resub\n" );
+      Abc_Print( -2, "\t                1: multi-add resub\n" );
+      Abc_Print( -2, "\t                2: repeat 0 and 1\n" );
+      Abc_Print( -2, "\t-Y num : flow [default = %d]\n", nSchedulerFlow );
+      Abc_Print( -2, "\t                0: apply method once\n" );
+      Abc_Print( -2, "\t                1: iterate like transtoch\n" );
+      Abc_Print( -2, "\t                2: iterate like deepsyn\n" );
+      Abc_Print( -2, "\t-N num : number of restarts or windows [default = %d]\n", nRestarts );
+      Abc_Print( -2, "\t-J num : number of threads [default = %d]\n", nThreads );
+      Abc_Print( -2, "\t-K num : window size (0 = no partitioning) [default = %d]\n", nWindowSize );
+      Abc_Print( -2, "\t-D num : distance between nodes (0 = no limit) [default = %d]\n", nDistance );
+      Abc_Print( -2, "\t-R num : random number generator seed [default = %d]\n", iSeed );
+      Abc_Print( -2, "\t-W num : number of simulation words [default = %d]\n", nWords );
+      Abc_Print( -2, "\t-T num : timeout in seconds (0 = no timeout) [default = %d]\n", nTimeout );
+      Abc_Print( -2, "\t-C num : conflict limit (0 = no limit) [default = %d]\n", nConflictLimit );
+      Abc_Print( -2, "\t-G num : fanin cost function [default = %d]\n", nSortType );
+      Abc_Print( -2, "\t-V num : scheduler verbosity level [default = %d]\n", nSchedulerVerbose );
+      Abc_Print( -2, "\t-P num : partitioner verbosity level [default = %d]\n", nPartitionerVerbose );
+      Abc_Print( -2, "\t-O num : optimizer verbosity level [default = %d]\n", nOptimizerVerbose );
+      Abc_Print( -2, "\t-A num : analyzer verbosity level [default = %d]\n", nAnalyzerVerbose );
+      Abc_Print( -2, "\t-Q num : simulator verbosity level [default = %d]\n", nSimulatorVerbose );
+      Abc_Print( -2, "\t-S num : SAT solver verbosity level [default = %d]\n", nSatSolverVerbose );
+      Abc_Print( -2, "\t-a     : use BDD-based analyzer (CSPF) [default = %s]\n", fUseBddCspf? "yes": "no" );
+      Abc_Print( -2, "\t-b     : use BDD-based analyzer (MSPF) [default = %s]\n", fUseBddMspf? "yes": "no" );
+      Abc_Print( -2, "\t-d     : ensure deterministic execution [default = %s]\n", fDeterministic? "yes": "no" );
+      Abc_Print( -2, "\t-h     : print the command usage\n");
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandAbc9Rewire( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern Gia_Man_t *Gia_ManRewire(Gia_Man_t *pGia, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose);
+    Gia_Man_t *pTemp;
+    int c, nIters = 100000, nExpands = 128, nGrowth = 4, nDivs = -1, nFaninMax = 8, nSeed = 1, nTimeOut = 0, nVerbose = 1, nMode = 0, nDist = 0;
+    Extra_UtilGetoptReset();
+    // Cmd_CommandExecute
+    while ( ( c = Extra_UtilGetopt( argc, argv, "IEGDFSTMLVh" ) ) != EOF ) {
+        switch ( c ) {
+        case 'I':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-I\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nIters = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'E':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-E\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nExpands = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'G':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-G\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nGrowth = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'D':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-D\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nDivs = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'F':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-F\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nFaninMax = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nSeed = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'T':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nTimeOut = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'M':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-M\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nMode = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'L':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-L\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nDist = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'V':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-V\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'h':
+        default:
+            goto usage;
+        }
+    }
+    if ( argc > globalUtilOptind + 1 )
+    {
+        Abc_Print( -1, "Wrong number of auguments.\n" );
+        goto usage;
+    }
+    if ( pAbc->pGia == NULL )
+    {
+        Abc_Print( -1, "Empty GIA network.\n" );
+        return 1;
+    }
+    if ( nMode == 1 && Abc_FrameReadLibGen2() == NULL )
+    {
+        Abc_Print( -1, "Library is not available.\n" );
+        return 1;
+    }
+
+    pTemp = Gia_ManRewire( pAbc->pGia, nIters, nExpands, nGrowth, nDivs, nFaninMax, nTimeOut, nMode, nDist, nSeed, nVerbose );
+    Abc_FrameUpdateGia( pAbc, pTemp );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: &rewire [-IEGDFSTV <num>]\n" );
+    Abc_Print( -2, "\t             performs AIG re-wiring\n" );
+    Abc_Print( -2, "\t-I <num>  :  the number of iterations [default = %d]\n",                 nIters );
+    Abc_Print( -2, "\t-E <num>  :  the number of fanins to add to all nodes [default = %d]\n", nExpands );
+    Abc_Print( -2, "\t-G <num>  :  the number of fanins to add to one node [default = %d]\n",  nGrowth );
+    Abc_Print( -2, "\t-D <num>  :  the number of shared divisors to extract [default = %d]\n", nDivs );
+    Abc_Print( -2, "\t-F <num>  :  the limit on the fanin count at a node [default = %d]\n",   nFaninMax);
+    Abc_Print( -2, "\t-L <num>  :  localization distances [default = %d]\n",                   nDist);
+    Abc_Print( -2, "\t-M <num>  :  optimization target [default = %s]\n",                      nMode ? "transistor" : "node" );
+    Abc_Print( -2, "\t-S <num>  :  the random seed [default = %d]\n",                          nSeed );
+    Abc_Print( -2, "\t-T <num>  :  the timeout in seconds [default = unused]\n" );
+    Abc_Print( -2, "\t-V <num>  :  the verbosity level [default = %d]\n",                      nVerbose );
+    Abc_Print( -2, "\t-h        :  prints the command usage\n" );
+    Abc_Print( -2, "\n\tThis command was contributed by Jiun-Hao Chen from National Taiwan University.\n" );
+    return 1;
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -51052,6 +52361,68 @@ usage:
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandAbc9RandSyn( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern Gia_Man_t * Gia_ManRandSyn( Gia_Man_t * p, unsigned random_seed );
+    Gia_Man_t * pTemp; int c, Seed = 0, fVerbose = 0;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "Svh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            Seed = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( Seed < 0 )
+                goto usage;
+            break;
+        case 'v':
+            fVerbose ^= 1;
+            break;
+        case 'h':
+            goto usage;
+        default:
+            goto usage;
+        }
+    }
+    if ( pAbc->pGia == NULL )
+    {
+        Abc_Print( -1, "Abc_CommandAbc9RandSyn(): There is no AIG.\n" );
+        return 0;
+    }
+    if ( Seed == 0 ) {
+        Seed = Abc_Random(0) % 10000;
+        printf( "Using random seed: %09u\n", Seed );
+    }
+    pTemp = Gia_ManRandSyn( pAbc->pGia, Seed );
+    Abc_FrameUpdateGia( pAbc, pTemp );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: &randsyn [-S <num>] [-vh]\n" );
+    Abc_Print( -2, "\t           generates a random variation of the current AIG\n" );
+    Abc_Print( -2, "\t-S <num> : user-specified random seed (0 <= num <= 100) [default = %d]\n", Seed  );
+    Abc_Print( -2, "\t-v       : toggle printing optimization summary [default = %s]\n", fVerbose? "yes": "no" );
+    Abc_Print( -2, "\t-h       : print the command usage\n");
+    return 1;
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -53699,7 +55070,7 @@ int Abc_CommandAbc9GenCex( Abc_Frame_t * pAbc, int argc, char ** argv )
 usage:
     Abc_Print( -2, "usage: &gencex [-CM num] [-F file] [-stcbvh]\n" );
     Abc_Print( -2, "\t          generates satisfying assignments for each output of the miter\n" );
-    Abc_Print( -2, "\t-C num  : the number of timeframes [default = %d]\n",                  nMinCexes );
+    Abc_Print( -2, "\t-C num  : the number of satisfying assignments [default = %d]\n",      nMinCexes );
     Abc_Print( -2, "\t-M num  : the max simulation runs before using SAT [default = %d]\n",  nMaxTries );
     Abc_Print( -2, "\t-F file : the output file name [default = %s]\n",                      pFileName );
     Abc_Print( -2, "\t-s      : toggles using reverse simulation [default = %s]\n",          fUseSim  ? "yes": "no" );
@@ -54020,7 +55391,67 @@ usage:
     Abc_Print( -2, "\t-i     : toggles using interleaved variable ordering [default = %s]\n", fInter ? "yes": "no" );
     Abc_Print( -2, "\t-v     : toggles printing verbose information [default = %s]\n", fVerbose ? "yes": "no" );
     Abc_Print( -2, "\t-h     : print the command usage\n");
-    Abc_Print( -2, "\tstring : the sizes of control input groups\n");
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_CommandAbc9GenSorter( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern Gia_Man_t * Gia_ManGenSorter( int LogN );
+    Gia_Man_t * pTemp = NULL;
+    int c, LogN = 0, fVerbose = 0;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "Kvh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'K':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-K\" should be followed by an integer.\n" );
+                goto usage;
+            }
+            LogN = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            if ( LogN < 0 )
+                goto usage;
+            break;
+        case 'v':
+            fVerbose ^= 1;
+            break;
+        case 'h':
+            goto usage;
+        default:
+            goto usage;
+        }
+    }
+    if ( LogN == 0 )
+    {
+        Abc_Print( -1, "Abc_CommandAbc9GenComp(): The number of inputs should be defined on the command line \"-K num\".\n" );
+        return 0;            
+    }    
+    pTemp = Gia_ManGenSorter( LogN );
+    Abc_FrameUpdateGia( pAbc, pTemp );
+    if ( fVerbose )
+        Abc_Print( 1, "Generated %d-input sorter composed of %d elementary 2-bit sorters.\n", 1 << LogN, (1 << LogN) * LogN * (LogN-1) / 4 + (1 << LogN) - 1 );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: &gensorter [-K <num>] [-vh]\n" );
+    Abc_Print( -2, "\t         generates the sorter using pair-wise sorting algorithm\n" );
+    Abc_Print( -2, "\t-K num : the base-2 log of the number of inputs [default = undefined]\n" );
+    Abc_Print( -2, "\t-v     : toggles printing verbose information [default = %s]\n", fVerbose ? "yes": "no" );
+    Abc_Print( -2, "\t-h     : print the command usage\n");
     return 1;
 }
 
@@ -54723,6 +56154,14 @@ int Abc_CommandAbc9Test( Abc_Frame_t * pAbc, int argc, char ** argv )
             goto usage;
         }
     }
+    
+    extern void cadical_solver_test();
+    cadical_solver_test();
+    return 0;
+    extern void kissat_solver_test();
+    kissat_solver_test();
+    return 0;
+    
     if ( pAbc->pGia == NULL )
     {
         Abc_Print( -1, "Abc_CommandAbc9Test(): There is no AIG.\n" );
diff --git a/src/base/abci/abcCas.c b/src/base/abci/abcCas.c
index b81d813d6..3a5a2b808 100644
--- a/src/base/abci/abcCas.c
+++ b/src/base/abci/abcCas.c
@@ -21,10 +21,11 @@
 #include "base/abc/abc.h"
 #include "bool/kit/kit.h"
 #include "aig/miniaig/miniaig.h"
+#include "misc/util/utilTruth.h"
 
 #ifdef ABC_USE_CUDD
 #include "bdd/extrab/extraBdd.h"
-#include "bdd/extrab/extraLutCas.h"
+//#include "bdd/extrab/extraLutCas.h"
 #endif
 
 ABC_NAMESPACE_IMPL_START
@@ -119,7 +120,7 @@ Abc_Ntk_t * Abc_NtkCascade( Abc_Ntk_t * pNtk, int nLutSize, int fCheck, int fVer
 #else
 
 Abc_Ntk_t * Abc_NtkCascade( Abc_Ntk_t * pNtk, int nLutSize, int fCheck, int fVerbose ) { return NULL; }
-word * Abc_LutCascade( Mini_Aig_t * p, int nLutSize, int fVerbose ) { return NULL; }
+word * Abc_LutCascade( Mini_Aig_t * p, int nLutSize, int nLuts, int nRails, int nIters, int fVerbose ) { return NULL; }
 
 #endif
 
@@ -131,7 +132,7 @@ word * Abc_LutCascade( Mini_Aig_t * p, int nLutSize, int fVerbose ) { return NUL
     - the number of words in this block
     - the number of fanins
     - the list of fanins
-    - the variable ID of the output (can be one of the fanin variables)
+    - the variable ID of the output (should be a LUT counter starting with the number of variables)
     - truth tables (one word for 6 vars or less; more words as needed for more than 6 vars)
     For a 6-input node, the LUT info block takes 10 words (block size, fanin count, 6 fanins, output ID, truth table).
     For a 4-input node, the LUT info block takes  8 words (block size, fanin count, 4 fanins, output ID, truth table).
@@ -159,37 +160,157 @@ word * Abc_LutCascadeGenTest()
     pLuts[1+1] =  6;
     for ( i = 0; i < 6; i++ )
         pLuts[1+2+i] = i;
-    pLuts[1+8] = 0;
+    pLuts[1+8] = 9;
     pLuts[1+9] = ABC_CONST(0x8000000000000000);
     // second node    
     pLuts[11+0] = 8;
     pLuts[11+1] = 4;
     for ( i = 0; i < 4; i++ )
-        pLuts[11+2+i] = i ? i + 5 : 0;
-    pLuts[11+6] = 1;
+        pLuts[11+2+i] = i ? i + 5 : 9;
+    pLuts[11+6] = 10;
     pLuts[11+7] = ABC_CONST(0xFFFEFFFEFFFEFFFE);
     return pLuts;
 }
+void Abc_LutCascadePrintLut( word * pLuts, int n, int i )
+{
+    word nIns   = pLuts[i+1];
+    word * pIns = pLuts+i+2;
+    word * pT   = pLuts+i+2+nIns+1;
+    printf( "LUT%d : ", n );
+    printf( "%c = F( ", 'a'+(int)pIns[nIns] );
+    for ( int k = 0; k < nIns; k++ )
+        printf( "%c ", 'a'+(int)pIns[k] );
+    printf( ")  " );
+    Abc_TtPrintHexRev( stdout, pT, nIns );
+    printf( "\n" );
+}
 void Abc_LutCascadePrint( word * pLuts )
 {
-    int n, i, k;
-    printf( "Single-rail LUT cascade has %d nodes:\n", (int)pLuts[0] );
+    int n, i;
+    printf( "The LUT cascade contains %d LUTs:\n", (int)pLuts[0] );
+    for ( n = 0, i = 1; n < pLuts[0]; n++, i += pLuts[i] )
+        Abc_LutCascadePrintLut( pLuts, n, i );
+}
+void Abc_LutCascadeGenOne( Vec_Wrd_t * vRes, int nIns, int * pIns, int Out, word * p )
+{
+    int w, nWords = Abc_TtWordNum(nIns);
+    //int iStart = Vec_WrdSize(vRes);
+    Vec_WrdAddToEntry(vRes, 0, 1);
+    Vec_WrdPush( vRes, 3+nIns+nWords );
+    Vec_WrdPush( vRes, nIns );
+    for ( w = 0; w < nIns; w++ )
+        Vec_WrdPush( vRes, pIns[w] );
+    Vec_WrdPush( vRes, Out );
+    if ( nIns < 6 )
+        Vec_WrdPush( vRes, p ? p[0] : Abc_Tt6Stretch(Abc_Random(0), nIns) );
+    else
+        for ( w = 0; w < nWords; w++ )
+            Vec_WrdPush( vRes, p ? p[w] : Abc_RandomW(0) );
+    //printf("Adding LUT: "); Abc_LutCascadePrintLut( Vec_WrdArray(vRes), 0, iStart );
+}
+word * Abc_LutCascadeGen( int nVars, int nLutSize, int nRails, int nShared )
+{
+    assert( nLutSize - nRails - nShared > 0 );
+    Vec_Wrd_t * vRes    = Vec_WrdStart( 1 );
+    Vec_Int_t * vFanins = Vec_IntAlloc( nLutSize );
+    Vec_Int_t * vVars   = Vec_IntStartNatural( nVars );
+    Vec_Str_t * vGuide  = Vec_StrAlloc( 100 );
+    Abc_Random(1);
+    int i, c = 0, Obj, iVarNext = nVars, iVarPrev = -1;
+    while ( Vec_IntSize(vVars) > nLutSize ) {
+        if ( Vec_WrdSize(vRes) > 1 )
+            for ( i = 0; i < nRails; i++ )
+                Vec_IntPop( vVars );
+        Vec_StrPush( vGuide, '0'+c++ );
+        Vec_IntClear( vFanins );
+        for ( i = 0; i < nShared; i++ ) {
+            int Index = -1;
+            do Index = Abc_Random(0) % Vec_IntSize(vVars);
+            while ( Vec_IntFind(vFanins, Vec_IntEntry(vVars, Index)) >= 0 );
+            Vec_IntPush( vFanins, Vec_IntEntry(vVars, Index) );
+            Vec_StrPush( vGuide, 'A'+Vec_IntEntry(vVars, Index) );
+        }
+        for ( i = 0; i < nLutSize - nRails - nShared; i++ ) {
+            int Index = -1;
+            do Index = Abc_Random(0) % Vec_IntSize(vVars);
+            while ( Vec_IntFind(vFanins, Vec_IntEntry(vVars, Index)) >= 0 );
+            Vec_IntPush( vFanins, Vec_IntEntry(vVars, Index) );
+            Vec_StrPush( vGuide, 'a'+Vec_IntEntry(vVars, Index) );
+            Vec_IntDrop( vVars, Index );
+        }        
+        if ( Vec_WrdSize(vRes) == 1 ) {
+            for ( i = 0; i < nRails; i++ ) {
+                int Index = -1;
+                do Index = Abc_Random(0) % Vec_IntSize(vVars);
+                while ( Vec_IntFind(vFanins, Vec_IntEntry(vVars, Index)) >= 0 );
+                Vec_IntPush( vFanins, Vec_IntEntry(vVars, Index) );
+                Vec_StrPush( vGuide, 'a'+Vec_IntEntry(vVars, Index) );
+                Vec_IntDrop( vVars, Index );
+            }
+        }
+        else {
+            assert( iVarPrev > 0 );
+            for ( i = 0; i < nRails; i++ ) {
+                Vec_IntPush( vFanins, iVarPrev+i );
+                Vec_StrPush( vGuide, 'a'+iVarPrev+i );
+            }
+        }
+        iVarPrev = iVarNext;
+        assert( Vec_IntSize(vFanins) == nLutSize );
+        for ( i = 0; i < nRails; i++ ) {
+            Abc_LutCascadeGenOne( vRes, Vec_IntSize(vFanins), Vec_IntArray(vFanins), iVarNext++, NULL );
+            Vec_IntPush( vVars, iVarPrev+i );
+        }
+    }
+    assert( Vec_IntSize(vVars) <= nLutSize );
+    Abc_LutCascadeGenOne( vRes, Vec_IntSize(vVars), Vec_IntArray(vVars), iVarNext, NULL );
+    Vec_StrPush( vGuide, '0'+c++ );
+    Vec_IntForEachEntry( vVars, Obj, i )
+        Vec_StrPush( vGuide, 'a'+Obj );
+    Vec_StrPush( vGuide, '\0' );
+    
+    printf( "Generated %d-LUT cascade for a %d-var function with %d rails and %d shared vars (node = %d, level = %d).\n", 
+        nLutSize, nVars, nRails, nShared, (int)Vec_WrdEntry(vRes, 0), c );
+    printf( "Structural info: %s\n", Vec_StrArray(vGuide) );
+    Vec_StrFree( vGuide );
+
+    word * pRes = Vec_WrdReleaseArray(vRes);
+    Vec_WrdFree( vRes );
+    return pRes;
+}
+word * Abc_LutCascadeTruth( word * pLuts, int nVars )
+{
+    int nWords = Abc_TtWordNum(nVars);
+    Vec_Wrd_t * vFuncs = Vec_WrdStartTruthTables6( nVars );
+    Vec_WrdFillExtra( vFuncs, nWords*(nVars+pLuts[0]+1), (word)0 );
+    word * pCube = Vec_WrdEntryP( vFuncs, nWords*(nVars+pLuts[0]) );
+    int n, i, m, v, iLastLut = -1;
     for ( n = 0, i = 1; n < pLuts[0]; n++, i += pLuts[i] ) 
     {
-        word nIns   = pLuts[i+1];
+        word   nIns = pLuts[i+1];
         word * pIns = pLuts+i+2;
         word * pT   = pLuts+i+2+nIns+1;
-        printf( "LUT%d : ", n );
-        printf( "%02d = F( ", (int)pIns[nIns] );
-        for ( k = 0; k < nIns; k++ )
-            printf( "%02d ", (int)pIns[k] );
-        for ( ; k < 8; k++ )
-            printf( "   " );
-        printf( ")  " );
-        Extra_PrintHex2( stdout, (unsigned *)pT, nIns );
-        printf( "\n" );
-    }    
+        assert( pLuts[i] == 3+nIns+Abc_TtWordNum(nIns) );
+        assert( pIns[nIns] < nVars+pLuts[0] );
+        word * pIn[30], * pOut = Vec_WrdEntryP( vFuncs, nWords*pIns[nIns] );
+        for ( v = 0; v < nIns; v++ )
+            pIn[v] = Vec_WrdEntryP( vFuncs, nWords*pIns[v] );
+        for ( m = 0; m < (1<<nIns); m++ ) {
+            if ( !Abc_TtGetBit(pT, m) )
+                continue;
+            Abc_TtFill(pCube, nWords);
+            for ( v = 0; v < nIns; v++ )
+                Abc_TtAndCompl(pCube, pCube, 0, pIn[v], !((m>>v)&1), nWords);
+            Abc_TtOr(pOut, pOut, pCube, nWords);
+        }
+        iLastLut = pIns[nIns];
+    }      
+    word * pRes = Vec_WrdReleaseArray(vFuncs);
+    Abc_TtCopy( pRes, pRes + nWords*iLastLut, nWords, 0 );
+    Vec_WrdFree( vFuncs );
+    return pRes; 
 }
+
 word * Abc_LutCascadeTest( Mini_Aig_t * p, int nLutSize, int fVerbose )
 {
     word * pLuts = Abc_LutCascadeGenTest();
@@ -198,6 +319,207 @@ word * Abc_LutCascadeTest( Mini_Aig_t * p, int nLutSize, int fVerbose )
 }
 
 
+/**Function*************************************************************
+
+  Synopsis    [LUT cascade decomposition.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+// computes permutation masks for the current stage
+int Abc_TtGetGuide( char * pGuide, int Iter, Vec_Int_t * vVarIDs, int fShared )
+{
+    int i, Res = 0, Count = 0;
+    for ( i = 0; pGuide[i]; i++ )
+        if ( pGuide[i] >= '0' && pGuide[i] <= '9' ) {
+            if ( Count++ == Iter )
+                break;
+        }
+    assert( i < strlen(pGuide) );
+    assert( pGuide[i] == '0'+Iter );
+    for ( i++; pGuide[i]; i++ ) 
+    {
+        char Char = pGuide[i];
+        if ( Char >= '0' && Char <= '9' )
+            break;
+        if ( fShared && Char >= 'a' && Char <= 'z' )
+            continue;
+        int Value = -1;
+        if ( Char >= 'a' && Char <= 'z' )
+            Value = Char - 'a';
+        else if ( Char >= 'A' && Char <= 'Z' )
+            Value = Char - 'A';
+        else assert( 0 );
+        int iPlace = Vec_IntFind(vVarIDs, Value);
+        assert( iPlace >= 0 );
+        assert( ((Res >> iPlace) & 1) == 0 );
+        Res |= 1 << iPlace;
+    }
+    return Res;
+}
+
+// moves variables in the mask to be the last ones in the order
+void Abc_TtPermuteMask( word * p, int nVars, int Mask, Vec_Int_t * vPerm )
+{
+    assert( !vPerm || nVars == Vec_IntSize(vPerm) );
+    int v, i, iLast = nVars-1, nWords = Abc_TtWordNum(nVars);
+    int * pPerm = vPerm ? Vec_IntArray(vPerm) : NULL;
+    if ( 0 && vPerm ) {
+        printf( "Beg: " );
+        for ( v = 0; v < nVars; v++ )
+            printf( "%c ", 'a'+Vec_IntEntry(vPerm, v) );
+        printf( "\n" );
+        printf( "Bit:  " );
+        for ( v = 0; v < nVars; v++ )
+            printf( "%c ", (Mask >> v) & 1 ? '1' : '-' );
+        printf( "\n" );
+    }
+    for ( v = nVars-1; v >= 0; v-- ) {
+        if ( ((Mask >> v) & 1) == 0 )
+            continue;
+        if ( v == iLast ) {
+            iLast--;
+            continue;
+        }
+        assert( v < iLast );
+        for ( i = v; i < iLast; i++ ) {
+            Abc_TtSwapAdjacent( p, nWords, i );
+            if ( pPerm ) ABC_SWAP( int, pPerm[i], pPerm[i+1] )
+        }
+        iLast--;
+    }
+    if ( 0 && vPerm ) {
+        printf( "End:  " );
+        for ( v = 0; v < nVars; v++ )
+            printf( "%c ", 'a'+Vec_IntEntry(vPerm, v) );
+        printf( "\n" );
+    }
+}
+
+
+// checks if the given function exists in storage
+// if the function does not exist, adds it to storage
+// returns the number of the function in storage
+int Abc_LutCascadeLookup( word * pStore, int nFuncs, word * pFunc, int nWords )
+{
+    int i;
+    for ( i = 0; i < nFuncs; i++ )
+        if ( Abc_TtEqual( pStore+i*nWords, pFunc, nWords ) )
+            return i;
+    Abc_TtCopy( pStore+i*nWords, pFunc, nWords, 0 );
+    assert( i == nFuncs );
+    return i;
+}
+void Abc_LutCascadeDerive( word * p, int nVars, int nBVars, int Myu, word * pRem, word * pDec, int nStep )
+{
+    int nFVars  = nVars-nBVars;  assert( nFVars >= 6 );
+    int nEVars  = Abc_Base2Log(Myu);
+    int nFWords = Abc_TtWordNum(nFVars);
+    int m, e, iFunc, nFuncs = 0;
+    //printf( "Decomposition pattern with %d BS vars and %d FS vars: ", nBVars, nFVars );
+    for ( m = 0; m < (1 << nBVars); m++ ) {
+        iFunc = Abc_LutCascadeLookup( pRem, nFuncs, p+m*nFWords, nFWords );
+        //printf( "%x", iFunc );
+        nFuncs = Abc_MaxInt( nFuncs, iFunc+1 );
+        for ( e = 0; e < nEVars; e++ )
+            if ( (iFunc >> e) & 1 )
+                Abc_TtSetBit(pDec+e*nStep, m); 
+    }
+    //printf( "\n" );
+    assert( nFuncs <= Myu );
+    iFunc = nFuncs-1;
+    for ( m = nFuncs; m < (1 << nEVars); m++ )
+        Abc_TtCopy( pRem+m*nFWords, pRem+iFunc*nFWords, nFWords, 0 );
+    if ( nBVars < 6 )
+        for ( e = 0; e < nEVars; e++ )
+            pDec[e*nStep] = Abc_Tt6Stretch( pDec[e*nStep], nBVars );
+}
+
+// performs decomposition of one stage
+static inline int Abc_LutCascadeDecStage( char * pGuide, int Iter, Vec_Wrd_t * vFuncs[3], Vec_Int_t * vVarIDs, int nRVars, int nRails, int nLutSize, int fVerbose, Vec_Wrd_t * vCas )
+{
+    extern word Abc_TtFindBVarsSVars( word * p, int nVars, int nRVars, int nRails, int nLutSize, int fVerbose );
+    assert( Vec_IntSize(vVarIDs) > nLutSize );
+    assert( Vec_IntSize(vVarIDs) <= 24 );
+    word Guide = pGuide ? 0 : Abc_TtFindBVarsSVars( Vec_WrdArray(vFuncs[0]), Vec_IntSize(vVarIDs), nRVars, nRails, nLutSize, fVerbose );
+    int m, Myu = pGuide ? 1 << nRails : (Guide >> 48) & 0xFF;
+    int nEVars = Abc_Base2Log(Myu);
+    if ( nEVars > nRails ) {
+        printf( "Best Myu (%d) requires %d rails that is more than available (%d).\n", Myu, nEVars, nRails );
+        Vec_IntClear( vVarIDs );
+        return 0;
+    }
+    int nVars  = Vec_IntSize(vVarIDs);
+    int mBVars = pGuide ? Abc_TtGetGuide(pGuide, Iter, vVarIDs, 0) : Guide & 0xFFFFFF;
+    int nBVars = __builtin_popcount(mBVars);
+    assert( nBVars <= nLutSize );
+    Abc_TtPermuteMask( Vec_WrdArray(vFuncs[0]), nVars, mBVars, vVarIDs );
+    int mSVars = pGuide ? Abc_TtGetGuide(pGuide, Iter, vVarIDs, 1) : (Guide >> 24) & 0xFFFFFF;
+    int nSVars = __builtin_popcount(mSVars);
+    Abc_TtPermuteMask( Vec_WrdArray(vFuncs[0]), nVars, mSVars, vVarIDs );
+    // prepare function (nVars -> nAVars+nVars)
+    int nFVars = nVars - nBVars;
+    int nAVars = nFVars >= 6 ? 0 : 6-nFVars;
+    int nWordsNew = Abc_TtWordNum(nVars+nAVars);
+    Vec_WrdFillExtra( vFuncs[0], nWordsNew, 0 );
+    word * pFunc = Vec_WrdArray(vFuncs[0]);
+    Abc_TtStretch6( pFunc, nVars, nVars+nAVars );
+    Abc_TtPermuteMask( pFunc, nVars+nAVars, (1 << nVars)-1, NULL );
+    // prepare remainder function (nAVars+nFVars+nEVars+nSVars)
+    int nWordsRem = Abc_TtWordNum(nAVars+nFVars+nEVars+nSVars);
+    Vec_WrdFill( vFuncs[1], nWordsRem, 0 );
+    word * pRem = Vec_WrdArray(vFuncs[1]);
+    // prepare decomposed functions (nBVars+nZVars) * nEVars
+    int nUVars     = nBVars - nSVars;
+    int nZVars     = nUVars >= 6 ? 0 : 6-nUVars;
+    int nWordsDec  = Abc_TtWordNum(nBVars+nZVars);
+    int nWordsStep = Abc_TtWordNum(nUVars+nZVars);
+    Vec_WrdFill( vFuncs[2], nWordsDec*nEVars, 0 );
+    word * pDec = Vec_WrdArray(vFuncs[2]);
+    int nSMints = 1 << nSVars;
+    for ( m = 0; m < nSMints; m++ ) 
+        Abc_LutCascadeDerive(pFunc+m*nWordsNew/nSMints, nVars+nAVars-nSVars, nBVars-nSVars, Myu, 
+            pRem+m*nWordsRem/nSMints, pDec+m*nWordsStep, nWordsDec );
+    Abc_TtPermuteMask( pRem, nAVars+nFVars+nEVars+nSVars, (1 << nAVars)-1, NULL );
+    Abc_TtPermuteMask( pRem, nFVars+nEVars+nSVars, ((1 << nEVars)-1) << nFVars, NULL );
+    for ( m = 0; m < nEVars; m++ )
+        Abc_TtPermuteMask( pDec+m*nWordsDec, nUVars+nZVars+nSVars, ((1 << nZVars)-1) << nUVars, NULL );
+    for ( m = 0; m < nEVars; m++ )
+        Abc_LutCascadeGenOne( vCas, nBVars, Vec_IntArray(vVarIDs)+nVars-nBVars, Vec_WrdEntry(vCas,0), pDec+m*nWordsDec );
+    Abc_TtCopy( pFunc, pRem, Abc_TtWordNum(nFVars+nSVars+nEVars), 0 );
+    assert( nEVars < nUVars );
+    for ( m = 0; m < nSVars; m++ )
+        Vec_IntWriteEntry(vVarIDs, nFVars+m, Vec_IntEntry(vVarIDs, nVars-nSVars+m) );
+    for ( m = 0; m < nEVars; m++ )
+        Vec_IntWriteEntry(vVarIDs, nFVars+nSVars+m, Vec_WrdEntry(vCas,0)-nEVars+m );
+    Vec_IntShrink( vVarIDs, nFVars+nSVars+nEVars );
+    return nEVars;
+}
+static inline word * Abc_LutCascadeDec( char * pGuide, word * pTruth, Vec_Int_t * vVarIDs, int nRails, int nLutSize, int fVerbose )
+{
+    word * pRes = NULL; int i, nRVars = 0, nVars = Vec_IntSize(vVarIDs);
+    Vec_Wrd_t * vFuncs[3] = { Vec_WrdStart(Abc_TtWordNum(nVars)), Vec_WrdAlloc(0), Vec_WrdAlloc(0) };
+    Abc_TtCopy( Vec_WrdArray(vFuncs[0]), pTruth, Abc_TtWordNum(nVars), 0 );
+    Vec_Wrd_t * vCas = Vec_WrdAlloc( 100 ); Vec_WrdPush( vCas, nVars );
+    for ( i = 0; Vec_IntSize(vVarIDs) > nLutSize; i++ )
+        nRVars = Abc_LutCascadeDecStage( pGuide, i, vFuncs, vVarIDs, nRVars, nRails, nLutSize, fVerbose, vCas );
+    if ( Vec_IntSize(vVarIDs) > 0 ) {
+        Abc_LutCascadeGenOne( vCas, Vec_IntSize(vVarIDs), Vec_IntArray(vVarIDs), Vec_WrdEntry(vCas, 0), Vec_WrdArray(vFuncs[0]) );
+        Vec_WrdAddToEntry( vCas, 0, -nVars );
+        pRes = Vec_WrdReleaseArray(vCas);
+    }
+    Vec_WrdFree( vCas );
+    for ( i = 0; i < 3; i++ )
+        Vec_WrdFree( vFuncs[i] );
+    return pRes;
+}
+
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -225,11 +547,30 @@ Abc_Obj_t * Abc_NtkLutCascadeDeriveSop( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pNodeNe
         return pNodeNew;
     }    
 }
-Abc_Ntk_t * Abc_NtkLutCascadeFromLuts( word * pLuts, Abc_Ntk_t * pNtk, int nLutSize, int fVerbose )
+Abc_Ntk_t * Abc_NtkLutCascadeFromLuts( word * pLuts, int nVars, Abc_Ntk_t * pNtk, int nLutSize, int fVerbose )
 {
-    Abc_Ntk_t * pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, ABC_FUNC_SOP );
-    Vec_Int_t * vCover = Vec_IntAlloc( 1000 ); word n, i, k, iLastLut = -1;
-    assert( Abc_NtkCoNum(pNtk) == 1 );
+    Abc_Ntk_t * pNtkNew = NULL; 
+    Abc_Obj_t * pObj; int Id; char pName[2] = {0};
+    Vec_Ptr_t * vCopy = Vec_PtrStart( nVars + pLuts[0] + 1000 );
+    if ( pNtk ) {
+        pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, ABC_FUNC_SOP );
+    }
+    else {
+        pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP , 0 );
+        pNtkNew->pName = Extra_UtilStrsav("cas");
+        //pNtkNew->pSpec = Extra_UtilStrsav(pNtk->pSpec);        
+        for ( Id = 0; Id < nVars; Id++ ) {
+            pObj = Abc_NtkCreatePi(pNtkNew);
+            pName[0] = 'a' + Id;
+            Abc_ObjAssignName( pObj, pName, NULL );
+        }
+        pObj = Abc_NtkCreatePo(pNtkNew);
+        Abc_ObjAssignName( pObj, "Out", NULL );
+    }
+    Abc_NtkForEachCi( pNtkNew, pObj, Id )
+        Vec_PtrWriteEntry( vCopy, Id, pObj );
+    Vec_Int_t * vCover = Vec_IntAlloc( 1000 );
+    word n, i, k, iLastLut = -1;
     for ( n = 0, i = 1; n < pLuts[0]; n++, i += pLuts[i] ) 
     {
         word nIns   = pLuts[i+1];
@@ -237,12 +578,15 @@ Abc_Ntk_t * Abc_NtkLutCascadeFromLuts( word * pLuts, Abc_Ntk_t * pNtk, int nLutS
         word * pT   = pLuts+i+2+nIns+1;
         Abc_Obj_t * pNodeNew = Abc_NtkCreateNode( pNtkNew );
         for ( k = 0; k < nIns; k++ )
-            Abc_ObjAddFanin( pNodeNew, Abc_NtkCi(pNtk, pIns[k])->pCopy );
-        Abc_NtkCi(pNtk, pIns[nIns])->pCopy = Abc_NtkLutCascadeDeriveSop( pNtkNew, pNodeNew, pT, nIns, vCover );
+            Abc_ObjAddFanin( pNodeNew, (Abc_Obj_t *)Vec_PtrEntry(vCopy, pIns[k]) );
+        Abc_Obj_t * pObjNew = Abc_NtkLutCascadeDeriveSop( pNtkNew, pNodeNew, pT, nIns, vCover );
+        Vec_PtrWriteEntry( vCopy, pIns[nIns], pObjNew );        
         iLastLut = pIns[nIns];
     }
     Vec_IntFree( vCover );
-    Abc_ObjAddFanin( Abc_NtkCo(pNtk, 0)->pCopy, Abc_NtkCi(pNtk, iLastLut)->pCopy );    
+    assert( Abc_NtkCoNum(pNtkNew) == 1 );
+    Abc_ObjAddFanin( Abc_NtkCo(pNtkNew, 0), (Abc_Obj_t *)Vec_PtrEntry(vCopy, iLastLut) );
+    Vec_PtrFree( vCopy ); 
     if ( !Abc_NtkCheck( pNtkNew ) )
     {
         printf( "Abc_NtkLutCascadeFromLuts: The network check has failed.\n" );
@@ -251,20 +595,489 @@ Abc_Ntk_t * Abc_NtkLutCascadeFromLuts( word * pLuts, Abc_Ntk_t * pNtk, int nLutS
     }
     return pNtkNew;    
 }
-Abc_Ntk_t * Abc_NtkLutCascade( Abc_Ntk_t * pNtk, int nLutSize, int fVerbose )
+Abc_Ntk_t * Abc_NtkLutCascade( Abc_Ntk_t * pNtk, int nLutSize, int nLuts, int nRails, int nIters, int fVerbose )
 {
     extern Gia_Man_t *  Abc_NtkStrashToGia( Abc_Ntk_t * pNtk );
     extern Mini_Aig_t * Gia_ManToMiniAig( Gia_Man_t * pGia );
-    extern word *       Abc_LutCascade( Mini_Aig_t * p, int nLutSize, int fVerbose );
+    extern word *       Abc_LutCascade( Mini_Aig_t * p, int nLutSize, int nLuts, int nRails, int nIters, int fVerbose );    
     Gia_Man_t * pGia  = Abc_NtkStrashToGia( pNtk );
     Mini_Aig_t * pM   = Gia_ManToMiniAig( pGia );
-    word * pLuts      = Abc_LutCascade( pM, nLutSize, fVerbose );
-    Abc_Ntk_t * pNew  = pLuts ? Abc_NtkLutCascadeFromLuts( pLuts, pNtk, nLutSize, fVerbose ) : NULL;
+    //word * pLuts      = Abc_LutCascade( pM, nLutSize, nLuts, nRails, nIters, fVerbose );
+    word * pLuts      = Abc_LutCascadeTest( pM, nLutSize, 0 );
+    Abc_Ntk_t * pNew  = pLuts ? Abc_NtkLutCascadeFromLuts( pLuts, Abc_NtkCiNum(pNtk), pNtk, nLutSize, fVerbose ) : NULL;
     ABC_FREE( pLuts );
     Mini_AigStop( pM );
     Gia_ManStop( pGia );
     return pNew;
 }
+Abc_Ntk_t * Abc_NtkLutCascade2( Abc_Ntk_t * pNtk, int nLutSize, int nLuts, int nRails, int nIters, int fVerbose, char * pGuide )
+{
+    extern Gia_Man_t *  Abc_NtkStrashToGia( Abc_Ntk_t * pNtk );
+    extern word *       Abc_LutCascade2( word * p, int nVars, int nLutSize, int nLuts, int nRails, int nIters, int fVerbose );
+    Gia_Man_t * pGia  = Abc_NtkStrashToGia( pNtk );
+    word * pTruth1    = Gia_ObjComputeTruthTable( pGia, Gia_ManCo(pGia, 0) );
+
+    int nVars = Abc_NtkCiNum(pNtk);
+    Vec_Int_t * vVarIDs = Vec_IntStartNatural( nVars );
+    Abc_TtMinimumBase( pTruth1, Vec_IntArray(vVarIDs), nVars, &nVars );
+    if ( fVerbose ) {
+        if ( Vec_IntSize(vVarIDs) != nVars )
+            printf( "The support of the function is reduced from %d to %d variables.\n", Vec_IntSize(vVarIDs), nVars );
+        printf( "Decomposing %d-var function into %d-rail cascade of %d-LUTs", nVars, nRails, nLutSize );
+        if ( pGuide )
+            printf( " using structural info: %s", pGuide );
+        printf( ".\n" );
+    }
+    Vec_IntShrink( vVarIDs, nVars );
+
+    //word * pLuts      = Abc_LutCascade2( pTruth1, nVars, nLutSize, nLuts, nRails, nIters, fVerbose );
+    word * pLuts      = Abc_LutCascadeDec( pGuide, pTruth1, vVarIDs, nRails, nLutSize, fVerbose );
+    Abc_Ntk_t * pNew  = pLuts ? Abc_NtkLutCascadeFromLuts( pLuts, nVars, pNtk, nLutSize, fVerbose ) : NULL;
+    Vec_IntFree( vVarIDs );
+    
+    if ( pLuts && fVerbose ) {
+        word * pTruth2 = Abc_LutCascadeTruth( pLuts, Abc_NtkCiNum(pNtk) );
+        if ( nVars < 9 ) {
+            printf("Function before: "); Abc_TtPrintHexRev( stdout, pTruth1, nVars ); printf( "\n" );
+            printf("Function after:  "); Abc_TtPrintHexRev( stdout, pTruth2, nVars ); printf( "\n" );
+        }
+        Abc_LutCascadePrint( pLuts );
+        ABC_FREE( pLuts );
+        ABC_FREE( pTruth2 );
+    }
+    Gia_ManStop( pGia );
+    //ABC_FREE( pTruth1 );
+    return pNew;
+}
+Abc_Ntk_t * Abc_NtkLutCascadeGen( int nLutSize, int nStages, int nRails, int nShared, int fVerbose )
+{
+    int nVars = nStages * nLutSize - (nStages-1) * (nRails + nShared);
+    word * pLuts = Abc_LutCascadeGen( nVars, nLutSize, nRails, nShared );
+    Abc_Ntk_t * pNew = Abc_NtkLutCascadeFromLuts( pLuts, nVars, NULL, nLutSize, fVerbose );
+    Abc_LutCascadePrint( pLuts );
+    if ( fVerbose ) {
+        word * pTruth = Abc_LutCascadeTruth( pLuts, nVars );
+        if ( nVars <= 10 ) {
+            printf( "Function: "); Abc_TtPrintHexRev( stdout, pTruth, nVars ); printf( "\n" );
+        }
+        ABC_FREE( pTruth );
+    }
+    ABC_FREE( pLuts );
+    return pNew;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Structural LUT cascade mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+typedef struct Abc_LutCas_t_  Abc_LutCas_t;
+struct Abc_LutCas_t_
+{
+    // mapped network
+    Abc_Ntk_t *        pNtk;
+    // parameters
+    int                nLutSize;
+    int                nLutsMax;
+    int                nIters;
+    int                fDelayLut;
+    int                fDelayRoute;
+    int                fDelayDirect;
+    int                fVerbose;
+    // internal data
+    int                DelayMax;
+    Vec_Int_t *        vTime[2];   // timing info
+    Vec_Int_t *        vCrits[2];  // critical terminals
+    Vec_Int_t *        vPath[2];   // direct connections
+    Vec_Wec_t *        vStack;     // processing queue
+    Vec_Int_t *        vZeroSlack; // zero-slack nodes
+    Vec_Int_t *        vCands;     // direct edge candidates
+    Vec_Int_t *        vTrace;     // modification trace
+    Vec_Int_t *        vTraceBest; // modification trace
+};
+
+Abc_LutCas_t * Abc_LutCasAlloc( Abc_Ntk_t * pNtk, int nLutsMax, int nIters, int fDelayLut, int fDelayRoute, int fDelayDirect, int fVerbose )
+{
+    Abc_LutCas_t * p = ABC_ALLOC( Abc_LutCas_t, 1 );
+    p->pNtk         = pNtk;
+    p->nLutSize     = 6;
+    p->nLutsMax     = nLutsMax;
+    p->nIters       = nIters;
+    p->fDelayLut    = fDelayLut;
+    p->fDelayRoute  = fDelayRoute;
+    p->fDelayDirect = fDelayDirect;
+    p->fVerbose     = fVerbose;
+    p->vTime[0]   = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
+    p->vTime[1]   = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
+    p->vCrits[0]  = Vec_IntAlloc(1000);
+    p->vCrits[1]  = Vec_IntAlloc(1000);
+    p->vPath[0]   = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
+    p->vPath[1]   = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
+    p->vStack     = Vec_WecStart( Abc_NtkLevel(pNtk) + 1 );
+    p->vZeroSlack = Vec_IntAlloc( 1000 );
+    p->vCands     = Vec_IntAlloc( 1000 );
+    p->vTrace     = Vec_IntAlloc( 1000 );
+    p->vTraceBest = Vec_IntAlloc( 1000 );
+    return p;
+}
+void Abc_LutCasFree( Abc_LutCas_t * p )
+{
+    Vec_IntFree( p->vTime[0]   );
+    Vec_IntFree( p->vTime[1]   );
+    Vec_IntFree( p->vCrits[0]  );
+    Vec_IntFree( p->vCrits[1]  );
+    Vec_IntFree( p->vPath[0]   );
+    Vec_IntFree( p->vPath[1]   );
+    Vec_WecFree( p->vStack     );
+    Vec_IntFree( p->vZeroSlack );
+    Vec_IntFree( p->vCands     );
+    Vec_IntFree( p->vTrace     );
+    Vec_IntFree( p->vTraceBest );
+    ABC_FREE( p );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Structural LUT cascade mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkFindPathTimeD_rec( Abc_LutCas_t * p, Abc_Obj_t * pObj )
+{
+    if ( !Abc_ObjIsNode(pObj) || !Abc_ObjFaninNum(pObj) )
+        return 0;
+    if ( Vec_IntEntry(p->vTime[0], pObj->Id) > 0 )
+        return Vec_IntEntry(p->vTime[0], pObj->Id);    
+    Abc_Obj_t * pNext; int i, Delay, DelayMax = 0;
+    Abc_ObjForEachFanin( pObj, pNext, i ) {
+        Delay  = Abc_NtkFindPathTimeD_rec( p, pNext );
+        Delay += Vec_IntEntry(p->vPath[0], pObj->Id) == pNext->Id ? p->fDelayDirect : p->fDelayRoute;
+        DelayMax = Abc_MaxInt( DelayMax, Delay + p->fDelayLut );
+    }
+    Vec_IntWriteEntry( p->vTime[0], pObj->Id, DelayMax );
+    return DelayMax;
+}
+int Abc_NtkFindPathTimeD( Abc_LutCas_t * p )
+{
+    Abc_Obj_t * pObj; int i, Delay, DelayMax = 0;
+    Vec_IntFill( p->vTime[0], Abc_NtkObjNumMax(p->pNtk), 0 );
+    Abc_NtkForEachCo( p->pNtk, pObj, i ) {
+        Delay = Abc_NtkFindPathTimeD_rec( p, Abc_ObjFanin0(pObj) );
+        DelayMax = Abc_MaxInt( DelayMax, Delay + p->fDelayRoute );
+    }
+    Vec_IntClear( p->vCrits[0] );
+    Abc_NtkForEachCo( p->pNtk, pObj, i )
+        if ( DelayMax == Vec_IntEntry(p->vTime[0], Abc_ObjFaninId0(pObj)) + p->fDelayRoute )
+            Vec_IntPush( p->vCrits[0], pObj->Id );
+    return DelayMax;
+}
+int Abc_NtkFindPathTimeR_rec( Abc_LutCas_t * p, Abc_Obj_t * pObj )
+{
+    if ( Abc_ObjIsCo(pObj) )
+        return 0;
+    if ( Vec_IntEntry(p->vTime[1], pObj->Id) > 0 )
+        return Vec_IntEntry(p->vTime[1], pObj->Id) + (Abc_ObjIsNode(pObj) ? p->fDelayLut : 0);
+    Abc_Obj_t * pNext; int i; float Delay, DelayMax = 0;
+    Abc_ObjForEachFanout( pObj, pNext, i ) {
+        Delay  = Abc_NtkFindPathTimeR_rec( p, pNext );
+        Delay += Vec_IntEntry(p->vPath[0], pNext->Id) == pObj->Id ? p->fDelayDirect : p->fDelayRoute;
+        DelayMax = Abc_MaxInt( DelayMax, Delay );
+    }
+    Vec_IntWriteEntry( p->vTime[1], pObj->Id, DelayMax );
+    return DelayMax + (Abc_ObjIsNode(pObj) ? p->fDelayLut : 0);
+}
+int Abc_NtkFindPathTimeR( Abc_LutCas_t * p )
+{
+    Abc_Obj_t * pObj; int i; int Delay, DelayMax = 0;
+    Vec_IntFill( p->vTime[1], Abc_NtkObjNumMax(p->pNtk), 0 );
+    Abc_NtkForEachCi( p->pNtk, pObj, i ) {        
+        Delay = Abc_NtkFindPathTimeR_rec( p, pObj );
+        DelayMax = Abc_MaxInt( DelayMax, Delay );
+    }
+    Vec_IntClear( p->vCrits[1] );
+    Abc_NtkForEachCi( p->pNtk, pObj, i )
+        if ( DelayMax == Vec_IntEntry(p->vTime[1], pObj->Id) )
+            Vec_IntPush( p->vCrits[1], pObj->Id );
+    return DelayMax;
+}
+void Abc_NtkFindCriticalEdges( Abc_LutCas_t * p )
+{
+    Abc_Obj_t * pObj, * pFanin; int i, k;
+    Vec_IntClear( p->vCands );
+    Abc_NtkForEachNode( p->pNtk, pObj, i ) {
+        if ( Vec_IntEntry(p->vPath[0], pObj->Id) )
+            continue;
+        if ( Vec_IntEntry(p->vTime[0], pObj->Id) + Vec_IntEntry(p->vTime[1], pObj->Id) < p->DelayMax )
+            continue;
+        assert( Vec_IntEntry(p->vTime[0], pObj->Id) + Vec_IntEntry(p->vTime[1], pObj->Id == p->DelayMax) );
+        Abc_ObjForEachFanin( pObj, pFanin, k )
+            if ( Abc_ObjIsNode(pFanin) && !Vec_IntEntry(p->vPath[1], pFanin->Id) && 
+                 Vec_IntEntry(p->vTime[0], pFanin->Id) + p->fDelayRoute + p->fDelayLut == Vec_IntEntry(p->vTime[0], pObj->Id) )
+                Vec_IntPushTwo( p->vCands, pObj->Id, pFanin->Id );
+    }    
+}
+int Abc_NtkFindTiming( Abc_LutCas_t * p )
+{
+    int Delay0 = Abc_NtkFindPathTimeD( p );
+    int Delay1 = Abc_NtkFindPathTimeR( p );
+    assert( Delay0 == Delay1 );
+    p->DelayMax = Delay0;
+    Abc_NtkFindCriticalEdges( p );
+    return Delay0;
+}
+
+int Abc_NtkUpdateNodeD( Abc_LutCas_t * p, Abc_Obj_t * pObj )
+{
+    Abc_Obj_t * pNext; int i; int Delay, DelayMax = 0;
+    Abc_ObjForEachFanin( pObj, pNext, i ) {
+        Delay  = Vec_IntEntry( p->vTime[0], pNext->Id );
+        Delay += Vec_IntEntry(p->vPath[0], pObj->Id) == pNext->Id ? p->fDelayDirect : p->fDelayRoute;
+        DelayMax = Abc_MaxInt( DelayMax, Delay + p->fDelayLut );
+    }
+    int DelayOld = Vec_IntEntry( p->vTime[0], pObj->Id );
+    Vec_IntWriteEntry( p->vTime[0], pObj->Id, DelayMax );
+    assert( DelayOld >= DelayMax );
+    return DelayOld > DelayMax;
+}
+int Abc_NtkUpdateNodeR( Abc_LutCas_t * p, Abc_Obj_t * pObj )
+{
+    Abc_Obj_t * pNext; int i; float Delay, DelayMax = 0;
+    Abc_ObjForEachFanout( pObj, pNext, i ) {
+        Delay  = Vec_IntEntry(p->vTime[1], pNext->Id) + (Abc_ObjIsNode(pNext) ? p->fDelayLut : 0);
+        Delay += Vec_IntEntry(p->vPath[0], pNext->Id) == pObj->Id ? p->fDelayDirect : p->fDelayRoute;
+        DelayMax = Abc_MaxInt( DelayMax, Delay );
+    }
+    int DelayOld = Vec_IntEntry( p->vTime[1], pObj->Id );
+    Vec_IntWriteEntry( p->vTime[1], pObj->Id, DelayMax );
+    assert( DelayOld >= DelayMax );
+    return DelayOld > DelayMax;
+}
+int Abc_NtkUpdateTiming( Abc_LutCas_t * p, int Node, int Fanin )
+{
+    Abc_Obj_t * pNode  = Abc_NtkObj( p->pNtk, Node );
+    Abc_Obj_t * pFanin = Abc_NtkObj( p->pNtk, Fanin );
+    Abc_Obj_t * pNext, * pTemp; Vec_Int_t * vLevel; int i, k, j;
+    assert( Abc_ObjIsNode(pNode) && Abc_ObjIsNode(pFanin) );
+    Vec_WecForEachLevel( p->vStack, vLevel, i )
+        Vec_IntClear( vLevel );
+    Abc_NtkIncrementTravId( p->pNtk );
+    Abc_NodeSetTravIdCurrentId( p->pNtk, Node );
+    Abc_NodeSetTravIdCurrentId( p->pNtk, Fanin );
+    Vec_WecPush( p->vStack, pNode->Level, Node );
+    Vec_WecPush( p->vStack, pFanin->Level, Fanin );
+    Vec_WecForEachLevelStart( p->vStack, vLevel, i, pNode->Level )
+        Abc_NtkForEachObjVec( vLevel, p->pNtk, pTemp, k ) {
+            if ( !Abc_NtkUpdateNodeD(p, pTemp) )
+                continue;
+            Abc_ObjForEachFanout( pTemp, pNext, j ) {
+                if ( Abc_NodeIsTravIdCurrent(pNext) || Abc_ObjIsCo(pNext) ) 
+                    continue;
+                Abc_NodeSetTravIdCurrent( pNext );
+                Vec_WecPush( p->vStack, pNext->Level, pNext->Id );                    
+            }
+        }
+    Vec_WecForEachLevelReverseStartStop( p->vStack, vLevel, i, pFanin->Level+1, 0 )
+        Abc_NtkForEachObjVec( vLevel, p->pNtk, pTemp, k ) {
+            if ( !Abc_NtkUpdateNodeR(p, pTemp) )
+                continue;
+            Abc_ObjForEachFanin( pTemp, pNext, j ) {
+                if ( Abc_NodeIsTravIdCurrent(pNext) ) 
+                    continue;
+                Abc_NodeSetTravIdCurrent( pNext );
+                Vec_WecPush( p->vStack, pNext->Level, pNext->Id );                    
+            }
+        }
+    j = 0;
+    Abc_NtkForEachObjVec( p->vCrits[0], p->pNtk, pTemp, i )
+        if ( Vec_IntEntry(p->vTime[0], Abc_ObjFaninId0(pTemp)) + p->fDelayRoute == p->DelayMax )
+            Vec_IntWriteEntry( p->vCrits[0], j++, pTemp->Id );
+    Vec_IntShrink( p->vCrits[0], j );
+    j = 0;
+    Abc_NtkForEachObjVec( p->vCrits[1], p->pNtk, pTemp, i )
+        if ( Vec_IntEntry(p->vTime[1], pTemp->Id) == p->DelayMax )
+            Vec_IntWriteEntry( p->vCrits[1], j++, pTemp->Id );
+    Vec_IntShrink( p->vCrits[1], j );
+    if ( Vec_IntSize(p->vCrits[0]) && Vec_IntSize(p->vCrits[1]) ) {
+        int j = 0, Node2, Fanin2;
+        Vec_IntForEachEntryDouble( p->vCands, Node2, Fanin2, i )
+            if ( !Vec_IntEntry(p->vPath[0], Node2) && !Vec_IntEntry(p->vPath[1], Fanin2) && 
+                 Vec_IntEntry(p->vTime[0], Node2) + Vec_IntEntry(p->vTime[1], Node2) == p->DelayMax && 
+                 Vec_IntEntry(p->vTime[0], Fanin2) + p->fDelayRoute + p->fDelayLut == Vec_IntEntry(p->vTime[0], Node2) )
+                    Vec_IntWriteEntry( p->vCands, j++, Node2 ), Vec_IntWriteEntry( p->vCands, j++, Fanin2 );
+        Vec_IntShrink( p->vCands, j );
+        return p->DelayMax;
+    }
+    int DelayOld = p->DelayMax;
+    Abc_NtkFindTiming(p);
+    assert( DelayOld > p->DelayMax );
+    return p->DelayMax;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Structural LUT cascade mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkAddEdges( Abc_LutCas_t * p )
+{
+    int nEdgesMax = 10000;
+    Vec_IntClear( p->vTrace );
+    Vec_IntFill( p->vPath[0], Vec_IntSize(p->vPath[0]), 0 );
+    Vec_IntFill( p->vPath[1], Vec_IntSize(p->vPath[1]), 0 );
+    Abc_NtkFindTiming( p );
+    if ( p->fVerbose )
+        printf( "Start : %d\n", p->DelayMax );
+    int i, LastChange = 0;
+    for ( i = 0; i < nEdgesMax; i++ ) 
+    {
+        float DelayPrev = p->DelayMax;
+        if ( Vec_IntSize(p->vCands) == 0 )
+            break;
+        int Index = rand() % Vec_IntSize(p->vCands)/2;
+        int Node  = Vec_IntEntry( p->vCands, 2*Index );
+        int Fanin = Vec_IntEntry( p->vCands, 2*Index+1 );
+        assert( Vec_IntEntry( p->vPath[0], Node ) == 0 );
+        Vec_IntWriteEntry( p->vPath[0], Node, Fanin );
+        assert( Vec_IntEntry( p->vPath[1], Fanin ) == 0 );
+        Vec_IntWriteEntry( p->vPath[1], Fanin, Node );
+        Vec_IntPushTwo( p->vTrace, Node, Fanin );
+        //Abc_NtkFindTiming( p );
+        Abc_NtkUpdateTiming( p, Node, Fanin );
+        assert( DelayPrev >= p->DelayMax );
+        if ( DelayPrev > p->DelayMax )
+            LastChange = i+1;
+        DelayPrev = p->DelayMax;
+        if ( p->fVerbose )
+            printf( "%5d : %d : %4d -> %4d\n", i, p->DelayMax, Fanin, Node );
+    }
+    Vec_IntShrink( p->vTrace, 2*LastChange );
+    return p->DelayMax;
+}
+Vec_Wec_t * Abc_NtkProfileCascades( Abc_Ntk_t * pNtk, Vec_Int_t * vTrace )
+{
+    Vec_Wec_t * vCasc = Vec_WecAlloc( 100 );
+    Vec_Int_t * vMap  = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
+    Vec_Int_t * vPath = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
+    Vec_Int_t * vCounts = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
+    Abc_Obj_t * pObj; int i, Node, Fanin, Count, nCascs = 0;
+    Vec_IntForEachEntryDouble( vTrace, Node, Fanin, i ) {
+        assert( Vec_IntEntry(vPath, Node) == 0 );
+        Vec_IntWriteEntry( vPath, Node, Fanin );
+        Vec_IntWriteEntry( vMap, Fanin, 1 );
+    }
+    Abc_NtkForEachNode( pNtk, pObj, i ) {
+        if ( Vec_IntEntry(vMap, pObj->Id) )
+            continue;
+        if ( Vec_IntEntry(vPath, pObj->Id) == 0 )
+            continue;
+        Vec_Int_t * vLevel = Vec_WecPushLevel( vCasc );
+        Node = pObj->Id;
+        Vec_IntPush( vLevel, Node );
+        while ( (Node = Vec_IntEntry(vPath, Node)) )
+            Vec_IntPush( vLevel, Node );
+        Vec_IntAddToEntry( vCounts, Vec_IntSize(vLevel), 1 );
+    }
+    printf( "Cascades: " );
+    Vec_IntForEachEntry( vCounts, Count, i )
+        if ( Count )
+            printf( "%d=%d ", i, Count ), nCascs += Count;
+    printf( "\n" );
+    Vec_IntFree( vMap );
+    Vec_IntFree( vPath );
+    Vec_IntFree( vCounts );
+    return vCasc;
+}
+void Abc_LutCasAssignNames( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkNew, Vec_Wec_t * vCascs )
+{
+    Abc_Obj_t * pObj; Vec_Int_t * vLevel; int i, k; char pName[100];
+    Vec_Int_t * vMap = Vec_IntStart( Abc_NtkObjNumMax(pNtk) );
+    Abc_NtkForEachCo( pNtkNew, pObj, i )
+        Vec_IntWriteEntry( vMap, Abc_ObjFaninId0(pObj), pObj->Id );
+    Vec_WecForEachLevel( vCascs, vLevel, i ) {
+        Abc_NtkForEachObjVec( vLevel, pNtk, pObj, k ) {
+            assert( Abc_ObjIsNode(pObj) );
+            sprintf( pName, "c%d_n%d", i, k );
+            if ( Vec_IntEntry(vMap, pObj->pCopy->Id) == 0 )
+                Abc_ObjAssignName( Abc_NtkObj(pNtkNew, pObj->pCopy->Id), pName, NULL );
+            else {
+                Nm_ManDeleteIdName( pNtkNew->pManName, Vec_IntEntry(vMap, pObj->pCopy->Id) );
+                Abc_ObjAssignName( Abc_NtkObj(pNtkNew, Vec_IntEntry(vMap, pObj->pCopy->Id)), pName, NULL );
+            }
+        }
+    }
+    Vec_IntFree( vMap );
+}
+void Abc_NtkLutCascadeDumpResults( char * pDumpFile, char * pTest, int Nodes, int Edges, int Levs, int DelStart, int DelStop, float DelRatio, int EdgesUsed, float EdgeRatio, int Cascs, float AveLength, abctime time )
+{
+    FILE * pTable = fopen( pDumpFile, "a+" );
+    fprintf( pTable, "%s,", pTest+28 );
+    fprintf( pTable, "%d,", Nodes );
+    fprintf( pTable, "%d,", Edges );
+    fprintf( pTable, "%d,", Levs );
+    fprintf( pTable, "%d,", DelStart );
+    fprintf( pTable, "%d,", DelStop );
+    fprintf( pTable, "%.2f,", DelRatio );
+    fprintf( pTable, "%d,", EdgesUsed );
+    fprintf( pTable, "%.2f,", EdgeRatio );
+    fprintf( pTable, "%d,",   Cascs );
+    fprintf( pTable, "%.1f,", AveLength );
+    fprintf( pTable, "%.2f,", 1.0*((double)(time))/((double)CLOCKS_PER_SEC) );
+    fprintf( pTable, "\n" );
+    fclose( pTable );
+}
+
+Abc_Ntk_t * Abc_NtkLutCascadeMap( Abc_Ntk_t * pNtk, int nLutsMax, int nIters, int fDelayLut, int fDelayRoute, int fDelayDirect, int fVerbose )
+{
+    abctime clk = Abc_Clock();
+    Abc_Ntk_t * pNtkNew = NULL;
+    Abc_LutCas_t * p = Abc_LutCasAlloc( pNtk, nLutsMax, nIters, fDelayLut, fDelayRoute, fDelayDirect, fVerbose );
+    int i, IterBest = 0, DelayStart = Abc_NtkFindTiming( p ),  DelayBest = DelayStart, nEdges = Abc_NtkGetTotalFanins(pNtk);
+    //printf( "Delays: LUT (%d) Route (%d) Direct (%d).  Iters = %d.  LUTs = %d.\n", fDelayLut, fDelayRoute, fDelayDirect, nIters, Abc_NtkNodeNum(pNtk) );
+    Vec_IntFill( p->vTraceBest, Abc_NtkNodeNum(pNtk), 0 );
+    for ( i = 0; i < nIters; i++ )
+    {
+        if ( fVerbose )
+            printf( "ITERATION %2d:\n", i );
+        float Delay = Abc_NtkAddEdges( p );
+        if ( DelayBest < Delay || (DelayBest == Delay && Vec_IntSize(p->vTraceBest) <= Vec_IntSize(p->vTrace)) )
+            continue;
+        IterBest = i;
+        DelayBest = Delay;
+        ABC_SWAP( Vec_Int_t *, p->vTrace, p->vTraceBest );
+    }
+    printf( "Delay reduction %d -> %d (-%.2f %%) is found after iter %d with %d edges (%.2f %%). ", 
+        DelayStart, DelayBest, 100.0*(DelayStart - DelayBest)/DelayStart, IterBest, Vec_IntSize(p->vTraceBest)/2, 50.0*Vec_IntSize(p->vTraceBest)/nEdges );
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+    Vec_Wec_t * vCascs = Abc_NtkProfileCascades( p->pNtk, p->vTraceBest );
+//    Abc_NtkLutCascadeDumpResults( "stats.csv", pNtk->pName, Abc_NtkNodeNum(pNtk), nEdges, Abc_NtkLevel(pNtk), DelayStart, DelayBest, 100.0*(DelayStart - DelayBest)/DelayStart,
+//        Vec_IntSize(p->vTraceBest)/2, 50.0*Vec_IntSize(p->vTraceBest)/nEdges, Vec_WecSize(vCascs), 0.5*Vec_IntSize(p->vTraceBest)/Abc_MaxInt(1, Vec_WecSize(vCascs)), Abc_Clock() - clk );
+    Abc_LutCasFree( p );
+    pNtkNew = Abc_NtkDup( pNtk );
+    Abc_LutCasAssignNames( pNtk, pNtkNew, vCascs );
+    Vec_WecFree( vCascs );
+    return pNtkNew;
+}
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
diff --git a/src/base/abci/abcDar.c b/src/base/abci/abcDar.c
index a209143f3..d5ea77c78 100644
--- a/src/base/abci/abcDar.c
+++ b/src/base/abci/abcDar.c
@@ -1221,6 +1221,8 @@ Abc_Ntk_t * Abc_NtkFromDarChoices( Abc_Ntk_t * pNtkOld, Aig_Man_t * pMan )
     Aig_ManForEachNode( pMan, pObj, i )
     {
         pObj->pData = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, (Abc_Obj_t *)Aig_ObjChild0Copy(pObj), (Abc_Obj_t *)Aig_ObjChild1Copy(pObj) );
+    }
+    Aig_ManForEachNode( pMan, pObj, i ) {
         if ( (pTemp = Aig_ObjEquiv(pMan, pObj)) )
         {
             assert( pTemp->pData != NULL );
diff --git a/src/base/abci/abcLutmin.c b/src/base/abci/abcLutmin.c
index 883a56904..9b5b98881 100644
--- a/src/base/abci/abcLutmin.c
+++ b/src/base/abci/abcLutmin.c
@@ -430,10 +430,10 @@ Abc_Obj_t * Abc_NtkBddCurtis( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pNode, Vec_Ptr_t
     int b, c, u, i;
     assert( nBits + 2 <= nLutSize );
     assert( nLutSize < Abc_ObjFaninNum(pNode) );
-    // start BDDs for the decompoosed blocks
+    // start BDDs for the decomposed blocks
     for ( b = 0; b < nBits; b++ )
         bBits[b] = Cudd_ReadLogicZero(ddNew), Cudd_Ref( bBits[b] );
-    // add each bound set minterm to one of the blccks
+    // add each bound set minterm to one of the blocks
     Vec_PtrForEachEntry( DdNode *, vCofs, bCof, c )
     {
         Vec_PtrForEachEntry( DdNode *, vUniq, bUniq, u )
diff --git a/src/base/abci/abcMap.c b/src/base/abci/abcMap.c
index 0c84a04b8..2c3021b45 100644
--- a/src/base/abci/abcMap.c
+++ b/src/base/abci/abcMap.c
@@ -59,7 +59,7 @@ static Abc_Obj_t *  Abc_NodeFromMapSuperChoice_rec( Abc_Ntk_t * pNtkNew, Map_Sup
   SeeAlso     []
 
 ***********************************************************************/
-Abc_Ntk_t * Abc_NtkMap( Abc_Ntk_t * pNtk, double DelayTarget, double AreaMulti, double DelayMulti, float LogFan, float Slew, float Gain, int nGatesMin, int fRecovery, int fSwitching, int fSkipFanout, int fUseProfile, int fUseBuffs, int fVerbose )
+Abc_Ntk_t * Abc_NtkMap( Abc_Ntk_t * pNtk, Mio_Library_t* userLib, double DelayTarget, double AreaMulti, double DelayMulti, float LogFan, float Slew, float Gain, int nGatesMin, int fRecovery, int fSwitching, int fSkipFanout, int fUseProfile, int fUseBuffs, int fVerbose )
 {
     static int fUseMulti = 0;
     int fShowSwitching = 1;
@@ -88,6 +88,11 @@ Abc_Ntk_t * Abc_NtkMap( Abc_Ntk_t * pNtk, double DelayTarget, double AreaMulti,
         Map_SuperLibFree( (Map_SuperLib_t *)Abc_FrameReadLibSuper() );
         Abc_FrameSetLibSuper( NULL );
     }
+
+    if ( userLib != NULL ) {
+        pLib = userLib;
+    }
+ 
     // quit if there is no library
     if ( pLib == NULL )
     {
@@ -847,7 +852,7 @@ Vec_Int_t * Abc_NtkWriteMiniMapping( Abc_Ntk_t * pNtk )
     // write the numbers of CI/CO/Node/FF
     Vec_IntPush( vMapping, Abc_NtkCiNum(pNtk) );
     Vec_IntPush( vMapping, Abc_NtkCoNum(pNtk) );
-    Vec_IntPush( vMapping, Abc_NtkNodeNum(pNtk) );
+    Vec_IntPush( vMapping, Vec_PtrSize(vNodes) );
     Vec_IntPush( vMapping, Abc_NtkLatchNum(pNtk) );
     // write the nodes
     vGates = Vec_StrAlloc( 10000 );
@@ -863,6 +868,15 @@ Vec_Int_t * Abc_NtkWriteMiniMapping( Abc_Ntk_t * pNtk )
     // write the COs literals
     Abc_NtkForEachCo( pNtk, pObj, i )
         Vec_IntPush( vMapping, Abc_ObjFanin0(pObj)->iTemp );
+    // write signal names
+    Abc_NtkForEachCi( pNtk, pObj, i ) {
+        Vec_StrPrintStr( vGates, Abc_ObjName(pObj) );        
+        Vec_StrPush( vGates, '\0' );
+    }
+    Abc_NtkForEachCo( pNtk, pObj, i ) {
+        Vec_StrPrintStr( vGates, Abc_ObjName(pObj) );
+        Vec_StrPush( vGates, '\0' );
+    }
     // finish off the array
     nExtra = 4 - Vec_StrSize(vGates) % 4;
     for ( i = 0; i < nExtra; i++ )
@@ -879,6 +893,129 @@ Vec_Int_t * Abc_NtkWriteMiniMapping( Abc_Ntk_t * pNtk )
     return vMapping;
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Build mapped network from the mini-mapped format.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Ntk_t * Abc_NtkFromMiniMapping( int *pArray )
+{
+    if ( !pArray ) {
+        printf("Mapping is not available.\n");
+        return NULL;
+    }
+    Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen();
+    if ( !pLib ) {
+        printf("Library is not available.\n");
+        return NULL;
+    }
+    Abc_Ntk_t *pNtkMapped = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_MAP, 1 );
+    pNtkMapped->pName = Extra_UtilStrsav( "mapped" );
+    pNtkMapped->pManFunc = pLib;
+    int nCis, nCos, nNodes, nFlops;
+    int i, k, nLeaves, Pos = 4;
+    char * pBuffer, * pName;
+    Mio_Gate_t *pGate;
+    Abc_Obj_t * pObj;
+    nCis = pArray[0];
+    nCos = pArray[1];
+    nNodes = pArray[2];
+    nFlops = pArray[3];
+    // create pis
+    for ( i = 0; i < nCis-nFlops; i++ )
+        Abc_NtkCreatePi( pNtkMapped );
+    // create pos
+    for ( i = 0; i < nCos-nFlops; i++ )
+        Abc_NtkCreatePo( pNtkMapped );
+    // create flops
+    for ( i = 0; i < nFlops; i++ )
+        Abc_NtkAddLatch( pNtkMapped, NULL, ABC_INIT_ZERO );
+    // create nodes
+    for ( i = 0; i < nNodes; i++ )
+        Abc_NtkCreateNode( pNtkMapped );
+    // connect nodes
+    for ( i = 0; i < nNodes; i++ )
+    {
+        nLeaves = pArray[Pos++];
+        for ( k = 0; k < nLeaves; k++ )
+            Abc_ObjAddFanin( Abc_NtkObj( pNtkMapped, nCis + i + 1 ), Abc_NtkObj( pNtkMapped, pArray[Pos++] + 1 ) );
+    }
+    for ( i = 0; i < nCos; i++ )
+        Abc_ObjAddFanin( Abc_NtkCo( pNtkMapped, i ), Abc_NtkObj( pNtkMapped, pArray[Pos++] + 1 ) );
+
+    pBuffer = (char *)(pArray + Pos);
+    for ( i = 0; i < nNodes; i++ )
+    {
+        pName = pBuffer;
+        pBuffer += strlen(pName) + 1;
+        pGate = Mio_LibraryReadGateByName( pLib, pName, NULL );
+        Abc_NtkObj( pNtkMapped, nCis + i + 1 )->pData = pGate;
+    }
+
+    assert( Abc_NtkCiNum(pNtkMapped) == nCis );
+    Abc_NtkForEachCi( pNtkMapped, pObj, i ) {
+        pName = pBuffer;
+        pBuffer += strlen(pName) + 1;
+        Abc_ObjAssignName( pObj, pName, NULL );
+    }
+    assert( Abc_NtkCoNum(pNtkMapped) == nCos );
+    Abc_NtkForEachCo( pNtkMapped, pObj, i ) {
+        pName = pBuffer;
+        pBuffer += strlen(pName) + 1;
+        Abc_ObjAssignName( pObj, pName, NULL );
+    }
+
+    if ( !Abc_NtkCheck( pNtkMapped ) ) {
+        fprintf( stdout, "Abc_NtkFromMiniMapping(): Network check has failed.\n" );
+    }
+
+    return pNtkMapped;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [File IO.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_Ntk_t * Abc_NtkReadFromFile( char * pFileName )
+{
+    int nSize = Extra_FileSize( pFileName );
+    if ( nSize == 0 )
+        return NULL;
+    FILE * pFile = fopen( pFileName, "rb" );
+    char * pArray = ABC_ALLOC( char, nSize );
+    int nSize2 = fread( pArray, sizeof(char), nSize, pFile );
+    assert( nSize2 == nSize );
+    fclose( pFile );
+    Abc_Ntk_t * pNtk = Abc_NtkFromMiniMapping( (int*)pArray );
+    ABC_FREE( pArray );
+    return pNtk;
+}
+int Abc_NtkWriteToFile( char * pFileName, Abc_Ntk_t * pNtk )
+{
+    Vec_Int_t * vRes = Abc_NtkWriteMiniMapping( pNtk );
+    FILE * pFile = fopen( pFileName, "wb" );
+    if ( pFile == NULL ) { printf( "Cannot open input file \"%s\" for writing.\n", pFileName ); return 0; }
+    int nSize = fwrite( Vec_IntArray(vRes), sizeof(int), Vec_IntSize(vRes), pFile );
+    assert( nSize == Vec_IntSize(vRes) );
+    Vec_IntFree( vRes );
+    fclose( pFile );
+    return 1;
+}
+
+
 /**Function*************************************************************
 
   Synopsis    [Prints mapped network represented in mini-mapped format.]
@@ -903,8 +1040,8 @@ void Abc_NtkPrintMiniMapping( int * pArray )
     printf( "The first %d object IDs (from 0 to %d) are reserved for the CIs.\n", nCis, nCis - 1 );
     for ( i = 0; i < nNodes; i++ )
     {
-        printf( "Node %d has fanins {", nCis + i );
         nLeaves = pArray[Pos++];
+        printf( "Node %d has %d fanins {", nCis + i, nLeaves );
         for ( k = 0; k < nLeaves; k++ )
             printf( " %d", pArray[Pos++] );
         printf( " }\n" );
@@ -918,6 +1055,38 @@ void Abc_NtkPrintMiniMapping( int * pArray )
         pBuffer += strlen(pName) + 1;
         printf( "Node %d has gate \"%s\"\n", nCis + i, pName );
     }
+    for ( i = 0; i < nCis; i++ )
+    {
+        pName = pBuffer;
+        pBuffer += strlen(pName) + 1;
+        printf( "CI %d has name \"%s\"\n", i, pName );
+    }
+    for ( i = 0; i < nCos; i++ )
+    {
+        pName = pBuffer;
+        pBuffer += strlen(pName) + 1;
+        printf( "CO %d has name \"%s\"\n", i, pName );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Procedures to update internal ABC network using mini-mapped network.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkInputMiniMapping( Abc_Frame_t * pAbc, void *p )
+{
+    Abc_Ntk_t * pNtk;
+    if ( pAbc == NULL )
+        printf( "ABC framework is not initialized by calling Abc_Start()\n" );
+    pNtk = Abc_NtkFromMiniMapping( (int *)p );
+    Abc_FrameReplaceCurrentNetwork( pAbc, pNtk );
 }
 
 /**Function*************************************************************
diff --git a/src/base/abci/abcMfs.c b/src/base/abci/abcMfs.c
index 69c04c2c3..ed38f6fc7 100644
--- a/src/base/abci/abcMfs.c
+++ b/src/base/abci/abcMfs.c
@@ -22,6 +22,7 @@
 #include "bool/kit/kit.h"
 #include "opt/sfm/sfm.h"
 #include "base/io/ioAbc.h"
+#include "misc/util/utilTruth.h"
 
 ABC_NAMESPACE_IMPL_START
 
@@ -330,6 +331,7 @@ void Abc_NtkInsertMfs( Abc_Ntk_t * pNtk, Sfm_Ntk_t * p )
         // update fanins
         vArray = Sfm_NodeReadFanins( p, pNode->iTemp );
         pTruth = Sfm_NodeReadTruth( p, pNode->iTemp );
+        Abc_TtFlipVar5( pTruth, Vec_IntSize(vArray) );
         pNode->pData = Abc_SopCreateFromTruthIsop( (Mem_Flex_t *)pNtk->pManFunc, Vec_IntSize(vArray), pTruth, vCover );
         if ( Abc_SopGetVarNum((char *)pNode->pData) == 0 )
             continue;
diff --git a/src/base/abci/abcMini.c b/src/base/abci/abcMini.c
index 67ce8382f..40e28dad6 100644
--- a/src/base/abci/abcMini.c
+++ b/src/base/abci/abcMini.c
@@ -144,6 +144,22 @@ Mini_Aig_t * Abc_NtkToMiniAig( Abc_Ntk_t * pNtk )
     Mini_AigSetRegNum( p, Abc_NtkLatchNum(pNtk) );
     return p;
 }
+Mini_Aig_t * Abc_MiniAigFromNtk ( Abc_Ntk_t *pNtk ) 
+{
+    Abc_Ntk_t *pNtkRes = NULL;
+    Mini_Aig_t *pAig;
+    if (Abc_NtkHasMapping(pNtk)) {
+        pNtk = pNtkRes = Abc_NtkStrash( pNtk, 0, 1, 0 );
+        if ( pNtkRes == NULL )
+        {
+            printf("Strashing has failed.\n" );
+            return NULL;
+        }
+    }
+    pAig = Abc_NtkToMiniAig(pNtk);
+    if (pNtkRes) Abc_NtkDelete(pNtkRes);
+    return pAig;
+}
 
 /**Function*************************************************************
 
diff --git a/src/base/abci/abcOrchestration.c b/src/base/abci/abcOrchestration.c
index af36939dd..5d12a529b 100644
--- a/src/base/abci/abcOrchestration.c
+++ b/src/base/abci/abcOrchestration.c
@@ -3383,26 +3383,43 @@ clk = Abc_Clock();
 Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
             if ( fCompl ) Dec_GraphComplement( pGraph );
             ops_rwr++;
+            if(pFFormRef != NULL){
+                Dec_GraphFree( pFFormRef );
+            }
+            if(pFFormRes != NULL){
+                Dec_GraphFree( pFFormRes );
+            }
             continue;
         } 
         // if (((! (pManRes->nLastGain < 0)) && (! (pManRes->nLastGain < nGain)) && (! (nGain < pManRef->nLastGain))) || ((! (pManRes->nLastGain < 0)) && (! (pManRes->nLastGain < pManRef->nLastGain)) && (! (pManRef->nLastGain < nGain)))){
         if (((! (pManRes->nLastGain < 0)) && (! (pManRes->nLastGain < nGain)) && (! (pManRes->nLastGain < pManRef->nLastGain)))){
         // update with Resub
-            if ( pFFormRes == NULL )
+            if ( pFFormRes == NULL ) {
+                if (pFFormRef != NULL) {
+                    Dec_GraphFree(pFFormRef);
+                }
                 continue;
+            }
             pManRes->nTotalGain += pManRes->nLastGain;
 clk = Abc_Clock();
             Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
 pManRes->timeNtk += Abc_Clock() - clk;
             Dec_GraphFree( pFFormRes );
             ops_res++;
+            if( pFFormRef != NULL ){
+                Dec_GraphFree( pFFormRef);
+            }
             continue;
         }
         // if (((! (pManRef->nLastGain < 0)) && (! (pManRef->nLastGain < nGain)) && (! (nGain < pManRes->nLastGain))) || ((! (pManRef->nLastGain < 0)) && (! (pManRef->nLastGain < pManRes->nLastGain)) && (! (pManRes->nLastGain < nGain)))){
         if (((! (pManRef->nLastGain < 0)) && (! (pManRef->nLastGain < nGain)) && (! (pManRef->nLastGain < pManRes->nLastGain)))){
         // update with Refactor
-            if ( pFFormRef == NULL )
+            if ( pFFormRef == NULL ) {
+                if( pFFormRes != NULL) {
+                    Dec_GraphFree(pFFormRes);
+                }
                 continue;
+            }
 clk = Abc_Clock();
             if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                  {
@@ -3413,9 +3430,21 @@ clk = Abc_Clock();
 pManRef->timeNtk += Abc_Clock() - clk;
             Dec_GraphFree( pFFormRef );
             ops_ref++;
+            if(pFFormRes != NULL){
+                Dec_GraphFree( pFFormRes );
+            }
+            continue;
+        }
+        else{
+            ops_null++;
+            if( pFFormRef != NULL ){
+                Dec_GraphFree( pFFormRef);
+            }
+            if(pFFormRes != NULL){
+                Dec_GraphFree( pFFormRes );
+            }
             continue;
         }
-        else{ops_null++; continue;}
     }
 
     /*
diff --git a/src/base/abci/abcPart.c b/src/base/abci/abcPart.c
index fc654bc92..da4d55a65 100644
--- a/src/base/abci/abcPart.c
+++ b/src/base/abci/abcPart.c
@@ -21,6 +21,14 @@
 #include "base/abc/abc.h"
 #include "base/main/main.h"
 #include "base/cmd/cmd.h"
+#include "map/mio/mio.h"
+
+#ifdef WIN32
+#include <process.h> 
+#define unlink _unlink
+#else
+#include <unistd.h>
+#endif
 
 ABC_NAMESPACE_IMPL_START
 
@@ -1197,6 +1205,690 @@ void Abc_NtkFraigPartitionedTime( Abc_Ntk_t * pNtk, void * pParams )
     ABC_PRT( "Partitioned fraiging time", Abc_Clock() - clk );
 }
 
+
+/**Function*************************************************************
+
+  Synopsis    [Optimization.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkStochSynthesis( Vec_Ptr_t * vWins, char * pScript )
+{
+    Abc_Ntk_t * pNtk, * pNew; int i;
+    Vec_PtrForEachEntry( Abc_Ntk_t *, vWins, pNtk, i )
+    {
+        Abc_FrameReplaceCurrentNetwork( Abc_FrameGetGlobalFrame(), Abc_NtkDupDfs(pNtk) );
+        if ( Abc_FrameIsBatchMode() )
+        {
+            if ( Cmd_CommandExecute(Abc_FrameGetGlobalFrame(), pScript) )
+            {
+                Abc_Print( 1, "Something did not work out with the command \"%s\".\n", pScript );
+                return;
+            }
+        }
+        else
+        {
+            Abc_FrameSetBatchMode( 1 );
+            if ( Cmd_CommandExecute(Abc_FrameGetGlobalFrame(), pScript) )
+            {
+                Abc_Print( 1, "Something did not work out with the command \"%s\".\n", pScript );
+                Abc_FrameSetBatchMode( 0 );
+                return;
+            }
+            Abc_FrameSetBatchMode( 0 );
+        }
+        pNew = Abc_FrameReadNtk(Abc_FrameGetGlobalFrame());
+        if ( Abc_NtkIsMappedLogic(pNew) && Abc_NtkIsMappedLogic(pNtk) )
+        {
+            if ( Abc_NtkGetMappedArea(pNew) < Abc_NtkGetMappedArea(pNtk) )
+            {
+                Abc_NtkDelete( pNtk );
+                pNtk = Abc_NtkDupDfs( pNew );
+            }
+        }
+        else
+        {
+            if ( Abc_NtkNodeNum(pNew) < Abc_NtkNodeNum(pNtk) )
+            {
+                Abc_NtkDelete( pNtk );
+                pNtk = Abc_NtkDupDfs( pNew );
+            }
+        }
+        Vec_PtrWriteEntry( vWins, i, pNtk );
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Generic concurrent processing.]
+
+  Description [User-defined problem-specific data and the way to process it.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+typedef struct StochSynData_t_
+{
+    Abc_Ntk_t *  pIn;
+    Abc_Ntk_t *  pOut;
+    char *       pScript;
+    int          Rand;
+    int          TimeOut;
+} StochSynData_t;
+
+Abc_Ntk_t * Abc_NtkStochProcessOne( Abc_Ntk_t * p, char * pScript0, int Rand, int TimeSecs )
+{
+    extern int Abc_NtkWriteToFile( char * pFileName, Abc_Ntk_t * pNtk );
+    extern Abc_Ntk_t * Abc_NtkReadFromFile( char * pFileName );
+    Abc_Ntk_t * pNew, * pTemp;
+    char FileName[100], Command[1000], PreCommand[500] = {0};
+    char * pLibFileName = Abc_NtkIsMappedLogic(p) ? Mio_LibraryReadFileName((Mio_Library_t *)p->pManFunc) : NULL;
+    if ( pLibFileName ) sprintf( PreCommand, "read_genlib %s; ", pLibFileName );
+    sprintf( FileName, "%06x.mm", Rand );
+    Abc_NtkWriteToFile( FileName, p );    
+    char * pScript = Abc_UtilStrsav( pScript0 );
+    sprintf( Command, "./abc -q \"%sread_mm %s; %s; write_mm %s\"", PreCommand[0] ? PreCommand : "", FileName, pScript, FileName );    
+#if defined(__wasm)
+    if ( 1 )
+#else
+    if ( system( (char *)Command ) )    
+#endif
+    {
+        fprintf( stderr, "The following command has returned non-zero exit status:\n" );
+        fprintf( stderr, "\"%s\"\n", (char *)Command );
+        fprintf( stderr, "Sorry for the inconvenience.\n" );
+        fflush( stdout );
+        unlink( FileName );
+        ABC_FREE( pScript );
+        return Abc_NtkDupDfs(p);
+    }
+    ABC_FREE( pScript );
+    pNew = Abc_NtkReadFromFile( FileName );
+    unlink( FileName );
+    if ( pNew && Abc_NtkGetMappedArea(pNew) < Abc_NtkGetMappedArea(p) ) {
+        pNew = Abc_NtkDupDfs( pTemp = pNew );
+        Abc_NtkDelete( pTemp );
+        return pNew;
+    }
+    if ( pNew ) Abc_NtkDelete( pNew );
+    return Abc_NtkDupDfs(p);
+}
+
+int Abc_NtkStochProcess1( void * p )
+{
+    StochSynData_t * pData = (StochSynData_t *)p;
+    assert( pData->pIn != NULL );
+    assert( pData->pOut == NULL );
+    pData->pOut = Abc_NtkStochProcessOne( pData->pIn, pData->pScript, pData->Rand, pData->TimeOut );
+    return 1;
+}
+
+Vec_Ptr_t * Abc_NtkStochProcess( Vec_Ptr_t * vWins, char * pScript, int nProcs, int TimeSecs, int fVerbose )
+{
+    if ( nProcs <= 2 ) {
+        Abc_NtkStochSynthesis( vWins, pScript );
+        return NULL;
+    }
+    StochSynData_t * pData = ABC_CALLOC( StochSynData_t, Vec_PtrSize(vWins) );
+    Vec_Ptr_t * vData = Vec_PtrAlloc( Vec_PtrSize(vWins) ); 
+    Abc_Ntk_t * pNtk; int i;
+    Abc_Random(1);
+    Vec_PtrForEachEntry( Abc_Ntk_t *, vWins, pNtk, i ) {
+        pData[i].pIn     = pNtk;
+        pData[i].pOut    = NULL;
+        pData[i].pScript = pScript;
+        pData[i].Rand    = Abc_Random(0) % 0x1000000;
+        pData[i].TimeOut = TimeSecs;
+        Vec_PtrPush( vData, pData+i );
+    }
+    Util_ProcessThreads( Abc_NtkStochProcess1, vData, nProcs, TimeSecs, fVerbose );
+    // replace old AIGs by new AIGs
+    Vec_PtrForEachEntry( Abc_Ntk_t *, vWins, pNtk, i ) {
+        Abc_NtkDelete( pNtk );
+        Vec_PtrWriteEntry( vWins, i, pData[i].pOut );
+    }
+    Vec_PtrFree( vData );
+    ABC_FREE( pData );
+    return NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns 1 if this window has a topo error (forward path from an output to an input).]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkWindowCheckTopoError_rec( Abc_Obj_t * pObj )
+{
+    if ( !Abc_ObjIsNode(pObj) )
+        return 0;
+    if ( Abc_NodeIsTravIdPrevious(pObj) )
+        return 1; // there is an error
+    if ( Abc_NodeIsTravIdCurrent(pObj) )
+        return 0; // there is no error; visited this node before
+    Abc_NodeSetTravIdPrevious(pObj);
+    Abc_Obj_t * pFanin; int i;
+    Abc_ObjForEachFanin( pObj, pFanin, i )
+    if ( Abc_NtkWindowCheckTopoError_rec(pFanin) )
+        return 1;
+    Abc_NodeSetTravIdCurrent(pObj);
+    return 0;
+}
+int Abc_NtkWindowCheckTopoError( Abc_Ntk_t * p, Vec_Int_t * vIns, Vec_Int_t * vOuts )
+{
+    Abc_Obj_t * pObj; int i, fError = 0;
+    // outputs should be internal nodes
+    Abc_NtkForEachObjVec( vOuts, p, pObj, i )
+        assert(Abc_ObjIsNode(pObj));
+    // mark outputs
+    Abc_NtkIncrementTravId( p );
+    Abc_NtkForEachObjVec( vOuts, p, pObj, i )
+        Abc_NodeSetTravIdCurrent(pObj);
+    // start from inputs and make sure we do not reach any of the outputs
+    Abc_NtkIncrementTravId( p );
+    Abc_NtkForEachObjVec( vIns, p, pObj, i )
+        fError |= Abc_NtkWindowCheckTopoError_rec(pObj);
+    return fError;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Updates the AIG after multiple windows have been optimized.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkCreateNodeMapped( Abc_Ntk_t * pNew, Abc_Obj_t * pObj )
+{
+    Abc_Obj_t * pObjNew = Abc_NtkDupObj( pNew, pObj, 0 );
+    Abc_Obj_t * pFanin; int i;
+    Abc_ObjForEachFanin( pObj, pFanin, i )
+        Abc_ObjAddFanin( pObjNew, pFanin->pCopy );
+}
+void Abc_NtkInsertPartitions_rec( Abc_Ntk_t * pNew, Abc_Obj_t * pObj, Vec_Int_t * vMap, Vec_Ptr_t * vvIns, Vec_Ptr_t * vvOuts, Vec_Ptr_t * vWins )
+{
+    if ( pObj->pCopy )
+        return;
+    assert( Abc_ObjIsNode(pObj) );
+    if ( Vec_IntEntry(vMap, Abc_ObjId(pObj)) == -1 ) // this is a regular node
+    {
+        Abc_Obj_t * pFanin; int i;
+        Abc_ObjForEachFanin( pObj, pFanin, i )
+            Abc_NtkInsertPartitions_rec( pNew, pFanin, vMap, vvIns, vvOuts, vWins );
+        Abc_NtkCreateNodeMapped( pNew, pObj );
+        return;
+    }
+    // this node is an output of a window
+    int iWin = Vec_IntEntry(vMap, Abc_ObjId(pObj));
+    Vec_Int_t * vIns  = (Vec_Int_t *)Vec_PtrEntry(vvIns, iWin);
+    Vec_Int_t * vOuts = (Vec_Int_t *)Vec_PtrEntry(vvOuts, iWin);
+    Abc_Ntk_t * pWin  = (Abc_Ntk_t *)Vec_PtrEntry(vWins, iWin); 
+    // build transinvite fanins of window inputs
+    Abc_Obj_t * pNode; int i;
+    Abc_NtkForEachObjVec( vIns, pObj->pNtk, pNode, i ) {
+        Abc_NtkInsertPartitions_rec( pNew, pNode, vMap, vvIns, vvOuts, vWins );
+        Abc_NtkPi(pWin, i)->pCopy = pNode->pCopy;
+    }
+    // add window nodes
+    Vec_Ptr_t * vNodes = Abc_NtkDfs( pWin, 0 );
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
+        Abc_NtkCreateNodeMapped( pNew, pNode );
+    Vec_PtrFree( vNodes );
+    // transfer to window outputs
+    Abc_NtkForEachObjVec( vOuts, pObj->pNtk, pNode, i )
+        pNode->pCopy = Abc_ObjFanin0(Abc_NtkPo(pWin, i))->pCopy;
+    assert( pObj->pCopy );
+}
+Abc_Ntk_t * Abc_NtkInsertPartitions( Abc_Ntk_t * p, Vec_Ptr_t * vvIns, Vec_Ptr_t * vvOuts, Vec_Ptr_t * vWins )
+{
+    if ( vvIns == NULL ) {
+        assert( vvOuts == NULL );
+        assert( Vec_PtrSize(vWins) == 1 );
+        return Abc_NtkDupDfs( (Abc_Ntk_t *)Vec_PtrEntry(vWins, 0) );        
+    }
+    // check consistency of input data
+    Abc_Ntk_t * pNew, * pTemp; Abc_Obj_t * pObj; int i, k, iNode;
+    Vec_PtrForEachEntry( Abc_Ntk_t *, vWins, pTemp, i ) {
+        Vec_Int_t * vIns  = (Vec_Int_t *)Vec_PtrEntry(vvIns, i);
+        Vec_Int_t * vOuts = (Vec_Int_t *)Vec_PtrEntry(vvOuts, i);
+        assert( Vec_IntSize(vIns)  == Abc_NtkPiNum(pTemp) );
+        assert( Vec_IntSize(vOuts) == Abc_NtkPoNum(pTemp) );
+        assert( !Abc_NtkWindowCheckTopoError(p, vIns, vOuts) );        
+    }
+    // create mapping of window outputs into window IDs
+    Vec_Int_t * vMap = Vec_IntStartFull( Abc_NtkObjNumMax(p) ), * vOuts;
+    Vec_PtrForEachEntry( Vec_Int_t *, vvOuts, vOuts, i )
+        Vec_IntForEachEntry( vOuts, iNode, k ) {
+            assert( Vec_IntEntry(vMap, iNode) == -1 );
+            Vec_IntWriteEntry( vMap, iNode, i );
+        }
+    Abc_NtkCleanCopy( p );
+    pNew = Abc_NtkStartFrom( p, p->ntkType, p->ntkFunc );
+    pNew->pManFunc = p->pManFunc;
+    Abc_NtkForEachCo( p, pObj, i )
+        Abc_NtkInsertPartitions_rec( pNew, Abc_ObjFanin0(pObj), vMap, vvIns, vvOuts, vWins );
+    Abc_NtkForEachCo( p, pObj, i )
+        Abc_ObjAddFanin( Abc_NtkCo(pNew, i), Abc_ObjFanin0(pObj)->pCopy );
+    Vec_IntFree( vMap );
+    return pNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Partitioning.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_ObjDfsMark_rec( Abc_Obj_t * p )
+{
+    Abc_Obj_t * pFanin; int i;
+    assert( !p->fMarkA );
+    if ( Abc_NodeIsTravIdCurrent( p ) )
+        return;
+    Abc_NodeSetTravIdCurrent( p );
+    Abc_ObjForEachFanin( p, pFanin, i )
+        Abc_ObjDfsMark_rec( pFanin );
+}
+void Abc_ObjDfsMark2_rec( Abc_Obj_t * p )
+{
+    Abc_Obj_t * pFanout; int i;
+    assert( !p->fMarkA );
+    if ( Abc_NodeIsTravIdCurrent( p ) )
+        return;
+    Abc_NodeSetTravIdCurrent( p );
+    Abc_ObjForEachFanout( p, pFanout, i )
+        Abc_ObjDfsMark2_rec( pFanout );
+}
+Vec_Int_t * Abc_NtkDeriveWinNodes( Abc_Ntk_t * pNtk, Vec_Int_t * vIns, Vec_Wec_t * vStore )
+{
+    Vec_Int_t * vLevel, * vNodes = Vec_IntAlloc( 100 );
+    Abc_Obj_t * pObj, * pNext; int i, k, iLevel;
+    Vec_WecForEachLevel( vStore, vLevel, i )
+        Vec_IntClear( vLevel );
+    // mark the TFI cones of the inputs
+    Abc_NtkIncrementTravId( pNtk );
+    Abc_NtkForEachObjVec( vIns, pNtk, pObj, i )
+        Abc_ObjDfsMark_rec( pObj );
+    // add unrelated fanouts of the inputs to storage
+    Abc_NtkForEachObjVec( vIns, pNtk, pObj, i )
+        Abc_ObjForEachFanout( pObj, pNext, k )
+            if ( Abc_ObjIsNode(pNext) && !Abc_NodeIsTravIdCurrent(pNext) && !pNext->fMarkA ) {
+                pNext->fMarkA = 1;
+                Vec_WecPush( vStore, Abc_ObjLevel(pNext), Abc_ObjId(pNext) );
+            }
+    // mark the inputs
+    Abc_NtkIncrementTravId( pNtk );
+    Abc_NtkForEachObjVec( vIns, pNtk, pObj, i )
+        Abc_NodeSetTravIdCurrent(pObj);
+    // collect those fanouts that are completely supported by the inputs
+    Vec_WecForEachLevel( vStore, vLevel, iLevel )
+        Abc_NtkForEachObjVec( vLevel, pNtk, pObj, i ) {
+            assert( !Abc_NodeIsTravIdCurrent(pObj) );
+            assert( pObj->fMarkA );
+            pObj->fMarkA = 0;
+            Abc_ObjForEachFanin( pObj, pNext, k )
+                if ( !Abc_NodeIsTravIdCurrent(pNext) )
+                    break;
+            if ( k < Abc_ObjFaninNum(pObj) )
+                continue;
+            Abc_NodeSetTravIdCurrent(pObj);
+            Vec_IntPush( vNodes, Abc_ObjId(pObj) );
+            assert( Abc_ObjIsNode(pObj) );
+            // add fanouts of this node to storage
+            Abc_ObjForEachFanout( pObj, pNext, k ) 
+                if ( Abc_ObjIsNode(pNext) && !Abc_NodeIsTravIdCurrent(pNext) && !pNext->fMarkA ) {
+                    pNext->fMarkA = 1;
+                    assert( Abc_ObjLevel(pNext) > iLevel );
+                    Vec_WecPush( vStore, Abc_ObjLevel(pNext), Abc_ObjId(pNext) );
+                }
+        }
+    Vec_IntSort( vNodes, 0 );
+    return vNodes;
+}
+Vec_Ptr_t * Abc_NtkDeriveWinNodesAll( Abc_Ntk_t * pNtk, Vec_Ptr_t * vvIns, Vec_Wec_t * vStore )
+{
+    Vec_Int_t * vIns; int i;
+    Vec_Ptr_t * vvNodes = Vec_PtrAlloc( Vec_PtrSize(vvIns) );
+    Vec_PtrForEachEntry( Vec_Int_t *, vvIns, vIns, i ) 
+        Vec_PtrPush( vvNodes, Abc_NtkDeriveWinNodes(pNtk, vIns, vStore) );
+    return vvNodes;
+}
+Vec_Int_t * Abc_NtkDeriveWinOuts( Abc_Ntk_t * pNtk, Vec_Int_t * vNodes )
+{
+    Vec_Int_t * vOuts = Vec_IntAlloc( 100 );
+    Abc_Obj_t * pObj, * pNext; int i, k;
+    // mark the nodes in the window
+    Abc_NtkIncrementTravId( pNtk );
+    Abc_NtkForEachObjVec( vNodes, pNtk, pObj, i )
+        Abc_NodeSetTravIdCurrent(pObj);
+    // collect nodes that have unmarked fanouts
+    Abc_NtkForEachObjVec( vNodes, pNtk, pObj, i ) {
+        Abc_ObjForEachFanout( pObj, pNext, k )
+            if ( !Abc_NodeIsTravIdCurrent(pNext) )
+                break;
+        if ( k < Abc_ObjFanoutNum(pObj) )
+            Vec_IntPush( vOuts, Abc_ObjId(pObj) );
+    }
+    if ( Vec_IntSize(vOuts) == 0 )
+        printf( "Window with %d internal nodes has no outputs (are these dangling nodes?).\n", Vec_IntSize(vNodes) );
+    return vOuts;
+}
+Vec_Ptr_t * Abc_NtkDeriveWinOutsAll( Abc_Ntk_t * pNtk, Vec_Ptr_t * vvNodes )
+{
+    Vec_Int_t * vNodes; int i;
+    Vec_Ptr_t * vvOuts = Vec_PtrAlloc( Vec_PtrSize(vvNodes) );
+    Vec_PtrForEachEntry( Vec_Int_t *, vvNodes, vNodes, i ) 
+        Vec_PtrPush( vvOuts, Abc_NtkDeriveWinOuts(pNtk, vNodes) );
+    return vvOuts;
+}
+void Abc_NtkPermuteLevel( Abc_Ntk_t * pNtk, int Level )
+{
+    Abc_Obj_t * pObj, * pNext; int i, k;
+    Abc_NtkForEachNode( pNtk, pObj, i ) {
+        int LevelMin = Abc_ObjLevel(pObj), LevelMax = Level + 1;
+        Abc_ObjForEachFanout( pObj, pNext, k )
+            if ( Abc_ObjIsNode(pNext) )
+                LevelMax = Abc_MinInt( LevelMax, Abc_ObjLevel(pNext) );
+        assert( LevelMin < LevelMax );
+        // randomly set level between LevelMin and LevelMax-1
+        pObj->Level = LevelMin + (Abc_Random(0) % (LevelMax - LevelMin));
+        assert( pObj->Level < LevelMax );
+    }
+}
+Vec_Int_t * Abc_NtkCollectObjectsPointedTo( Abc_Ntk_t * pNtk, int Level )
+{
+    Vec_Int_t * vRes = Vec_IntAlloc( 100 ); 
+    Abc_Obj_t * pObj, * pFanin; int i, k;
+    Abc_NtkIncrementTravId( pNtk );
+    Abc_NtkForEachNode( pNtk, pObj, i ) {
+        if ( Abc_ObjLevel(pObj) <= Level )
+            continue;
+        Abc_ObjForEachFanin( pObj, pFanin, k )
+            if ( Abc_ObjLevel(pFanin) <= Level && !Abc_NodeIsTravIdCurrent(pFanin) ) {
+                Abc_NodeSetTravIdCurrent(pFanin);
+                Vec_IntPush( vRes, Abc_ObjId(pFanin) );
+            }
+    }
+    Abc_NtkForEachCo( pNtk, pObj, i ) {
+        pFanin = Abc_ObjFanin0(pObj);
+        if ( Abc_ObjLevel(pFanin) <= Level && !Abc_NodeIsTravIdCurrent(pFanin) && Abc_ObjFaninNum(pFanin) > 0 ) {
+            Abc_NodeSetTravIdCurrent(pFanin);
+            Vec_IntPush( vRes, Abc_ObjId(pFanin) );
+        }
+    }
+    Vec_IntSort( vRes, 0 );
+    return vRes;
+}
+Vec_Wec_t * Abc_NtkCollectObjectsWithSuppLimit( Abc_Ntk_t * pNtk, int Level, int nSuppMax )
+{
+    Vec_Wec_t * vResSupps = NULL;
+    Vec_Int_t * vBelow   = Abc_NtkCollectObjectsPointedTo( pNtk, Level );
+    Vec_Wec_t * vSupps   = Vec_WecStart( Vec_IntSize(vBelow) );
+    Vec_Int_t * vSuppIds = Vec_IntStartFull( Abc_NtkObjNumMax(pNtk)+1 );
+    Vec_Int_t * vTemp[2] = { Vec_IntAlloc(100), Vec_IntAlloc(100) };
+    Abc_Obj_t * pObj, * pFanin; int i, k, Count = 0;
+    Abc_NtkForEachObjVec( vBelow, pNtk, pObj, i ) {
+        Vec_IntWriteEntry( vSuppIds, Abc_ObjId(pObj), i );
+        Vec_IntPush( Vec_WecEntry(vSupps, i), Abc_ObjId(pObj) );
+    }
+    Abc_NtkForEachNode( pNtk, pObj, i ) {
+        if ( Abc_ObjLevel(pObj) <= Level )
+            continue;
+        Vec_IntClear( vTemp[0] );
+        Abc_ObjForEachFanin( pObj, pFanin, k ) {
+            int iSuppId = Vec_IntEntry( vSuppIds, Abc_ObjId(pFanin) );
+            if ( iSuppId == -1 )
+                break;
+            Vec_IntTwoMerge2( Vec_WecEntry(vSupps, iSuppId), vTemp[0], vTemp[1] );
+            ABC_SWAP( Vec_Int_t *, vTemp[0], vTemp[1] );
+        }
+        if ( k < Abc_ObjFaninNum(pObj) || Vec_IntSize(vTemp[0]) > nSuppMax ) {
+            Count++;
+            continue;
+        }
+        Vec_IntWriteEntry( vSuppIds, Abc_ObjId(pObj), Vec_WecSize(vSupps) );
+        Vec_IntAppend( Vec_WecPushLevel(vSupps), vTemp[0] );
+    }
+    // remove those supported nodes that are in the TFI cones of others
+    Abc_NtkIncrementTravId( pNtk );
+    Abc_NtkForEachNode( pNtk, pObj, i )
+        if ( Abc_ObjLevel(pObj) > Level && Vec_IntEntry(vSuppIds, i) >= 0 && !Abc_NodeIsTravIdCurrent(pObj) ) {
+            Abc_ObjDfsMark_rec(pObj);
+            Abc_NodeSetTravIdPrevious(pObj);
+        }
+    // create the result
+    vResSupps = Vec_WecAlloc( 100 );
+    Abc_NtkForEachNode( pNtk, pObj, i )
+        if ( Abc_ObjLevel(pObj) > Level && Vec_IntEntry(vSuppIds, i) >= 0 && !Abc_NodeIsTravIdCurrent(pObj) ) {
+            Vec_Int_t * vSupp = Vec_WecEntry( vSupps, Vec_IntEntry(vSuppIds, i) );
+            if ( Vec_IntSize(vSupp) < 4 )
+                continue;
+            Vec_Int_t * vThis = Vec_WecPushLevel( vResSupps );
+            Vec_IntGrow( vThis, Vec_IntSize(vSupp) + 1 );
+            Vec_IntAppend( vThis, vSupp );
+            //Vec_IntPush( vThis, Abc_ObjId(pObj) );
+        }
+    //printf( "Inputs = %d. Nodes with %d-support = %d. Nodes with larger support = %d. Selected outputs = %d.\n", 
+    //    Vec_IntSize(vBelow), nSuppMax, Vec_WecSize(vSupps), Count, Vec_WecSize(vResSupps) );
+    Vec_WecFree( vSupps );
+    Vec_IntFree( vSuppIds );
+    Vec_IntFree( vBelow );
+    Vec_IntFree( vTemp[0] );
+    Vec_IntFree( vTemp[1] );
+    return vResSupps;
+}
+// removes all supports that overlap with this one
+void Abc_NtKSelectRemove( Vec_Wec_t * vSupps, Vec_Int_t * vOne )
+{
+    Vec_Int_t * vLevel; int i;
+    Vec_WecForEachLevel( vSupps, vLevel, i ) 
+        if ( Vec_IntTwoCountCommon(vLevel, vOne) > 0 )
+            Vec_IntClear( vLevel );
+    Vec_WecRemoveEmpty( vSupps );
+}
+// removes all supports that overlap with the TFI/TFO cones of this one
+void Abc_NtKSelectRemove2( Vec_Wec_t * vSupps, Vec_Int_t * vOne, Abc_Ntk_t * pNtk )
+{
+    Vec_Int_t * vLevel; int i, k; Abc_Obj_t * pObj;
+    Abc_NtkForEachObjVec( vOne, pNtk, pObj, i ) {
+        Abc_NodeSetTravIdPrevious(pObj);
+        Abc_ObjDfsMark_rec( pObj );
+        Abc_NodeSetTravIdPrevious(pObj);
+        Abc_ObjDfsMark2_rec( pObj );
+    }
+    Vec_WecForEachLevel( vSupps, vLevel, i ) {
+        Abc_NtkForEachObjVec( vLevel, pNtk, pObj, k ) 
+            if ( Abc_NodeIsTravIdCurrent(pObj) )
+                break;
+        if ( k < Vec_IntSize(vLevel) )
+            Vec_IntClear( vLevel );
+    }
+    Vec_WecRemoveEmpty( vSupps );
+}
+Vec_Ptr_t * Abc_NtkDeriveWinInsAll( Vec_Wec_t * vSupps, int nSuppMax, Abc_Ntk_t * pNtk )
+{
+    Vec_Ptr_t * vRes = Vec_PtrAlloc( 100 );
+    Abc_NtkIncrementTravId( pNtk );
+    while ( Vec_WecSize(vSupps) > 0 ) {
+        int i, Item, iRand = Abc_Random(0) % Vec_WecSize(vSupps);
+        Vec_Int_t * vLevel, * vLevel2 = Vec_WecEntry( vSupps, iRand );
+        Vec_Int_t * vCopy = Vec_IntDup( vLevel2 );
+        if ( Vec_IntSize(vLevel2) == nSuppMax ) {
+            Vec_PtrPush( vRes, vCopy );
+            Abc_NtKSelectRemove2( vSupps, vCopy, pNtk );
+            continue;
+        }
+        // find another support, which maximizes the union but does not exceed nSuppMax
+        int iBest = iRand, nUnion = Vec_IntSize(vCopy);
+        Vec_WecForEachLevel( vSupps, vLevel, i ) {
+            if ( i == iRand ) continue;
+            int nCommon = Vec_IntTwoCountCommon(vLevel, vCopy);
+            int nUnionCur = Vec_IntSize(vLevel) + Vec_IntSize(vCopy) - nCommon;
+            if ( nUnionCur <= nSuppMax && nUnion < nUnionCur ) {
+                nUnion = nUnionCur;
+                iBest = i;
+            }
+        }
+        vLevel = Vec_WecEntry( vSupps, iBest );
+        Vec_IntForEachEntry( vLevel, Item, i )
+            Vec_IntPushUniqueOrder( vCopy, Item );
+        Vec_PtrPush( vRes, vCopy );
+        Abc_NtKSelectRemove2( vSupps, vCopy, pNtk );
+    }
+    return vRes;
+}
+Abc_Ntk_t * Abc_NtkDupWindow( Abc_Ntk_t * p, Vec_Int_t * vIns, Vec_Int_t * vNodes, Vec_Int_t * vOuts )
+{
+    Abc_Ntk_t * pNew = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_MAP, 0 );
+    pNew->pName = Abc_UtilStrsav( p->pName );
+    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
+    pNew->pManFunc = p->pManFunc;
+    Abc_Obj_t * pObj; int i;
+    Abc_NtkForEachObjVec( vIns, p, pObj, i )
+        pObj->pCopy = Abc_NtkCreatePi(pNew);
+    Abc_NtkForEachObjVec( vOuts, p, pObj, i )
+        Abc_NtkCreatePo( pNew );
+    Abc_NtkForEachObjVec( vNodes, p, pObj, i )
+        Abc_NtkCreateNodeMapped( pNew, pObj );
+    Abc_NtkForEachObjVec( vOuts, p, pObj, i )
+        Abc_ObjAddFanin( Abc_NtkCo(pNew, i), pObj->pCopy );
+    Abc_NtkForEachObjVec( vIns, p, pObj, i )
+        pObj->pCopy = NULL;
+    Abc_NtkForEachObjVec( vNodes, p, pObj, i )
+        pObj->pCopy = NULL;
+    Abc_NtkAddDummyPiNames( pNew );
+    Abc_NtkAddDummyPoNames( pNew );
+    return pNew;
+}
+Vec_Ptr_t * Abc_NtkDupWindows( Abc_Ntk_t * pNtk, Vec_Ptr_t * vvIns, Vec_Ptr_t * vvNodes, Vec_Ptr_t * vvOuts )
+{
+    Vec_Int_t * vNodes; int i;
+    Vec_Ptr_t * vWins = Vec_PtrAlloc( Vec_PtrSize(vvIns) );
+    assert( Vec_PtrSize(vvIns)  == Vec_PtrSize(vvNodes) );
+    assert( Vec_PtrSize(vvOuts) == Vec_PtrSize(vvNodes) );
+    Abc_NtkCleanCopy( pNtk );
+    Abc_NtkCleanMarkABC( pNtk );
+    Vec_PtrForEachEntry( Vec_Int_t *, vvNodes, vNodes, i ) {
+        Vec_Int_t * vIns  = (Vec_Int_t *)Vec_PtrEntry(vvIns, i);
+        Vec_Int_t * vOuts = (Vec_Int_t *)Vec_PtrEntry(vvOuts, i);
+        Abc_Ntk_t * pNew  = Abc_NtkDupWindow( pNtk, vIns, vNodes, vOuts );
+        Vec_PtrPush( vWins, pNew );
+    }
+    return vWins;
+}
+Vec_Ptr_t * Abc_NtkExtractPartitions( Abc_Ntk_t * pNtk, int Iter, int nSuppMax, Vec_Ptr_t ** pvIns, Vec_Ptr_t ** pvOuts, Vec_Ptr_t ** pvNodes )
+{
+    if ( Abc_NtkCiNum(pNtk) <= nSuppMax ) {
+        Vec_Ptr_t * vWins = Vec_PtrAlloc( 1 );
+        Vec_PtrPush( vWins, Abc_NtkDupDfs(pNtk) );
+        *pvIns = *pvOuts = *pvNodes = NULL;
+        return vWins;
+    }
+    int iUseRevL = Iter % 3 == 0 ? 0 : Abc_Random(0) & 1;
+    int LevelMax = iUseRevL ? Abc_NtkLevelR(pNtk) : Abc_NtkLevel(pNtk);
+    int LevelCut = Iter % 3 == 0 ? 0 : LevelMax > 8 ? 2 + (Abc_Random(0) % (LevelMax - 4)) : 0;
+    //printf( "Using %s cut level %d (out of %d)\n", iUseRevL ? "reverse": "direct", LevelCut, LevelMax );
+    Abc_NtkPermuteLevel( pNtk, LevelMax );
+    Vec_Wec_t * vStore = Vec_WecStart( LevelMax+1 );
+    Vec_Wec_t * vSupps = Abc_NtkCollectObjectsWithSuppLimit( pNtk, LevelCut, nSuppMax );
+    Vec_Ptr_t * vIns   = Abc_NtkDeriveWinInsAll( vSupps, nSuppMax, pNtk );
+    Vec_Ptr_t * vNodes = Abc_NtkDeriveWinNodesAll( pNtk, vIns, vStore );
+    Vec_Ptr_t * vOuts  = Abc_NtkDeriveWinOutsAll( pNtk, vNodes );
+    Vec_Ptr_t * vWins  = Abc_NtkDupWindows( pNtk, vIns, vNodes, vOuts );
+    Vec_WecFree( vSupps );
+    Vec_WecFree( vStore );
+    *pvIns = vIns;
+    *pvOuts = vOuts;
+    *pvNodes = vNodes;
+    return vWins;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Performs stochastic mapping.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkStochMap( int nSuppMax, int nIters, int TimeOut, int Seed, int fVerbose, char * pScript, int nProcs )
+{
+    abctime clkStart    = Abc_Clock(); int i;
+    abctime nTimeToStop = TimeOut ? Abc_Clock() + TimeOut * CLOCKS_PER_SEC : 0;
+    float aEnd, aBeg    = Abc_NtkGetMappedArea(Abc_FrameReadNtk(Abc_FrameGetGlobalFrame()));
+    assert( Abc_NtkIsMappedLogic(Abc_FrameReadNtk(Abc_FrameGetGlobalFrame())) );
+    Abc_Random(1);
+    for ( i = 0; i < 10+Seed; i++ )
+        Abc_Random(0);
+    if ( fVerbose ) {
+        printf( "Running %d iterations of the script \"%s\"", nIters, pScript );
+        if ( nProcs > 2 )
+            printf( " using %d concurrent threads.\n", nProcs-1 );
+        else
+            printf( " without concurrency.\n" );
+        fflush(stdout);
+    }
+    Vec_Ptr_t * vIns = NULL, * vOuts = NULL, * vNodes = NULL;
+    for ( i = 0; i < nIters; i++ )
+    {
+        abctime clk = Abc_Clock();
+        Abc_Ntk_t * pNtk   = Abc_NtkDupDfs(Abc_FrameReadNtk(Abc_FrameGetGlobalFrame()));
+        Vec_Ptr_t * vWins  = Abc_NtkExtractPartitions( pNtk, i, nSuppMax, &vIns, &vOuts, &vNodes );
+        Vec_Ptr_t * vOpts  = Abc_NtkStochProcess( vWins, pScript, nProcs, 0, 0 );
+        Abc_Ntk_t * pNew   = Abc_NtkInsertPartitions( pNtk, vIns, vOuts, vWins );
+        Abc_FrameReplaceCurrentNetwork( Abc_FrameGetGlobalFrame(), pNew );
+        if ( fVerbose )
+        printf( "Iteration %3d : Using %3d partitions. Reducing area from %.2f to %.2f.  ", 
+            i, Vec_PtrSize(vWins), Abc_NtkGetMappedArea(pNtk), Abc_NtkGetMappedArea(pNew) ); 
+        if ( fVerbose )
+        Abc_PrintTime( 0, "Time", Abc_Clock() - clk );
+        // cleanup
+        Abc_NtkDelete( pNtk );
+        Vec_PtrFreeFunc( vWins,  (void (*)(void *)) Abc_NtkDelete );
+        //Vec_PtrFreeFunc( vOpts, (void (*)(void *)) Abc_NtkDelete );
+        vOpts = NULL;
+        if ( vIns )   Vec_PtrFreeFunc( vIns,   (void (*)(void *)) Vec_IntFree );
+        if ( vOuts )  Vec_PtrFreeFunc( vOuts,  (void (*)(void *)) Vec_IntFree );                
+        if ( vNodes ) Vec_PtrFreeFunc( vNodes, (void (*)(void *)) Vec_IntFree );                
+        if ( nTimeToStop && Abc_Clock() > nTimeToStop )
+        {
+            printf( "Runtime limit (%d sec) is reached after %d iterations.\n", TimeOut, i );
+            break;
+        }
+    }
+    aEnd = Abc_NtkGetMappedArea(Abc_FrameReadNtk(Abc_FrameGetGlobalFrame()));
+    if ( fVerbose )
+    printf( "Cumulatively reduced area by %.2f %% after %d iterations.  ", 100.0*(aBeg - aEnd)/aBeg, nIters );
+    if ( fVerbose )
+    Abc_PrintTime( 0, "Total time", Abc_Clock() - clkStart );
+}
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/base/abci/abcPrint.c b/src/base/abci/abcPrint.c
index 636665249..35d5c1206 100644
--- a/src/base/abci/abcPrint.c
+++ b/src/base/abci/abcPrint.c
@@ -1083,7 +1083,7 @@ void Abc_NtkPrintMffc( FILE * pFile, Abc_Ntk_t * pNtk )
     int i;
     extern void Abc_NodeMffcConeSuppPrint( Abc_Obj_t * pNode );
     Abc_NtkForEachNode( pNtk, pNode, i )
-        if ( Abc_ObjFanoutNum(pNode) > 1 )
+        if ( Abc_ObjFanoutNum(pNode) > 1 || (Abc_ObjFanoutNum(pNode) == 1 && Abc_ObjIsCo(Abc_ObjFanout0(pNode))))
             Abc_NodeMffcConeSuppPrint( pNode );
 }
 
diff --git a/src/base/abci/abcRunGen.c b/src/base/abci/abcRunGen.c
index 9130fdad0..d82ba7fe4 100644
--- a/src/base/abci/abcRunGen.c
+++ b/src/base/abci/abcRunGen.c
@@ -19,7 +19,16 @@
 ***********************************************************************/
 
 #include "base/abc/abc.h"
-#include "opt/cut/cut.h"
+#include "base/main/main.h"
+#include "base/cmd/cmd.h"
+#include "misc/util/utilTruth.h"
+
+#ifdef WIN32
+#include <process.h> 
+#define unlink _unlink
+#else
+#include <unistd.h>
+#endif
 
 ABC_NAMESPACE_IMPL_START
 
@@ -42,8 +51,79 @@ ABC_NAMESPACE_IMPL_START
   SeeAlso     []
 
 ***********************************************************************/
-void Acb_NtkRunGen( char * pFileNames[2], int fVerbose )
+int Abc_NtkRunGenOne( Abc_Ntk_t * p, char * pScript )
+{    
+    Abc_FrameReplaceCurrentNetwork( Abc_FrameGetGlobalFrame(), p );
+    if ( Abc_FrameIsBatchMode() )
+    {
+        if ( Cmd_CommandExecute(Abc_FrameGetGlobalFrame(), pScript) )
+        {
+            Abc_Print( 1, "Something did not work out with the command \"%s\".\n", pScript );
+            return 0;
+        }
+    }
+    else
+    {
+        Abc_FrameSetBatchMode( 1 );
+        if ( Cmd_CommandExecute(Abc_FrameGetGlobalFrame(), pScript) )
+        {
+            Abc_Print( 1, "Something did not work out with the command \"%s\".\n", pScript );
+            return 0;
+        }
+        Abc_FrameSetBatchMode( 0 );
+    }
+    Abc_Ntk_t * pTemp = Abc_FrameReadNtk(Abc_FrameGetGlobalFrame());
+    return Abc_NtkNodeNum(pTemp);
+}
+void Acb_NtkRunGen( int nInputs, int nMints, int nFuncs, int Seed, int fVerbose, char * pScript )
 {
+    abctime clkStart = Abc_Clock();
+    Vec_Int_t * vNodes = Vec_IntAlloc( 1000 );
+    int i, k, nNodes, nWords = Abc_TtWordNum(nInputs);
+    word * pFun = ABC_ALLOC( word, nWords );
+    Abc_Ntk_t * pNtkNew; char * pTtStr, * pSop;
+    Abc_Random(1);
+    for ( i = 0; i < 10+Seed; i++ )
+        Abc_Random(0);
+    printf( "Synthesizing %d random %d-variable functions with %d positive minterms using script \"%s\".\n", nFuncs, nInputs, nMints, pScript );
+    for ( i = 0; i < nFuncs; i++ )
+    {
+        if ( nMints == 0 )
+            for ( k = 0; k < nWords; k++ )
+                pFun[k] = Abc_RandomW(0);
+        else {
+            Abc_TtClear( pFun, nWords );
+            for ( k = 0; k < nMints; k++ ) {
+                int iMint = 0;
+                do iMint = Abc_Random(0) % (1 << nInputs);
+                while ( Abc_TtGetBit(pFun, iMint) );
+                Abc_TtSetBit( pFun, iMint );
+            }
+        }
+        pTtStr = ABC_CALLOC( char, nInputs > 2 ? (1 << (nInputs-2)) + 1 : 2 );
+        Extra_PrintHexadecimalString( pTtStr, (unsigned *)pFun, nInputs );
+        pSop = Abc_SopFromTruthHex( pTtStr );
+        pNtkNew = Abc_NtkCreateWithNode( pSop );
+        nNodes = Abc_NtkRunGenOne( pNtkNew, pScript );
+        if ( nNodes >= Vec_IntSize(vNodes) )
+          Vec_IntSetEntry( vNodes, nNodes, 0 );
+        Vec_IntAddToEntry( vNodes, nNodes, 1 );
+
+        if ( fVerbose ) {
+          printf( "Iteration %3d : ", i );
+          printf( "Random function has %d positive minterms ", nMints );
+          printf( "and maps into %d nodes.\n", nNodes );
+          if ( fVerbose )
+              printf( "Truth table : %s\n", pTtStr );
+        }
+        ABC_FREE( pTtStr );
+        ABC_FREE( pSop );
+    }
+    Vec_IntForEachEntry( vNodes, i, k )
+      if ( i )
+          printf( "Nodes %3d :   Functions %3d   Ratio %5.2f %%\n", k, i, 100.0*i/nFuncs );
+    ABC_FREE( pFun );
+    Abc_PrintTime( 0, "Total time", Abc_Clock() - clkStart );  
 }
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/base/abci/abcVerify.c b/src/base/abci/abcVerify.c
index f3e86746c..3ae3e1846 100644
--- a/src/base/abci/abcVerify.c
+++ b/src/base/abci/abcVerify.c
@@ -324,6 +324,12 @@ void Abc_NtkCecFraigPart( Abc_Ntk_t * pNtk1, Abc_Ntk_t * pNtk2, int nSeconds, in
         }
         else if ( RetValue == 0 )
         {
+            if(!pMiterPart)
+            {
+                printf("ERROR: Failed to create cone for output %d.\n", i);
+                Status = -1; 
+                break; 
+            }
             int * pSimInfo = Abc_NtkVerifySimulatePattern( pMiterPart, pMiterPart->pModel );
             if ( pSimInfo[0] != 1 )
                 printf( "ERROR in Abc_NtkMiterProve(): Generated counter-example is invalid.\n" );
diff --git a/src/base/io/io.c b/src/base/io/io.c
index 3327a9dfd..383acb159 100644
--- a/src/base/io/io.c
+++ b/src/base/io/io.c
@@ -60,6 +60,7 @@ static int IoCommandReadGig     ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandReadJson    ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandReadSF      ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandReadRom     ( Abc_Frame_t * pAbc, int argc, char **argv );
+static int IoCommandReadMM      ( Abc_Frame_t * pAbc, int argc, char **argv );
 
 static int IoCommandWrite       ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteHie    ( Abc_Frame_t * pAbc, int argc, char **argv );
@@ -79,6 +80,7 @@ static int IoCommandWriteCex    ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteDot    ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteEqn    ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteGml    ( Abc_Frame_t * pAbc, int argc, char **argv );
+static int IoCommandWriteHMetis ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteList   ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWritePla    ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteVerilog( Abc_Frame_t * pAbc, int argc, char **argv );
@@ -89,6 +91,7 @@ static int IoCommandWriteStatus ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteSmv    ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteJson   ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int IoCommandWriteResub  ( Abc_Frame_t * pAbc, int argc, char **argv );
+static int IoCommandWriteMM     ( Abc_Frame_t * pAbc, int argc, char **argv );
 
 extern void Abc_FrameCopyLTLDataBase( Abc_Frame_t *pAbc, Abc_Ntk_t * pNtk );
 
@@ -135,6 +138,7 @@ void Io_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "I/O", "read_json",     IoCommandReadJson,     0 );
     Cmd_CommandAdd( pAbc, "I/O", "read_sf",       IoCommandReadSF,       0 );
     Cmd_CommandAdd( pAbc, "I/O", "read_rom",      IoCommandReadRom,      1 );
+    Cmd_CommandAdd( pAbc, "I/O", "read_mm",       IoCommandReadMM,       1 );
 
     Cmd_CommandAdd( pAbc, "I/O", "write",         IoCommandWrite,        0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_hie",     IoCommandWriteHie,     0 );
@@ -155,16 +159,19 @@ void Io_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "I/O", "write_edgelist",IoCommandWriteEdgelist,    0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_gml",     IoCommandWriteGml,     0 );
 //    Cmd_CommandAdd( pAbc, "I/O", "write_list",    IoCommandWriteList,    0 );
+    Cmd_CommandAdd( pAbc, "I/O", "write_hmetis",  IoCommandWriteHMetis,     0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_pla",     IoCommandWritePla,     0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_verilog", IoCommandWriteVerilog, 0 );
 //    Cmd_CommandAdd( pAbc, "I/O", "write_verlib",  IoCommandWriteVerLib,  0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_sorter_cnf", IoCommandWriteSortCnf,  0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_truth",   IoCommandWriteTruth,   0 );
+    Cmd_CommandAdd( pAbc, "I/O", "&write_truth",  IoCommandWriteTruths,  0 );
     Cmd_CommandAdd( pAbc, "I/O", "&write_truths", IoCommandWriteTruths,  0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_status",  IoCommandWriteStatus,  0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_smv",     IoCommandWriteSmv,     0 );
     Cmd_CommandAdd( pAbc, "I/O", "write_json",    IoCommandWriteJson,    0 );
     Cmd_CommandAdd( pAbc, "I/O", "&write_resub",  IoCommandWriteResub,   0 );
+    Cmd_CommandAdd( pAbc, "I/O", "write_mm",      IoCommandWriteMM,      0 );
 }
 
 /**Function*************************************************************
@@ -1996,6 +2003,51 @@ usage:
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int IoCommandReadMM( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    extern Abc_Ntk_t * Abc_NtkReadFromFile( char * pFileName );
+    Abc_Ntk_t * pNtk; char * pFileName; int c;
+
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "h" ) ) != EOF )
+    {
+        switch ( c )
+        {
+            case 'h':
+                goto usage;
+            default:
+                goto usage;
+        }
+    }
+    if ( argc != globalUtilOptind + 1 )
+        goto usage;
+    pFileName = argv[globalUtilOptind];
+    pNtk = Abc_NtkReadFromFile( pFileName );
+    if ( pNtk == NULL )
+        return 0;
+    Abc_FrameReplaceCurrentNetwork( pAbc, pNtk );
+    Abc_FrameClearVerifStatus( pAbc );
+    return 0;
+
+usage:
+    fprintf( pAbc->Err, "usage: read_mm [-h] <file>\n" );
+    fprintf( pAbc->Err, "\t         reads mapped network from file\n" );
+    fprintf( pAbc->Err, "\t-h     : prints the command summary\n" );
+    fprintf( pAbc->Err, "\tfile   : the name of a file to read\n" );
+    return 1;
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -3398,6 +3450,78 @@ usage:
 }
 
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int IoCommandWriteHMetis( Abc_Frame_t * pAbc, int argc, char **argv )
+{
+    char * pFileName;
+    int fVerbose;
+    int fSkipPo;
+    int fWeightEdges;
+    int c;
+
+    fSkipPo       = 1;
+    fWeightEdges  = 0;
+    fVerbose      = 0;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "swvh" ) ) != EOF )
+    {
+        switch ( c )
+        {
+            case 's':
+                fSkipPo ^= 1;
+                break;
+            case 'w':
+                fWeightEdges ^= 1;
+                break;
+            case 'v':
+                fVerbose ^= 1;
+                break;
+            case 'h':
+                goto usage;
+            default:
+                goto usage;
+        }
+    }
+    if ( pAbc->pNtkCur == NULL )
+    {
+        fprintf( pAbc->Out, "Empty network.\n" );
+        return 0;
+    }
+    if ( argc != globalUtilOptind + 1 )
+        goto usage;
+    // get the output file name
+    pFileName = argv[globalUtilOptind];
+    // call the corresponding file writer
+    if ( !Abc_NtkIsStrash(pAbc->pNtkCur) )
+    {
+        fprintf( stdout, "Writing this format is only possible for structurally hashed AIGs.\n" );
+        return 1;
+    }
+    Io_WriteHMetis( pAbc->pNtkCur, pFileName, fSkipPo, fWeightEdges, fVerbose );
+    return 0;
+
+usage:
+    fprintf( pAbc->Err, "usage: write_hmetis <file>\n" );
+    fprintf( pAbc->Err, "\t         writes the network in the hMetis format (https://karypis.github.io/glaros/files/sw/hmetis/manual.pdf)\n" );
+    fprintf( pAbc->Err, "\t-s     : skip PO as sink explictly [default = %s]\n", fSkipPo? "yes" : "no" );
+    fprintf( pAbc->Err, "\t-w     : simulate weight on hyperedges [default = %s]\n", fWeightEdges? "yes" : "no" );
+    fprintf( pAbc->Err, "\t-v     : toggle printing verbose information [default = %s]\n", fVerbose? "yes" : "no" );
+    fprintf( pAbc->Err, "\t-h     : print the help massage\n" );
+    fprintf( pAbc->Err, "\tfile   : the name of the file to write\n" );
+    return 1;
+}
+
+
 
 /**Function*************************************************************
 
@@ -3934,7 +4058,7 @@ int IoCommandWriteTruths( Abc_Frame_t * pAbc, int argc, char **argv )
     return 0;
 
 usage:
-    fprintf( pAbc->Err, "usage: &write_truths [-rxbh] <file>\n" );
+    fprintf( pAbc->Err, "usage: &write_truth [-rxbh] <file>\n" );
     fprintf( pAbc->Err, "\t         writes truth tables of each PO of GIA manager into a file\n" );
     fprintf( pAbc->Err, "\t-r     : toggle reversing bits in the truth table [default = %s]\n", fReverse? "yes":"no" );
     fprintf( pAbc->Err, "\t-x     : toggle writing in the hex notation [default = %s]\n", fHex? "yes":"no" );
@@ -4142,6 +4266,57 @@ usage:
     return 1;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int IoCommandWriteMM( Abc_Frame_t * pAbc, int argc, char **argv )
+{
+    extern int Abc_NtkWriteToFile( char * pFileName, Abc_Ntk_t * pNtk );
+    Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc);
+    char * pFileName = NULL; int c;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "h" ) ) != EOF )
+    {
+        switch ( c )
+        {
+            case 'h':
+                goto usage;
+            default:
+                goto usage;
+        }
+    }
+    if ( argc != globalUtilOptind + 1 )
+        goto usage;
+    pFileName = argv[globalUtilOptind];
+    if ( pNtk == NULL )
+    {
+        Abc_Print( -1, "IoCommandWriteMM(): There is no current network.\n" );
+        return 1;
+    }
+    if ( !Abc_NtkIsMappedLogic(pNtk) )
+    {
+        Abc_Print( -1, "IoCommandWriteMM(): The current network is not mapped.\n" );
+        return 1;
+    }
+    Abc_NtkWriteToFile( pFileName, pNtk );
+    return 0;
+
+usage:
+    fprintf( pAbc->Err, "usage: write_mm [-h] <file>\n" );
+    fprintf( pAbc->Err, "\t         write mapped network into a file\n" );
+    fprintf( pAbc->Err, "\t-h     : print the help message\n" );
+    fprintf( pAbc->Err, "\tfile   : the name of the file to write\n" );
+    return 1;
+}
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/base/io/ioAbc.h b/src/base/io/ioAbc.h
index cf30196f2..77c7dc292 100644
--- a/src/base/io/ioAbc.h
+++ b/src/base/io/ioAbc.h
@@ -57,7 +57,8 @@ typedef enum {
     IO_FILE_DOT,      
     IO_FILE_EDIF,      
     IO_FILE_EQN,      
-    IO_FILE_GML,      
+    IO_FILE_GML,
+    IO_FILE_HMETIS,      
     IO_FILE_JSON,      
     IO_FILE_LIST,      
     IO_FILE_PLA,      
@@ -129,6 +130,8 @@ extern void               Io_WriteEqn( Abc_Ntk_t * pNtk, char * pFileName );
 extern void               Io_WriteEdgelist( Abc_Ntk_t * pNtk, char * pFileName, int fWriteLatches, int fBb2Wb, int fSeq , int fName);
 /*=== abcWriteGml.c ===========================================================*/
 extern void               Io_WriteGml( Abc_Ntk_t * pNtk, char * pFileName );
+/*=== abcWriteHMetis.c ===========================================================*/
+extern void               Io_WriteHMetis( Abc_Ntk_t * pNtk, char * pFileName, int fSkipPo, int fWeightEdges, int fVerbose );
 /*=== abcWriteList.c ==========================================================*/
 extern void               Io_WriteList( Abc_Ntk_t * pNtk, char * pFileName, int fUseHost );
 /*=== abcWritePla.c ===========================================================*/
diff --git a/src/base/io/ioReadAiger.c b/src/base/io/ioReadAiger.c
index 9cf41413d..200247bbd 100644
--- a/src/base/io/ioReadAiger.c
+++ b/src/base/io/ioReadAiger.c
@@ -433,14 +433,14 @@ Abc_Ntk_t * Io_ReadAiger( char * pFileName, int fCheck )
                 else 
                 {
                     assert( Init == Abc_Var2Lit(1+Abc_NtkPiNum(pNtkNew)+i, 0) ); 
-                    // unitialized value of the latch is the latch literal according to http://fmv.jku.at/hwmcc11/beyond1.pdf
+                    // uninitialized value of the latch is the latch literal according to http://fmv.jku.at/hwmcc11/beyond1.pdf
                     Abc_LatchSetInitDc( Abc_NtkBox(pNtkNew, i) );
                 }
                 while ( *pCur != ' ' && *pCur != '\n' ) pCur++;
             }
             if ( *pCur != '\n' )
             {
-                fprintf( stdout, "The initial value of latch number %d is not recongnized.\n", i );
+                fprintf( stdout, "The initial value of latch number %d is not recognized.\n", i );
                 return NULL;
             }
             pCur++;
diff --git a/src/base/io/ioWriteAiger.c b/src/base/io/ioWriteAiger.c
index 0a68c7eec..cad335d4f 100644
--- a/src/base/io/ioWriteAiger.c
+++ b/src/base/io/ioWriteAiger.c
@@ -680,7 +680,7 @@ void Io_WriteAiger( Abc_Ntk_t * pNtk, char * pFileName, int fWriteSymbols, int f
     b.f = fopen( pFileName, "wb" ); 
     if ( b.f == NULL )
     {
-        fprintf( stdout, "Ioa_WriteBlif(): Cannot open the output file \"%s\".\n", pFileName );
+        fprintf( stdout, "Io_WriteAiger(): Cannot open the output file \"%s\".\n", pFileName );
         ABC_FREE(b.buf);
         return;
     }
@@ -688,7 +688,7 @@ void Io_WriteAiger( Abc_Ntk_t * pNtk, char * pFileName, int fWriteSymbols, int f
         b.b = BZ2_bzWriteOpen( &bzError, b.f, 9, 0, 0 );
         if ( bzError != BZ_OK ) {
             BZ2_bzWriteClose( &bzError, b.b, 0, NULL, NULL );
-            fprintf( stdout, "Ioa_WriteBlif(): Cannot start compressed stream.\n" );
+            fprintf( stdout, "Io_WriteAiger(): Cannot start compressed stream.\n" );
             fclose( b.f );
             ABC_FREE(b.buf);
             return;
diff --git a/src/base/io/ioWriteDot.c b/src/base/io/ioWriteDot.c
index dc1f97698..2c067bd11 100644
--- a/src/base/io/ioWriteDot.c
+++ b/src/base/io/ioWriteDot.c
@@ -317,7 +317,7 @@ void Io_WriteDotNtk( Abc_Ntk_t * pNtk, Vec_Ptr_t * vNodes, Vec_Ptr_t * vNodesSho
             if ( AigNodeId > 0 )
                 fprintf( pFile, "  Node%d [label = \"%s%d\\n%s\"", pNode->Id, Abc_LitIsCompl(AigNodeId) ? "-":"+", Abc_Lit2Var(AigNodeId), pSopString );
             else 
-                fprintf( pFile, "  Node%d [label = \"%d\\n%s\"", pNode->Id, pNode->Id, pSopString );
+                fprintf( pFile, "  Node%d [label = \"%d\\n%s\"", pNode->Id, pNode->Id+1, pSopString );
 //            fprintf( pFile, "  Node%d [label = \"%d\\n%s\"", pNode->Id, 
 //                SuppSize, 
 //                pSopString );
diff --git a/src/base/io/ioWriteHMetis.c b/src/base/io/ioWriteHMetis.c
new file mode 100644
index 000000000..90527a0dc
--- /dev/null
+++ b/src/base/io/ioWriteHMetis.c
@@ -0,0 +1,112 @@
+/**CFile****************************************************************
+
+  FileName    [ioWriteHMetis.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Command processing package.]
+
+  Synopsis    [Procedures to write hMetis format developed by
+  George Karypis and Vipin Kumar from the University of Minnesota 
+  (https://karypis.github.io/glaros/files/sw/hmetis/manual.pdf)]
+
+  Author      [Jingren Wang]
+
+  Affiliation []
+
+  Date        [Ver. 1.0. Started - December 16, 2006.]
+
+  Revision    []
+
+***********************************************************************/
+#include "ioAbc.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void Io_WriteHMetis( Abc_Ntk_t *pNtk, char *pFileName, int fSkipPo, int fWeightEdges, int fVerbose )
+{
+    Abc_Obj_t *pObj;
+    Abc_Obj_t *pFanout;
+    int i, j;
+    Vec_Int_t *vHyperEdgeEachWrite;
+    int iEntry;
+    int nHyperNodesNum = 0;
+    // check that the network is valid
+    assert( Abc_NtkIsStrash( pNtk ) && Abc_NtkIsComb( pNtk ) );
+
+    FILE *pFHMetis = fopen( pFileName, "wb" );
+    Vec_Ptr_t *vHyperEdges = Vec_PtrAlloc( 1000 );
+    if ( pFHMetis == NULL )
+    {
+        fprintf( stdout, "Io_WriteHMetis(): Cannot open the output file \"%s\".\n", pFileName );
+        fclose( pFHMetis );
+        return;
+    }
+
+    // show pi/po/and number
+    if ( fVerbose )
+    {
+        Abc_Print( 1, "Writing hMetis file \"%s\" with %d nodes (%d pi, %d po, %d and nodes).\n", pFileName, Abc_NtkObjNum( pNtk ), Abc_NtkPiNum( pNtk ), Abc_NtkPoNum( pNtk ), Abc_NtkNodeNum( pNtk ) );
+    }
+
+    Abc_NtkForEachObj( pNtk, pObj, i )
+    {
+        Vec_Int_t *vHyperEdgeEach = Vec_IntAlloc( 20 );
+        // push the node itself, which is a source node
+        Vec_IntPush( vHyperEdgeEach, Abc_ObjId( pObj ) );
+        // iterate through all the fanouts(sink) of the node
+        if ( !Abc_ObjIsCo( pObj ) )
+        {
+            Abc_ObjForEachFanout( pObj, pFanout, j )
+            {
+                Vec_IntPush( vHyperEdgeEach, Abc_ObjId( pFanout ) );
+            }
+        } else
+        {
+            if ( fSkipPo )
+            {
+                continue;
+            }
+            Vec_IntPush( vHyperEdgeEach, Abc_ObjId( Abc_ObjFanin0( pObj ) ) );
+        }
+        Vec_PtrPush( vHyperEdges, vHyperEdgeEach );
+    }
+    
+    nHyperNodesNum = Abc_NtkObjNum( pNtk );
+
+    // write the number of hyperedges and the number of vertices
+    if ( fWeightEdges )
+    {
+        fprintf( pFHMetis, "%d %d 1\n", Vec_PtrSize( vHyperEdges ), nHyperNodesNum );
+    } else
+    {
+        fprintf( pFHMetis, "%d %d\n", Vec_PtrSize( vHyperEdges ), nHyperNodesNum );
+    }
+    // write the hyperedges
+    Vec_PtrForEachEntry( Vec_Int_t *, vHyperEdges, vHyperEdgeEachWrite, i )
+    {
+        if ( fWeightEdges )
+        {
+            fprintf( pFHMetis, "%d ", Vec_IntSize( vHyperEdgeEachWrite ) );
+        }
+
+        Vec_IntForEachEntry( vHyperEdgeEachWrite, iEntry, j )
+        {
+            if ( j == Vec_IntSize( vHyperEdgeEachWrite ) - 1 )
+            {
+                fprintf( pFHMetis, "%d", iEntry );
+            } else
+            {
+                fprintf( pFHMetis, "%d ", iEntry );
+            }
+        }
+        fprintf( pFHMetis, "\n" );
+    }
+    // comments should be started with "%" in hMetis format
+    fprintf( pFHMetis, "%%This file was written by ABC on %s\n", Extra_TimeStamp() );
+    fprintf( pFHMetis, "%%For information about hMetis format, refer to %s\n", "https://karypis.github.io/glaros/files/sw/hmetis/manual.pdf" );
+    Vec_PtrFreeFree( vHyperEdges );
+    fclose( pFHMetis );
+}
+
+ABC_NAMESPACE_IMPL_END
\ No newline at end of file
diff --git a/src/base/io/module.make b/src/base/io/module.make
index d80642134..19f9fa2d2 100644
--- a/src/base/io/module.make
+++ b/src/base/io/module.make
@@ -26,6 +26,7 @@ SRC +=  src/base/io/io.c \
     src/base/io/ioWriteEqn.c \
     src/base/io/ioWriteEdgelist.c \
     src/base/io/ioWriteGml.c \
+    src/base/io/ioWriteHMetis.c \
     src/base/io/ioWriteList.c \
     src/base/io/ioWritePla.c \
     src/base/io/ioWriteVerilog.c \
diff --git a/src/base/main/abcapis.h b/src/base/main/abcapis.h
index d723e3e6f..1601cb301 100644
--- a/src/base/main/abcapis.h
+++ b/src/base/main/abcapis.h
@@ -81,6 +81,8 @@ extern ABC_DLL void   Abc_FrameGiaInputMiniLut( Abc_Frame_t * pAbc, void * pMini
 extern ABC_DLL void   Abc_FrameGiaInputMiniLut2( Abc_Frame_t * pAbc, void * pMiniLut );
 extern ABC_DLL void * Abc_FrameGiaOutputMiniLut( Abc_Frame_t * pAbc );
 extern ABC_DLL char * Abc_FrameGiaOutputMiniLutAttr( Abc_Frame_t * pAbc, void * pMiniLut );
+extern ABC_DLL int *  Abc_FrameGiaOutputMiniLutObj( Abc_Frame_t * pAbc );
+extern ABC_DLL void   Abc_FrameSetObjDelays( Abc_Frame_t * pAbc, int * pDelays, int nDelays );
 extern ABC_DLL int *  Abc_FrameReadMiniLutSwitching( Abc_Frame_t * pAbc );
 extern ABC_DLL int *  Abc_FrameReadMiniLutSwitching2( Abc_Frame_t * pAbc, int nRandPiFactor );
 extern ABC_DLL int *  Abc_FrameReadMiniLutSwitchingPo( Abc_Frame_t * pAbc );
diff --git a/src/base/main/mainInt.h b/src/base/main/mainInt.h
index 5325adfe6..2d099577a 100644
--- a/src/base/main/mainInt.h
+++ b/src/base/main/mainInt.h
@@ -158,6 +158,8 @@ struct Abc_Frame_t_
     Gia_Man_t *     pGiaMiniLut; 
     Vec_Int_t *     vCopyMiniAig;
     Vec_Int_t *     vCopyMiniLut;
+    Vec_Int_t *     vMiniLutObjs;
+    Vec_Int_t *     vObjDelays;
     int *           pArray;
     int *           pBoxes;
     void *          pNdr;
diff --git a/src/base/wlc/wlcBlast.c b/src/base/wlc/wlcBlast.c
index 271b52d99..1b066ef4c 100644
--- a/src/base/wlc/wlcBlast.c
+++ b/src/base/wlc/wlcBlast.c
@@ -1513,9 +1513,12 @@ Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p, Wlc_BstPar_t * pParIn )
                 nRange2 = 0;
 
             // create new box
-            if ( vTables == NULL )
+            if ( vTables == NULL ) {
                 Tim_ManSetDelayTables( pManTime, (vTables = Vec_PtrAlloc(100)) );
+                Vec_PtrPush( vTables, NULL );
+            }
             Tim_ManCreateBox( pManTime, curPo, nRange0 + nRange1 + nRange2, curPi, nRange, Vec_PtrSize(vTables), 0 );
+            Tim_ManBoxSetCopy( pManTime, Tim_ManBoxNum(pManTime)-1, Tim_ManBoxNum(pManTime)-1 );
             curPi += nRange;
             curPo += nRange0 + nRange1 + nRange2;
 
@@ -2105,8 +2108,10 @@ Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p, Wlc_BstPar_t * pParIn )
         assert( pObj->Type == WLC_OBJ_FF );
 
         // create new box
-        if ( vTables == NULL )
+        if ( vTables == NULL ) {
             Tim_ManSetDelayTables( pManTime, (vTables = Vec_PtrAlloc(100)) );
+            Vec_PtrPush( vTables, NULL );
+        }
         Tim_ManCreateBox( pManTime, curPo, nRangeIn, curPi, nRange, Vec_PtrSize(vTables), 0 );
         curPi += nRange;
         curPo += nRangeIn;
diff --git a/src/bdd/extrab/extraLutCas.h b/src/bdd/extrab/extraLutCas.h
index 1308c2bee..38a5dcd26 100644
--- a/src/bdd/extrab/extraLutCas.h
+++ b/src/bdd/extrab/extraLutCas.h
@@ -27,6 +27,11 @@
 #define inline __inline // compatible with MS VS 6.0
 #endif
 
+#ifdef _MSC_VER
+#  include <intrin.h>
+#  define __builtin_popcount __popcnt
+#endif
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -107,6 +112,159 @@ Vec_Ptr_t * Abc_LutCasCollapse( Mini_Aig_t * p, DdManager * dd, int nBddLimit, i
     return vFuncs;
 }
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Abc_LutBddScan( DdManager * dd, DdNode * bFunc, int nVars )
+{
+    Vec_Ptr_t * vRes = Vec_PtrAlloc( 1 << nVars );
+    Vec_Ptr_t * vRes2 = Vec_PtrAlloc( 1 << nVars );
+    Vec_PtrPush( vRes, bFunc );
+    int v, Level = Cudd_ReadPerm( dd, Cudd_NodeReadIndex(bFunc) );
+    for ( v = 0; v < dd->size; v++ )
+        printf( "%2d : perm = %d  invperm = %d\n", v, dd->perm[v], dd->invperm[v] );
+    for ( v = 0; v < nVars; v++ )
+    {
+        int i, LevelCur = Level + v;
+        Vec_PtrClear( vRes2 );
+        DdNode * bTemp;
+        Vec_PtrForEachEntry( DdNode *, vRes, bTemp, i )  {
+            int LevelTemp = Cudd_ReadPerm( dd, Cudd_NodeReadIndex(bTemp) );
+            if ( LevelTemp == LevelCur ) {
+                Vec_PtrPush( vRes2, Cudd_NotCond(Cudd_E(bTemp), Cudd_IsComplement(bTemp)) );
+                Vec_PtrPush( vRes2, Cudd_NotCond(Cudd_T(bTemp), Cudd_IsComplement(bTemp)) );
+            } 
+            else if ( LevelTemp > LevelCur ) {
+                Vec_PtrPush( vRes2, bTemp );
+                Vec_PtrPush( vRes2, bTemp );
+            }
+            else assert( 0 );
+        }
+        ABC_SWAP( Vec_Ptr_t *, vRes, vRes2 );
+        //Vec_PtrForEachEntry( DdNode *, vRes, bTemp, i )
+        //    printf( "%p ", bTemp );
+        //printf( "\n" );
+    }
+    Vec_PtrFree( vRes2 );
+    assert( Vec_PtrSize(vRes) == (1 << nVars) );
+    return vRes;
+}
+char * Abc_LutBddToTruth( Vec_Ptr_t * vFuncs )
+{
+    assert( Vec_PtrSize(vFuncs) <= 256 );
+    char * pRes = ABC_CALLOC( char, Vec_PtrSize(vFuncs)+1 );
+    void * pTemp, * pStore[256] = {Vec_PtrEntry(vFuncs, 0)}; 
+    int i, k, nStore = 1; pRes[0] = 'a';
+    Vec_PtrForEachEntryStart( void *, vFuncs, pTemp, i, 1 ) {
+        for ( k = 0; k < nStore; k++ )
+            if ( pStore[k] == pTemp )
+                break;
+        if ( k == nStore )
+            pStore[nStore++] = pTemp;
+        pRes[i] = 'a' + (char)k;
+    }
+    return pRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Abc_NtkPrecomputeData()
+{
+    char * pRes = ABC_CALLOC( char, 1 << 16 );
+    int i, k, b;
+    for ( i = 0; i < 256; i++ ) {
+        int nOnes = __builtin_popcount(i);
+        char * pTemp = pRes + 256*i;
+        for ( k = 0; k < 256; k++ ) {
+            int iMask = 0, Counts[2] = {nOnes, 0};
+            for ( b = 0; b < 8; Counts[(i >> b++)&1]++ )
+                if ( (k >> b) & 1 )
+                    iMask |= 1 << Counts[(i >> b)&1];
+            pTemp[iMask] = (char)k;
+            assert( Counts[1] == nOnes );
+        }
+    }
+    for ( i = 0; i < 16; i++, printf("\n") )
+    for ( printf("%x : ", i), k = 0; k < 16; k++ )
+        printf( "%x=%x ", k, (int)pRes[i*256+k] );    
+    return pRes;
+}
+
+int Abc_NtkDecPatCount( int iFirst, int nStep, int MyuMax, char * pDecPat, char * pPermInfo )
+{
+    int s, k, nPats = 1; 
+    char Pats[256] = { pDecPat[(int)pPermInfo[iFirst]] };
+    assert( MyuMax <= 256 );
+    for ( s = 1; s < nStep; s++ ) {
+        char Entry = pDecPat[(int)pPermInfo[iFirst+s]];
+        for ( k = 0; k < nPats; k++ )
+            if ( Pats[k] == Entry )
+                break;
+        if ( k < nPats )
+            continue;
+        if ( nPats == MyuMax )
+            return MyuMax + 1;
+        assert( nPats < 256 );    
+        Pats[nPats++] = Entry;
+    }
+    return nPats;
+}
+int Abc_NtkDecPatDecompose_rec( int Mask, int nMaskVars, int iStart, int nVars, int nDiffs, int nRails, char * pDecPat, char * pPermInfo )
+{
+    if ( nDiffs == 0 || iStart == nVars ) 
+        return 0;
+    int v, m, nMints = 1 << nVars;
+    for ( v = iStart; v < nVars; v++ ) {
+        int MaskThis = Mask & ~(1 << v);
+        int nStep = 1 << (nMaskVars - 1);
+        int MyuMax = 0;
+        for ( m = 0; m < nMints; m += nStep ) {
+            int MyuCur = Abc_NtkDecPatCount( m, nStep, 1 << nDiffs, pDecPat, pPermInfo+256*MaskThis );
+            MyuMax = Abc_MaxInt( MyuMax, MyuCur );
+        }
+        if ( MyuMax > (1 << nDiffs) )
+            continue;
+        if ( MyuMax <= (1 << nRails) )
+            return MaskThis;
+        MaskThis = Abc_NtkDecPatDecompose_rec( MaskThis, nMaskVars-1, v+1, nVars, nDiffs-1, nRails, pDecPat, pPermInfo );
+        if ( MaskThis )
+            return MaskThis;
+    }
+    return 0;
+}
+int Abc_NtkDecPatDecompose( int nVars, int nRails, char * pDecPat, char * pPermInfo )
+{
+    int BoundSet = ~(~0 << nVars);
+    int Myu = Abc_NtkDecPatCount( 0, 1 << nVars, 256, pDecPat, pPermInfo + 256*BoundSet );
+    int Log2 = Abc_Base2Log( Myu );
+    if ( Log2 <= nRails )
+        return BoundSet;
+    return Abc_NtkDecPatDecompose_rec( BoundSet, nVars, 0, nVars, Log2 - nRails, nRails, pDecPat, pPermInfo );
+}
+
+int Abc_NtkCascadeDecompose( int nVars, int nRails, char * pDecPat, char * pPermInfo )
+{
+    return 0;
+}
+
+
 
 /**Function*************************************************************
 
@@ -159,12 +317,12 @@ void Abc_LutCasPrintDsd( DdManager * dd, DdNode * bFunc, int fVerbose )
     }
     Dsd_ManagerStop( pManDsd );
 }    
-DdNode * Abc_LutCasBuildBdds( Mini_Aig_t * p, DdManager ** pdd )
+DdNode * Abc_LutCasBuildBdds( Mini_Aig_t * p, DdManager ** pdd, int fReorder )
 {
     DdManager * dd = Cudd_Init( Mini_AigPiNum(p), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
+    if ( fReorder ) Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
     Vec_Ptr_t * vFuncs = Abc_LutCasCollapse( p, dd, 10000, 0 );
-    Cudd_AutodynDisable( dd );
+    if ( fReorder ) Cudd_AutodynDisable( dd );
     if ( vFuncs == NULL ) {
         Extra_StopManager( dd );
         return NULL;
@@ -174,15 +332,28 @@ DdNode * Abc_LutCasBuildBdds( Mini_Aig_t * p, DdManager ** pdd )
     *pdd = dd;
     return bNode;
 }
-static inline word * Abc_LutCascade( Mini_Aig_t * p, int nLutSize, int fVerbose )
+static inline word * Abc_LutCascade( Mini_Aig_t * p, int nLutSize, int nLuts, int nRails, int nIters, int fVerbose )
 {
     DdManager * dd = NULL;
-    DdNode * bFunc = Abc_LutCasBuildBdds( p, &dd );
+    DdNode * bFunc = Abc_LutCasBuildBdds( p, &dd, 0 );
     if ( bFunc == NULL ) return NULL;
+    char * pPermInfo = Abc_NtkPrecomputeData();
     Abc_LutCasPrintDsd( dd, bFunc, 1 );
+
+    Vec_Ptr_t * vTemp = Abc_LutBddScan( dd, bFunc, nLutSize );
+    char * pTruth = Abc_LutBddToTruth( vTemp );
+
+    int BoundSet = Abc_NtkDecPatDecompose( nLutSize, nRails, pTruth, pPermInfo );
+    printf( "Pattern %s : Bound set = %d\n", pTruth, BoundSet );
+
+    ABC_FREE( pTruth );
+    Vec_PtrFree( vTemp );
+
     Cudd_RecursiveDeref( dd, bFunc );
     Extra_StopManager( dd );
+    ABC_FREE( pPermInfo );
 
+    printf( "\n" );
     word * pLuts = NULL;
     return pLuts;
 }
diff --git a/src/map/if/acd/ac_decomposition.hpp b/src/map/if/acd/ac_decomposition.hpp
index c6a526e08..55097a453 100644
--- a/src/map/if/acd/ac_decomposition.hpp
+++ b/src/map/if/acd/ac_decomposition.hpp
@@ -294,6 +294,7 @@ private:
       pst->num_luts = best_multiplicity <= 2 ? 2 : best_multiplicity <= 4 ? 3
                                                  : best_multiplicity <= 8 ? 4
                                                                           : 5;
+      pst->num_edges = ( pst->num_luts - 1 ) * ( num_vars - best_free_set ) + ( pst->num_luts - 1 ) + best_free_set;
     }
 
     return true;
@@ -510,8 +511,8 @@ private:
       }
     } while ( combinations_offset_next( free_set_size, offset, pComb, pInvPerm, tt ) );
 
-    std::array<uint32_t, max_num_vars> res_perm = {0};
-    
+    std::array<uint32_t, max_num_vars> res_perm;
+
     if ( best_cost > ( 1 << ( ps.lut_size - free_set_size ) ) )
     {
       return std::make_tuple( local_best_tt, res_perm, UINT32_MAX );
@@ -543,7 +544,7 @@ private:
     }
 
     /* enumerate combinations */
-    std::array<uint32_t, max_num_vars> res_perm = {0};
+    std::array<uint32_t, max_num_vars> res_perm;
 
     do
     {
@@ -803,31 +804,43 @@ private:
         }
       }
       support_minimization_encodings = std::vector<std::array<uint32_t, 2>>( num_combs );
-      generate_support_minimization_encodings_rec<false, true>( 0, 0, 0, count );
+      generate_support_minimization_encodings_rec<false, true>( 0, 0, 0, count, best_multiplicity >> 1, true );
+      assert( count == num_combs );
+      return;
     }
-    else if ( best_multiplicity > 8 )
+
+    /* constraint the number of offset classes for a strict encoding */
+    int32_t min_set_size = 1;
+    if ( best_multiplicity <= 4 )
+      min_set_size = 2;
+    else if ( best_multiplicity <= 8 )
+      min_set_size = 4;
+    else
+      min_set_size = 8;
+    min_set_size = best_multiplicity - min_set_size;
+
+    if ( best_multiplicity > 8 )
     {
-      /* combinations are 2^(mu - 1) */
-      num_combs = 1u << ( best_multiplicity - 1 );
+      /* distinct elements in 2 indistinct bins with at least `min_set_size` elements in the indistinct bins */
+      uint32_t class_sizes[13] = { 3, 3, 15, 25, 35, 35, 255, 501, 957, 1749, 3003, 4719, 6435 };
+      num_combs = class_sizes[best_multiplicity - 3];
       support_minimization_encodings = std::vector<std::array<uint32_t, 2>>( num_combs );
-      generate_support_minimization_encodings_rec<false, false>( 0, 0, 0, count );
+      generate_support_minimization_encodings_rec<false, false>( 0, 0, 0, count, min_set_size, true );
     }
     else
     {
-      /* combinations are 2*3^(mu - 1) */
-      for ( uint32_t i = 1; i < best_multiplicity; ++i )
-      {
-        num_combs = ( num_combs << 1 ) + num_combs;
-      }
+      /* distinct elements in 3 bins, of which 2 are indistinct, and with at least `min_set_size` elements in the indistinct bins */
+      uint32_t class_sizes[13] = { 6, 3, 90, 130, 105, 35, 9330, 23436, 48708, 78474, 91377, 70785, 32175 };
+      num_combs = class_sizes[best_multiplicity - 3];
       support_minimization_encodings = std::vector<std::array<uint32_t, 2>>( num_combs );
-      generate_support_minimization_encodings_rec<true, false>( 0, 0, 0, count );
+      generate_support_minimization_encodings_rec<true, false>( 0, 0, 0, count, min_set_size, true );
     }
 
     assert( count == num_combs );
   }
 
   template<bool enable_dcset, bool equal_size_partition>
-  void generate_support_minimization_encodings_rec( uint32_t onset, uint32_t offset, uint32_t var, uint32_t& count )
+  void generate_support_minimization_encodings_rec( uint32_t onset, uint32_t offset, uint32_t var, uint32_t& count, int32_t min_set_size, bool first )
   {
     if ( var == best_multiplicity )
     {
@@ -839,6 +852,11 @@ private:
           return;
         }
       }
+      else if ( __builtin_popcount( onset ) < min_set_size || __builtin_popcount( offset ) < min_set_size )
+      {
+        /* ON-set and OFF-set must be populated with at least min_set_size elements */
+        return;
+      }
 
       support_minimization_encodings[count][0] = onset;
       support_minimization_encodings[count][1] = offset;
@@ -849,23 +867,23 @@ private:
     /* var in DCSET */
     if ( enable_dcset )
     {
-      generate_support_minimization_encodings_rec<enable_dcset, equal_size_partition>( onset, offset, var + 1, count );
+      generate_support_minimization_encodings_rec<enable_dcset, equal_size_partition>( onset, offset, var + 1, count, min_set_size, first );
     }
 
     /* move var in ONSET */
     onset |= 1 << var;
-    generate_support_minimization_encodings_rec<enable_dcset, equal_size_partition>( onset, offset, var + 1, count );
+    generate_support_minimization_encodings_rec<enable_dcset, equal_size_partition>( onset, offset, var + 1, count, min_set_size, false );
     onset &= ~( 1 << var );
 
     /* remove symmetries */
-    if ( var == 0 )
+    if ( first )
     {
       return;
     }
 
     /* move var in OFFSET */
     offset |= 1 << var;
-    generate_support_minimization_encodings_rec<enable_dcset, equal_size_partition>( onset, offset, var + 1, count );
+    generate_support_minimization_encodings_rec<enable_dcset, equal_size_partition>( onset, offset, var + 1, count, min_set_size, false );
     offset &= ~( 1 << var );
   }
 
@@ -1016,15 +1034,6 @@ private:
       uint32_t const onset = support_minimization_encodings[i][0];
       uint32_t const offset = support_minimization_encodings[i][1];
 
-      uint32_t ones_onset = __builtin_popcount( onset );
-      uint32_t ones_offset = __builtin_popcount( offset );
-
-      /* filter columns that do not distinguish pairs */
-      if ( ones_onset == 0 || ones_offset == 0 || ones_onset == best_multiplicity || ones_offset == best_multiplicity )
-      {
-        continue;
-      }
-
       /* compute function and distinguishable seed dichotomies */
       uint64_t column[2] = { 0, 0 };
       STT tt;
@@ -1503,4 +1512,4 @@ private:
 
 ABC_NAMESPACE_CXX_HEADER_END
 
-#endif // _ACD_H_
\ No newline at end of file
+#endif // _ACD_H_
diff --git a/src/map/if/acd/acdXX.hpp b/src/map/if/acd/acdXX.hpp
index 13d1bdddf..cf9bd6a27 100644
--- a/src/map/if/acd/acdXX.hpp
+++ b/src/map/if/acd/acdXX.hpp
@@ -610,7 +610,7 @@ private:
                                             : cost <= 32  ? 4
                                                           : 5;
 
-      if ( ss_vars_needed + free_set_size < 6 )
+      if ( ss_vars_needed + free_set_size < ps.lut_size )
       {
         /* look for a shared variable */
         best_multiplicity = cost;
@@ -665,7 +665,7 @@ private:
                                             : cost <= 32  ? 4
                                                           : 5;
 
-      if ( ss_vars_needed + free_set_size < 6 )
+      if ( ss_vars_needed + free_set_size < ps.lut_size )
       {
         /* look for a shared variable */
         best_multiplicity = cost;
diff --git a/src/map/if/ifCom.c b/src/map/if/ifCom.c
index dd6477d11..a2f54ae35 100644
--- a/src/map/if/ifCom.c
+++ b/src/map/if/ifCom.c
@@ -32,6 +32,8 @@ static int If_CommandReadLut ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int If_CommandPrintLut( Abc_Frame_t * pAbc, int argc, char **argv );
 static int If_CommandReadBox ( Abc_Frame_t * pAbc, int argc, char **argv );
 static int If_CommandPrintBox( Abc_Frame_t * pAbc, int argc, char **argv );
+static int If_CommandWriteBox( Abc_Frame_t * pAbc, int argc, char **argv );
+static int If_CommandPrintTim( Abc_Frame_t * pAbc, int argc, char **argv );
 
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
@@ -59,6 +61,8 @@ void If_Init( Abc_Frame_t * pAbc )
 
     Cmd_CommandAdd( pAbc, "FPGA mapping", "read_box",   If_CommandReadBox,   0 ); 
     Cmd_CommandAdd( pAbc, "FPGA mapping", "print_box",  If_CommandPrintBox,  0 ); 
+    Cmd_CommandAdd( pAbc, "FPGA mapping", "write_box",  If_CommandWriteBox,  0 ); 
+    Cmd_CommandAdd( pAbc, "FPGA mapping", "print_tim",  If_CommandPrintTim,  0 ); 
 }
 
 /**Function*************************************************************
@@ -362,6 +366,113 @@ usage:
     return 1;       /* error exit */
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Command procedure to read LUT libraries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int If_CommandWriteBox( Abc_Frame_t * pAbc, int argc, char **argv )
+{
+    FILE * pOut, * pErr;
+    Abc_Ntk_t * pNet;
+    int fVerbose;
+    int c;
+
+    pNet = Abc_FrameReadNtk(pAbc);
+    pOut = Abc_FrameReadOut(pAbc);
+    pErr = Abc_FrameReadErr(pAbc);
+
+    fVerbose = 1;
+    Extra_UtilGetoptReset();
+    while ( (c = Extra_UtilGetopt(argc, argv, "vh")) != EOF ) 
+    {
+        switch (c) 
+        {
+            case 'v':
+                fVerbose ^= 1;
+                break;
+            case 'h':
+                goto usage;
+                break;
+            default:
+                goto usage;
+        }
+    }
+
+    if ( argc != globalUtilOptind+1 )
+        goto usage;
+
+    If_LibBoxWrite( argv[globalUtilOptind], (If_LibBox_t *)Abc_FrameReadLibBox() );
+    return 0;
+
+usage:
+    fprintf( pErr, "\nusage: write_box [-vh] <file>\n");
+    fprintf( pErr, "\t          write the current box library into a file\n" );  
+    fprintf( pErr, "\t-v      : toggles enabling of verbose output [default = %s]\n", (fVerbose? "yes" : "no") );
+    fprintf( pErr, "\t-h      : print the command usage\n");
+    fprintf( pErr, "\t<file>  : the output file name\n");
+    return 1;       /* error exit */
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Command procedure to read LUT libraries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int If_CommandPrintTim( Abc_Frame_t * pAbc, int argc, char **argv )
+{
+    Gia_Man_t * pGia = Abc_FrameReadGia(pAbc);
+    int c, fVerbose = 0;
+    Extra_UtilGetoptReset();
+    while ( (c = Extra_UtilGetopt(argc, argv, "vh")) != EOF ) 
+    {
+        switch (c) 
+        {
+            case 'v':
+                fVerbose ^= 1;
+                break;
+            case 'h':
+                goto usage;
+                break;
+            default:
+                goto usage;
+        }
+    }
+    if ( pGia == NULL )
+    {
+        Abc_Print( -1, "There is no AIG in the &-space.\n" );
+        return 1;
+    }
+    if ( pGia->pManTime == NULL )
+    {
+        Abc_Print( -1, "The current AIG does not have a timing manager.\n" );
+        return 1;
+    }
+    Tim_ManPrint( (Tim_Man_t *)pGia->pManTime );
+    if ( fVerbose ) 
+        Tim_ManPrintBoxCopy( (Tim_Man_t *)pGia->pManTime );
+    return 0;
+
+usage:
+    Abc_Print( -2, "\nusage: print_tim [-vh]\n");
+    Abc_Print( -2, "\t          print the timing manager\n" );  
+    Abc_Print( -2, "\t-v      : toggles enabling of verbose output [default = %s]\n", (fVerbose? "yes" : "no") );
+    Abc_Print( -2, "\t-h      : print the command usage\n");
+    return 1;       /* error exit */
+}
 
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
diff --git a/src/map/if/ifLibBox.c b/src/map/if/ifLibBox.c
index 443dbd3f4..55a859ceb 100644
--- a/src/map/if/ifLibBox.c
+++ b/src/map/if/ifLibBox.c
@@ -345,7 +345,7 @@ void If_LibBoxPrint( FILE * pFile, If_LibBox_t * p )
     If_LibBoxForEachBox( p, pBox, i )
     {
         fprintf( pFile, "%s %d %d %d %d\n", pBox->pName, pBox->Id, !pBox->fBlack, pBox->nPis, pBox->nPos );
-        for ( j = 0; j < pBox->nPos; j++, printf("\n") )
+        for ( j = 0; j < pBox->nPos; j++, fprintf(pFile, "\n") )
             for ( k = 0; k < pBox->nPis; k++ )
                 if ( pBox->pDelays[j * pBox->nPis + k] == -ABC_INFINITY )
                     fprintf( pFile, "    - " );
@@ -364,6 +364,7 @@ void If_LibBoxWrite( char * pFileName, If_LibBox_t * p )
     }
     If_LibBoxPrint( pFile, p );
     fclose( pFile );
+    printf( "Finished writing box library into file \"%s\".\n", pFileName );
 }
 
 /**Function*************************************************************
diff --git a/src/map/mio/mio.c b/src/map/mio/mio.c
index cfe5d3e8c..a2c956356 100644
--- a/src/map/mio/mio.c
+++ b/src/map/mio/mio.c
@@ -47,7 +47,7 @@ static int Mio_CommandPrintProfile( Abc_Frame_t * pAbc, int argc, char **argv );
 
 /*
 // internal version of genlib library
-static char * pMcncGenlib[25] = {
+static char * pMcncGenlib[] = {
     "GATE inv1    1   O=!a;             PIN * INV     1 999 0.9 0.0 0.9 0.0\n",
     "GATE inv2    2   O=!a;             PIN * INV     2 999 1.0 0.0 1.0 0.0\n",
     "GATE inv3    3   O=!a;             PIN * INV     3 999 1.1 0.0 1.1 0.0\n",
@@ -68,13 +68,57 @@ static char * pMcncGenlib[25] = {
     "GATE oai22   4   O=!((a+b)*(c+d)); PIN * INV     1 999 2.0 0.0 2.0 0.0\n",
     "GATE buf     1   O=a;              PIN * NONINV  1 999 1.0 0.0 1.0 0.0\n",
     "GATE zero    0   O=CONST0;\n",
-    "GATE one     0   O=CONST1;\n"
+    "GATE one     0   O=CONST1;\n",
+    NULL
 };
 */
+
+// internal version of genlib library
+static char * pSimpleGenlib[] = {
+    "GATE zero    0   O=CONST0;\n",
+    "GATE one     0   O=CONST1;\n",
+    "GATE buf     4   O=a;              PIN * NONINV  1 999 1.0 0.0 1.0 0.0\n",
+    "GATE inv     2   O=!a;             PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    "GATE nand2   4   O=!(a*b);         PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    "GATE nand3   6   O=!(a*b*c);       PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    "GATE nor2    4   O=!(a+b);         PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    "GATE nor3    6   O=!(a+b+c);       PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    "GATE aoi21   6   O=!(a*b+c);       PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    "GATE oai21   6   O=!((a+b)*c);     PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    "GATE aoi22   8   O=!(a*b+c*d);     PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    "GATE oai22   8   O=!((a+b)*(c+d)); PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
+    NULL
+};
+
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Mio_IntallSimpleLibrary()
+{
+    extern Mio_Library_t * Mio_LibraryReadBuffer( char * pBuffer, int fExtendedFormat, st__table * tExcludeGate, int nFaninLimit, int fVerbose );
+    Mio_Library_t * pLib;  int i;
+    Vec_Str_t * vLibStr = Vec_StrAlloc( 1000 );
+    for ( i = 0; pSimpleGenlib[i]; i++ )
+        Vec_StrAppend( vLibStr, pSimpleGenlib[i] );
+    Vec_StrPush( vLibStr, '\0' );
+    pLib = Mio_LibraryReadBuffer( Vec_StrArray(vLibStr), 0, NULL, 0, 0 );
+    Mio_LibrarySetName( pLib, Abc_UtilStrsav("simple.genlib") );
+    Mio_UpdateGenlib( pLib );
+    Vec_StrFree( vLibStr );
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -292,7 +336,7 @@ int Mio_CommandReadGenlib( Abc_Frame_t * pAbc, int argc, char **argv )
     double WireDelay = 0.0;
     int fShortNames = 0;
     int nFaninLimit = 0;
-    int c, fVerbose = 1;
+    int c, fVerbose = 0;
 
     pOut = Abc_FrameReadOut(pAbc);
     pErr = Abc_FrameReadErr(pAbc);
diff --git a/src/map/mio/mio.h b/src/map/mio/mio.h
index ce6f0aa9b..499a9e6e5 100644
--- a/src/map/mio/mio.h
+++ b/src/map/mio/mio.h
@@ -109,6 +109,7 @@ extern void              Mio_UpdateGenlib( Mio_Library_t * pLib );
 extern int               Mio_UpdateGenlib2( Vec_Str_t * vStr, Vec_Str_t * vStr2, char * pFileName, int fVerbose );
 /*=== mioApi.c =============================================================*/
 extern char *            Mio_LibraryReadName       ( Mio_Library_t * pLib );
+extern char *            Mio_LibraryReadFileName   ( Mio_Library_t * pLib );
 extern int               Mio_LibraryReadGateNum    ( Mio_Library_t * pLib );
 extern Mio_Gate_t *      Mio_LibraryReadGates      ( Mio_Library_t * pLib );
 extern Mio_Gate_t **     Mio_LibraryReadGateArray  ( Mio_Library_t * pLib );
diff --git a/src/map/mio/mioApi.c b/src/map/mio/mioApi.c
index 906395187..1c3262eb0 100644
--- a/src/map/mio/mioApi.c
+++ b/src/map/mio/mioApi.c
@@ -41,6 +41,7 @@ ABC_NAMESPACE_IMPL_START
 
 ***********************************************************************/
 char *            Mio_LibraryReadName          ( Mio_Library_t * pLib )  { return pLib->pName;      }
+char *            Mio_LibraryReadFileName      ( Mio_Library_t * pLib )  { return pLib->pFileName;  }
 int               Mio_LibraryReadGateNum       ( Mio_Library_t * pLib )  { return pLib->nGates;     }
 Mio_Gate_t *      Mio_LibraryReadGates         ( Mio_Library_t * pLib )  { return pLib->pGates;     }
 Mio_Gate_t **     Mio_LibraryReadGateArray     ( Mio_Library_t * pLib )  { return pLib->ppGatesName;}
diff --git a/src/map/mio/mioInt.h b/src/map/mio/mioInt.h
index bf01f588a..1d86d1b2f 100644
--- a/src/map/mio/mioInt.h
+++ b/src/map/mio/mioInt.h
@@ -61,6 +61,7 @@ ABC_NAMESPACE_HEADER_START
 struct  Mio_LibraryStruct_t_
 {
     char *             pName;       // the name of the library
+    char *             pFileName;   // the original file name
     int                nGates;      // the number of the gates
     Mio_Gate_t **      ppGates0;    // the array of gates in the original order
     Mio_Gate_t **      ppGatesName; // the array of gates sorted by name
diff --git a/src/map/mio/mioRead.c b/src/map/mio/mioRead.c
index 79d5dc4ef..c393fc188 100644
--- a/src/map/mio/mioRead.c
+++ b/src/map/mio/mioRead.c
@@ -97,6 +97,7 @@ Mio_Library_t * Mio_LibraryRead( char * FileName, char * pBuffer, char * Exclude
     if ( tExcludeGate )
         st__free_table( tExcludeGate );
 
+    pLib->pFileName = Abc_UtilStrsav( FileName );
     return pLib;
 }
 
diff --git a/src/map/mio/mioUtils.c b/src/map/mio/mioUtils.c
index 6419339f9..e75fcd90f 100644
--- a/src/map/mio/mioUtils.c
+++ b/src/map/mio/mioUtils.c
@@ -69,6 +69,7 @@ void Mio_LibraryDelete( Mio_Library_t * pLib )
 //        Cudd_Quit( pLib->dd );
     ABC_FREE( pLib->ppGates0 );
     ABC_FREE( pLib->ppGatesName );
+    ABC_FREE( pLib->pFileName );
     ABC_FREE( pLib );
 }
 
diff --git a/src/map/scl/sclLiberty.c b/src/map/scl/sclLiberty.c
index 707a8c585..2e3838eea 100644
--- a/src/map/scl/sclLiberty.c
+++ b/src/map/scl/sclLiberty.c
@@ -25,6 +25,7 @@
 #include <fnmatch.h>
 #endif
 
+#include "misc/zlib/zlib.h"
 #include "sclLib.h"
 #include "misc/st/st.h"
 #include "map/mio/mio.h"
@@ -552,14 +553,59 @@ long Scl_LibertyFileSize( char * pFileName )
     fclose( pFile );
     return nFileSize;
 }
-char * Scl_LibertyFileContents( char * pFileName, long nContents )
+
+static char * Io_LibLoadFileGz( char * pFileName, long * pnFileSize )
 {
-    FILE * pFile = fopen( pFileName, "rb" );
-    char * pContents = ABC_ALLOC( char, nContents+1 );
-    long RetValue = 0;
-    RetValue = fread( pContents, nContents, 1, pFile );
-    fclose( pFile );
-    pContents[nContents] = 0;
+    const int READ_BLOCK_SIZE = 100000;
+    gzFile pFile;
+    char * pContents;
+    long amtRead, readBlock, nFileSize = READ_BLOCK_SIZE;
+    pFile = gzopen( pFileName, "rb" ); // if pFileName doesn't end in ".gz" then this acts as a passthrough to fopen
+    pContents = ABC_ALLOC( char, nFileSize );
+    readBlock = 0;
+    while ((amtRead = gzread(pFile, pContents + readBlock * READ_BLOCK_SIZE, READ_BLOCK_SIZE)) == READ_BLOCK_SIZE) {
+        //Abc_Print( 1,"%d: read %d bytes\n", readBlock, amtRead);
+        nFileSize += READ_BLOCK_SIZE;
+        pContents = ABC_REALLOC(char, pContents, nFileSize);
+        ++readBlock;
+    }
+    //Abc_Print( 1,"%d: read %d bytes\n", readBlock, amtRead);
+    assert( amtRead != -1 ); // indicates a zlib error
+    nFileSize -= (READ_BLOCK_SIZE - amtRead);
+    gzclose(pFile);
+    *pnFileSize = nFileSize;
+    return pContents;
+}
+
+char * Scl_LibertyFileContents( char * pFileName, long * nContents )
+{
+    char * pContents = NULL;
+    //if file ends in ".gz" then use gzopen
+    if ( !strncmp(pFileName+strlen(pFileName)-3,".gz", 3) )
+    {
+        FILE * pFile = fopen( pFileName, "rb" );
+        //char * pContents;
+        long RetValue = 0;
+        pContents = Io_LibLoadFileGz(  pFileName, nContents );
+        if(pContents == NULL) {
+            printf( "Scl_LibertyFileContents(): The input file is unavailable (absent or open).\n" );
+            return NULL;
+        }
+        else {
+            RetValue = 1;
+        }
+        fclose( pFile );
+    }
+    // original .lib file
+    else
+    {
+        FILE * pFile = fopen( pFileName, "rb" );
+        pContents = ABC_ALLOC( char, *nContents+1 );
+        long RetValue = 0;
+        RetValue = fread( pContents, *nContents, 1, pFile );
+        fclose( pFile );
+        pContents[*nContents] = 0;
+    }
     return pContents;
 }
 void Scl_LibertyStringDump( char * pFileName, Vec_Str_t * vStr )
@@ -600,7 +646,7 @@ Scl_Tree_t * Scl_LibertyStart( char * pFileName )
     memset( p, 0, sizeof(Scl_Tree_t) );
     p->clkStart  = Abc_Clock();
     p->nContents = RetValue;
-    p->pContents = Scl_LibertyFileContents( pFileName, p->nContents );
+    p->pContents = Scl_LibertyFileContents( pFileName, &p->nContents );
     // other 
     p->pFileName = Abc_UtilStrsav( pFileName );
     p->nItermAlloc = 10 + Scl_LibertyCountItems( p->pContents, p->pContents+p->nContents );
diff --git a/src/map/scl/sclSize.c b/src/map/scl/sclSize.c
index b3bc2828d..bf2a40090 100644
--- a/src/map/scl/sclSize.c
+++ b/src/map/scl/sclSize.c
@@ -200,7 +200,7 @@ void Abc_SclTimeNtkPrint( SC_Man * p, int fShowAll, int fPrintPath )
         while ( pObj && Abc_ObjIsNode(pObj) )
         {
             i++;
-            nLength = Abc_MaxInt( nLength, strlen(Abc_SclObjCell(pObj)->pName) );
+            nLength = Abc_MaxInt( nLength, Abc_SclObjCell(pObj) ? strlen(Abc_SclObjCell(pObj)->pName) : 2 /* strlen("pi") */ );
             pObj = Abc_SclFindMostCriticalFanin( p, &fRise, pObj );
         }
 
diff --git a/src/misc/bbl/bblif.h b/src/misc/bbl/bblif.h
index b48593701..af6025da3 100644
--- a/src/misc/bbl/bblif.h
+++ b/src/misc/bbl/bblif.h
@@ -237,7 +237,7 @@ extern void        Bbl_ManDumpBinaryBlif( Bbl_Man_t * p, char * pFileName );
 // (3) reading the data manager from file
 extern Bbl_Man_t * Bbl_ManReadBinaryBlif( char * pFileName );
 
-// (4) returning the mapped network after reading the data manaager from file
+// (4) returning the mapped network after reading the data manager from file
 extern char *      Bbl_ManName( Bbl_Man_t * p );
 extern int         Bbl_ObjIsInput( Bbl_Obj_t * p );
 extern int         Bbl_ObjIsOutput( Bbl_Obj_t * p );
diff --git a/src/misc/mvc/mvcUtils.c b/src/misc/mvc/mvcUtils.c
index d938169a3..5ce59daee 100644
--- a/src/misc/mvc/mvcUtils.c
+++ b/src/misc/mvc/mvcUtils.c
@@ -276,7 +276,8 @@ int Mvc_CoverSetCubeSizes( Mvc_Cover_t * pCover )
     int nBytes, nOnes;
 
     // get the number of unsigned chars in the cube's bit strings
-    nBytes = pCover->nBits / (8 * sizeof(unsigned char)) + (int)(pCover->nBits % (8 * sizeof(unsigned char)) > 0);
+//    nBytes = pCover->nBits / (8 * sizeof(unsigned char)) + (int)(pCover->nBits % (8 * sizeof(unsigned char)) > 0);
+    nBytes = sizeof(Mvc_CubeWord_t) * pCover->nWords; // big-endian issue
     // iterate through the cubes
     Mvc_CoverForEachCube( pCover, pCube )
     {
@@ -298,13 +299,14 @@ int Mvc_CoverSetCubeSizes( Mvc_Cover_t * pCover )
 
   Synopsis    [Counts the cube sizes.]
 
-  Description []
+  Description [This procedure works incorrectly on big-endian machines.]
                
   SideEffects []
 
   SeeAlso     []
 
 ***********************************************************************/
+/*
 int Mvc_CoverGetCubeSize( Mvc_Cube_t * pCube )
 {
     unsigned char * pByte, * pByteStart, * pByteStop;
@@ -322,6 +324,7 @@ int Mvc_CoverGetCubeSize( Mvc_Cube_t * pCube )
         nOnes += bit_count[*pByte];
     return nOnes;
 }
+*/
 
 /**Function*************************************************************
 
@@ -351,7 +354,8 @@ int Mvc_CoverCountCubePairDiffs( Mvc_Cover_t * pCover, unsigned char pDiffs[] )
     // allocate a temporary mask
     pMask = Mvc_CubeAlloc( pCover );
     // get the number of unsigned chars in the cube's bit strings
-    nBytes = pCover->nBits / (8 * sizeof(unsigned char)) + (int)(pCover->nBits % (8 * sizeof(unsigned char)) > 0);
+//    nBytes = pCover->nBits / (8 * sizeof(unsigned char)) + (int)(pCover->nBits % (8 * sizeof(unsigned char)) > 0);
+    nBytes = sizeof(Mvc_CubeWord_t) * pCover->nWords; // big-endian issue
     // iterate through the cubes
     nCubePairs = 0;
     Mvc_CoverForEachCube( pCover, pCube1 )
diff --git a/src/misc/nm/nmApi.c b/src/misc/nm/nmApi.c
index ab3340325..39071ce57 100644
--- a/src/misc/nm/nmApi.c
+++ b/src/misc/nm/nmApi.c
@@ -116,7 +116,7 @@ char * Nm_ManStoreIdName( Nm_Man_t * p, int ObjId, int Type, char * pName, char
     // check if the object with this ID is already stored
     if ( (pEntry = Nm_ManTableLookupId(p, ObjId)) )
     {
-        printf( "Nm_ManStoreIdName(): Entry with the same ID already exists.\n" );
+        printf( "Nm_ManStoreIdName(): Entry with ID %d already exists.\n", ObjId );
         return NULL;
     }
     // create a new entry
@@ -152,7 +152,7 @@ void Nm_ManDeleteIdName( Nm_Man_t * p, int ObjId )
     pEntry = Nm_ManTableLookupId(p, ObjId);
     if ( pEntry == NULL )
     {
-        printf( "Nm_ManDeleteIdName(): This entry is not in the table.\n" );
+        printf( "Nm_ManDeleteIdName(): Entry with ID %d is not in the table.\n", ObjId );
         return;
     }
     // remove entry from the table
diff --git a/src/misc/tim/tim.h b/src/misc/tim/tim.h
index 06019f56b..a01d53e32 100644
--- a/src/misc/tim/tim.h
+++ b/src/misc/tim/tim.h
@@ -140,6 +140,7 @@ extern float *         Tim_ManGetReqTimes( Tim_Man_t * p );
 extern void            Tim_ManStop( Tim_Man_t * p );
 extern void            Tim_ManStopP( Tim_Man_t ** p );
 extern void            Tim_ManPrint( Tim_Man_t * p );
+extern void            Tim_ManPrintBoxCopy( Tim_Man_t * p );
 extern void            Tim_ManPrintStats( Tim_Man_t * p, int nAnd2Delay );
 extern int             Tim_ManCiNum( Tim_Man_t * p );
 extern int             Tim_ManCoNum( Tim_Man_t * p );
diff --git a/src/misc/tim/timMan.c b/src/misc/tim/timMan.c
index 151bf91d1..7e112669e 100644
--- a/src/misc/tim/timMan.c
+++ b/src/misc/tim/timMan.c
@@ -564,10 +564,10 @@ void Tim_ManPrint( Tim_Man_t * p )
     if ( Tim_ManBoxNum(p) > 0 )
     Tim_ManForEachBox( p, pBox, i )
     {
-        printf( "*** Box %5d :  I =%4d. O =%4d. I1 =%6d. O1 =%6d. Table =%4d\n", 
+        printf( "*** Box %5d :  I =%4d. O =%4d. I1 =%6d. O1 =%6d. Table =%4d. Copy = %d.\n", 
             i, pBox->nInputs, pBox->nOutputs, 
             Tim_ManBoxInputFirst(p, i), Tim_ManBoxOutputFirst(p, i), 
-            pBox->iDelayTable );
+            pBox->iDelayTable, pBox->iCopy );
 
         // print box inputs
         pPrev = Tim_ManBoxInput( p, pBox, 0 );
@@ -591,7 +591,7 @@ void Tim_ManPrint( Tim_Man_t * p )
             Tim_ManBoxForEachOutput( p, pBox, pObj, k )
                 printf( "box-out%3d :  arrival = %5.3f  required = %5.3f\n", k, pObj->timeArr, pObj->timeReq );
 
-        if ( i > 2 )
+        if ( i == 7 )
             break;
     }
 
@@ -611,6 +611,8 @@ void Tim_ManPrint( Tim_Man_t * p )
                     printf( "%5s", "-" );
                 else
                     printf( "%5.0f", pTable[3+j*TableX+k] );
+        if ( i == 7 )
+            break;
     }
     printf( "\n" );
 }
diff --git a/src/misc/util/abc_global.h b/src/misc/util/abc_global.h
index 4bc3c1c15..b666fca01 100644
--- a/src/misc/util/abc_global.h
+++ b/src/misc/util/abc_global.h
@@ -248,6 +248,7 @@ typedef ABC_INT64_T iword;
 ////////////////////////////////////////////////////////////////////////
 
 #define ABC_INFINITY    (1000000000)
+#define ABC_INT_MAX     (2147483647)
 
 #define ABC_SWAP(Type, a, b)  { Type t = a; a = b; b = t; }
 
diff --git a/src/misc/util/module.make b/src/misc/util/module.make
index 66e87653f..bf3538360 100644
--- a/src/misc/util/module.make
+++ b/src/misc/util/module.make
@@ -1,4 +1,5 @@
 SRC +=  src/misc/util/utilBridge.c \
+    src/misc/util/utilBSet.c \
     src/misc/util/utilCex.c \
     src/misc/util/utilColor.c \
     src/misc/util/utilFile.c \
diff --git a/src/misc/util/utilBSet.c b/src/misc/util/utilBSet.c
new file mode 100644
index 000000000..8cee38e1b
--- /dev/null
+++ b/src/misc/util/utilBSet.c
@@ -0,0 +1,1036 @@
+/**CFile****************************************************************
+
+  FileName    [utilBSet.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Bound set evaluation.]
+
+  Synopsis    [Bound set evaluation.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - December 25, 2024.]
+
+  Revision    [$Id: utilBSet.c,v 1.00 2024/12/25 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "misc/vec/vec.h"
+#include "misc/extra/extra.h"
+#include "misc/util/utilTruth.h"
+
+#ifdef _MSC_VER
+#  include <intrin.h>
+#  define __builtin_popcount __popcnt
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Abc_BSEval_t_  Abc_BSEval_t;
+struct Abc_BSEval_t_
+{
+    int           nVars;
+    int           nBVars;
+    Vec_Int_t *   vPairs;   // perm pairs
+    Vec_Int_t *   vCounts;  // cofactor counts
+    Vec_Int_t *   vTable;   // hash table
+    Vec_Int_t *   vUsed;    // used entries
+    Vec_Wrd_t *   vStore;   // cofactors
+    Vec_Wec_t *   vSets;    // sets
+    Vec_Wrd_t *   vCofs;    // cofactors
+};
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Bound-set evalution.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_TtGetCM1( word * p, int nVars )
+{
+    int Counts[4] = {0};
+    int i, Res = 0, nDigits = 1 << (nVars - 1);
+    for ( i = 0; i < nDigits; i++ )
+        Counts[Abc_TtGetQua(p, i)]++;
+    for ( i = 0; i < 4; i++ )
+        Res += Counts[i] > 0;
+    return Res;
+}
+int Abc_TtGetCM2( word * p, int nVars )
+{
+    int Counts[16] = {0};
+    int i, Res = 0, nDigits = 1 << (nVars - 2);
+    for ( i = 0; i < nDigits; i++ )
+        Counts[Abc_TtGetHex(p, i)]++;
+    for ( i = 0; i < 16; i++ )
+        Res += Counts[i] > 0;
+    return Res;
+}
+int Abc_TtGetCM3( word * p, int nVars, int * pCounts, Vec_Int_t * vUsed )
+{
+    unsigned char * q = (unsigned char *)p;
+    int i, Digit, nDigits = 1 << (nVars - 3);
+    Vec_IntClear( vUsed );
+    for ( i = 0; i < nDigits; i++ ) {
+        if ( pCounts[q[i]] == 1 )
+            continue;
+        pCounts[q[i]] = 1;
+        Vec_IntPush(vUsed, q[i]);
+    }
+    Vec_IntForEachEntry( vUsed, Digit, i )
+        pCounts[Digit] = -1;
+    return Vec_IntSize(vUsed);
+}
+int Abc_TtGetCM4( word * p, int nVars, int * pCounts, Vec_Int_t * vUsed )
+{
+    unsigned short * q = (unsigned short *)p;
+    int i, Digit, nDigits = 1 << (nVars - 4);
+    Vec_IntClear( vUsed );
+    for ( i = 0; i < nDigits; i++ ) {
+        if ( pCounts[q[i]] == 1 )
+            continue;
+        pCounts[q[i]] = 1;
+        Vec_IntPush(vUsed, q[i]);
+    }
+    Vec_IntForEachEntry( vUsed, Digit, i )
+        pCounts[Digit] = -1;
+    return Vec_IntSize(vUsed);
+}
+
+// https://en.wikipedia.org/wiki/Jenkins_hash_function
+int Abc_TtGetKey( unsigned char * p, int nSize, int nTableSize )
+{
+    int i = 0; unsigned hash = 0;
+    while ( i != nSize ) 
+    {
+        hash += p[i++];
+        hash += hash << 10;
+        hash ^= hash >> 6;
+    }
+    hash += hash << 3;
+    hash ^= hash >> 11;
+    hash += hash << 15;
+    return (int)(hash % nTableSize);
+}
+int Abc_TtHashLookup5( int Entry, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed )
+{
+    int Key = Abc_TtGetKey( (unsigned char*)&Entry, 4, Vec_IntSize(vTable) );
+    int * pTable = Vec_IntArray(vTable);
+    for ( ; pTable[Key] >= 0; Key = (Key + 1) % Vec_IntSize(vTable) )
+        if ( Entry == (int)Vec_WrdEntry(vStore, pTable[Key]) )
+            return pTable[Key];
+    assert( pTable[Key] == -1 );
+    pTable[Key] = Vec_WrdSize(vStore);
+    Vec_WrdPush( vStore, (word)Entry );
+    Vec_IntPush( vUsed, Key );
+    return pTable[Key];
+}
+int Abc_TtGetCM5( word * p, int nVars, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed )
+{
+    unsigned * q = (unsigned *)p;
+    int i, Item, nDigits = 1 << (nVars - 5);
+    Vec_WrdClear( vStore );
+    Vec_IntClear( vUsed );
+    for ( i = 0; i < nDigits; i++ )
+        Abc_TtHashLookup5( q[i], vTable, vStore, vUsed );
+    Vec_IntForEachEntry( vUsed, Item, i )
+        Vec_IntWriteEntry( vTable, Item, -1 );
+    return Vec_IntSize(vUsed);
+}
+int Abc_TtHashLookup6( word * pEntry, int nWords, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed )
+{
+    int i, Key = Abc_TtGetKey( (unsigned char*)pEntry, 8*nWords, Vec_IntSize(vTable) );
+    int * pTable = Vec_IntArray(vTable);
+    for ( ; pTable[Key] >= 0; Key = (Key + 1) % Vec_IntSize(vTable) )
+        if ( !memcmp(pEntry, Vec_WrdEntryP(vStore, nWords*pTable[Key]), 8*nWords) )
+            return pTable[Key];
+    assert( pTable[Key] == -1 );
+    pTable[Key] = Vec_WrdSize(vStore)/nWords;
+    for ( i = 0; i < nWords; i++ )
+        Vec_WrdPush( vStore, pEntry[i] );
+    Vec_IntPush( vUsed, Key );
+    return pTable[Key];
+}
+int Abc_TtGetCM6( word * p, int nVars, int nFVars, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed )
+{
+    assert( nFVars >= 6 && nFVars < nVars );
+    int i, Item, nDigits = 1 << (nVars - nFVars), nWords = 1 << (nFVars - 6);
+    Vec_WrdClear( vStore );
+    Vec_IntClear( vUsed );
+    //assert( Vec_IntSum(vTable) == -Vec_IntSize(vTable) );
+    for ( i = 0; i < nDigits; i++ )
+        Abc_TtHashLookup6( p + i*nWords, nWords, vTable, vStore, vUsed );
+    Vec_IntForEachEntry( vUsed, Item, i )
+        Vec_IntWriteEntry( vTable, Item, -1 );
+    return Vec_IntSize(vUsed);
+}
+int Abc_TtGetCMCount( word * p, int nVars, int nFVars, Vec_Int_t * vCounts, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed )
+{
+    if ( nFVars == 1 ) 
+        return Abc_TtGetCM1( p, nVars );
+    if ( nFVars == 2 ) 
+        return Abc_TtGetCM2( p, nVars );
+    if ( nFVars == 3 ) 
+        return Abc_TtGetCM3( p, nVars, Vec_IntArray(vCounts), vUsed );
+    if ( nFVars == 4 ) 
+        return Abc_TtGetCM4( p, nVars, Vec_IntArray(vCounts), vUsed );
+    if ( nFVars == 5 ) 
+        return Abc_TtGetCM5( p, nVars, vTable, vStore, vUsed );
+    if ( nFVars == 6 ) 
+        return Abc_TtGetCM6( p, nVars, nFVars, vTable, vStore, vUsed );
+    assert( 0 );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Bound-set evalution.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_TtGetCM1Pat( word * p, int nVars, word * pPat )
+{
+    int nUsed = 0, pUsed[4], pMap[4];
+    int i, nDigits = 1 << (nVars - 1), nWordsBS = Abc_TtWordNum(nVars - 1);
+    memset( pMap, 0xFF, 16 );
+    for ( i = 0; i < nDigits; i++ ) {
+        int Digit = Abc_TtGetQua(p, i);
+        if ( pMap[Digit] == -1 ) {
+            pMap[Digit] = nUsed;
+            pUsed[nUsed++] = Digit;
+        }
+        if ( pPat ) Abc_TtSetBit( pPat + nWordsBS*pMap[Digit], i );
+    }
+    return nUsed;
+}
+int Abc_TtGetCM2Pat( word * p, int nVars, word * pPat )
+{
+    int nUsed = 0, pUsed[16], pMap[16];
+    int i, nDigits = 1 << (nVars - 2), nWordsBS = Abc_TtWordNum(nVars - 2);
+    memset( pMap, 0xFF, 64 );
+    for ( i = 0; i < nDigits; i++ ) {
+        int Digit = Abc_TtGetHex(p, i);
+        if ( pMap[Digit] == -1 ) {
+            pMap[Digit] = nUsed;
+            pUsed[nUsed++] = Digit;
+        }
+        if ( pPat ) Abc_TtSetBit( pPat + nWordsBS*pMap[Digit], i );
+    }
+    return nUsed;
+}
+int Abc_TtGetCM3Pat( word * p, int nVars, int * pMap, Vec_Int_t * vUsed, word * pPat )
+{
+    unsigned char * q = (unsigned char *)p;
+    int i, Digit, nDigits = 1 << (nVars - 3), nWordsBS = Abc_TtWordNum(nVars - 3);
+    Vec_IntClear( vUsed );
+    for ( i = 0; i < nDigits; i++ ) {
+        if ( pMap[q[i]] == -1 ) {
+            pMap[q[i]] = Vec_IntSize(vUsed);
+            Vec_IntPush(vUsed, q[i]);
+        }
+        if ( pPat ) Abc_TtSetBit( pPat + nWordsBS*pMap[q[i]], i );
+    }
+    Vec_IntForEachEntry( vUsed, Digit, i )
+        pMap[Digit] = -1;
+    return Vec_IntSize(vUsed);
+}
+int Abc_TtGetCM4Pat( word * p, int nVars, int * pMap, Vec_Int_t * vUsed, word * pPat )
+{
+    unsigned short * q = (unsigned short *)p;
+    int i, Digit, nDigits = 1 << (nVars - 4), nWordsBS = Abc_TtWordNum(nVars - 4);
+    Vec_IntClear( vUsed );
+    for ( i = 0; i < nDigits; i++ ) {
+        if ( pMap[q[i]] == -1 ) {
+            pMap[q[i]] = Vec_IntSize(vUsed);
+            Vec_IntPush(vUsed, q[i]);
+        }
+        if ( pPat ) Abc_TtSetBit( pPat + nWordsBS*pMap[q[i]], i );
+    }
+    Vec_IntForEachEntry( vUsed, Digit, i )
+        pMap[Digit] = -1;
+    return Vec_IntSize(vUsed);
+}
+int Abc_TtGetCM5Pat( word * p, int nVars, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed, word * pPat )
+{
+    unsigned * q = (unsigned *)p;
+    int i, Item, nDigits = 1 << (nVars - 5), nWordsBS = Abc_TtWordNum(nVars - 5);
+    Vec_WrdClear( vStore );
+    Vec_IntClear( vUsed );
+    if ( pPat )
+        for ( i = 0; i < nDigits; i++ )
+            Abc_TtSetBit( pPat + nWordsBS*Abc_TtHashLookup5(q[i], vTable, vStore, vUsed), i );
+    else
+        for ( i = 0; i < nDigits; i++ )
+            Abc_TtHashLookup5( q[i], vTable, vStore, vUsed );
+    Vec_IntForEachEntry( vUsed, Item, i )
+        Vec_IntWriteEntry( vTable, Item, -1 );
+    return Vec_IntSize(vUsed);
+}
+int Abc_TtGetCM6Pat( word * p, int nVars, int nFVars, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed, word * pPat )
+{
+    assert( nFVars >= 6 && nFVars < nVars );
+    int i, Item, nDigits = 1 << (nVars - nFVars), nWords = 1 << (nFVars - 6), nWordsBS = Abc_TtWordNum(nVars - nFVars);
+    Vec_WrdClear( vStore );
+    Vec_IntClear( vUsed );    
+    if ( pPat )
+        for ( i = 0; i < nDigits; i++ )
+            Abc_TtSetBit( pPat + nWordsBS*Abc_TtHashLookup6(p + i*nWords, nWords, vTable, vStore, vUsed), i );
+    else
+        for ( i = 0; i < nDigits; i++ )
+            Abc_TtHashLookup6( p + i*nWords, nWords, vTable, vStore, vUsed );
+    Vec_IntForEachEntry( vUsed, Item, i )
+        Vec_IntWriteEntry( vTable, Item, -1 );
+    return Vec_IntSize(vUsed);
+}
+
+void Abc_TtPrintPat( word * pPat, int nVars, int nMyu )
+{
+    printf( "ACD i-sets with %d variables and column multiplicity %d:\n", nVars, nMyu );
+    for ( int m = 0; m < nMyu; m++ )
+        Extra_PrintBinary( stdout, (unsigned *)&pPat[m], (1 << nVars) ), printf("\n");
+}
+int Abc_TtCheck1Shared( word * pPat, int nVars, int nFVars, int nMyu )
+{
+    int fVerbose = 0;
+    if ( fVerbose ) Abc_TtPrintPat( pPat, nVars-nFVars, nMyu );
+    assert( nMyu > 2 );
+    int nRails  = Abc_Base2Log(nMyu);
+    int nMyuMax = 1 << (nRails - 1);
+    for ( int v = 0; v < nVars - nFVars; v++ ) {
+        int m, n, Counts[2] = {0};
+        for ( n = 0; n < 2; n++ ) {
+            for ( m = 0; m < nMyu; m++ )
+                if ( (Counts[n] += ((s_Truth26[n][v] & pPat[m]) != 0)) > nMyuMax )
+                    break;
+            if ( m < nMyu )
+                break;
+        }
+        if ( fVerbose ) printf( "%d : %2d %2d  %2d\n", v, Counts[0], Counts[1], nMyuMax );
+        if ( n == 2 ) {
+            //Abc_TtPrintPat( pPat, nVars-nFVars, nMyu );
+            //printf( "%d : %2d %2d  %2d\n", v, Counts[0], Counts[1], nMyuMax );
+            return nRails - 1;
+        }
+    }
+    if ( fVerbose ) printf( "Not found\n" );
+    return nRails;
+}
+int Abc_TtGetCMInt( word * p, int nVars, int nFVars, Vec_Int_t * vCounts, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed, word * pPat )
+{
+    int nMintsBS = 1 << (nVars - nFVars);
+    int nWordsBS = Abc_TtWordNum(nVars - nFVars);
+    assert( nMintsBS * nWordsBS <= 1024 );
+    memset( pPat, 0, 8 * nMintsBS * nWordsBS );
+    int nMyu = 0;
+    if ( nFVars == 1 ) 
+        nMyu = Abc_TtGetCM1Pat( p, nVars, pPat );
+    else if ( nFVars == 2 ) 
+        nMyu = Abc_TtGetCM2Pat( p, nVars, pPat );
+    else if ( nFVars == 3 ) 
+        nMyu = Abc_TtGetCM3Pat( p, nVars, Vec_IntArray(vCounts), vUsed, pPat );
+    else if ( nFVars == 4 ) 
+        nMyu = Abc_TtGetCM4Pat( p, nVars, Vec_IntArray(vCounts), vUsed, pPat );
+    else if ( nFVars == 5 ) 
+        nMyu = Abc_TtGetCM5Pat( p, nVars, vTable, vStore, vUsed, pPat );
+    else if ( nFVars == 6 ) 
+        nMyu = Abc_TtGetCM6Pat( p, nVars, nFVars, vTable, vStore, vUsed, pPat );
+    else assert( 0 );
+    return nMyu;
+}
+
+int Abc_TtGetCMPat( word * p, int nVars, int nFVars, Vec_Int_t * vCounts, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed )
+{
+    word pPat[1024];
+    int nRails, nMyu = Abc_TtGetCMInt( p, nVars, nFVars, vCounts, vTable, vStore, vUsed, pPat );
+    if ( nMyu <= 2 )
+        nRails = 1;
+    else
+        nRails = Abc_TtCheck1Shared( pPat, nVars, nFVars, nMyu );
+    return nRails;
+}
+int Abc_TtGetCM( word * p, int nVars, int nFVars, Vec_Int_t * vCounts, Vec_Int_t * vTable, Vec_Wrd_t * vStore, Vec_Int_t * vUsed, int fShared )
+{
+    if ( fShared )
+        return Abc_TtGetCMPat( p, nVars, nFVars, vCounts, vTable, vStore, vUsed );
+    return Abc_TtGetCMCount( p, nVars, nFVars, vCounts, vTable, vStore, vUsed );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Permutation generation.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static void Abc_TtPermGen( int * currPerm, int nVars, word * pT, int nTtVars )
+{
+    int i = nVars - 1;
+    while ( i >= 0 && currPerm[i - 1] >= currPerm[i] )
+        i--;
+    if (i >= 0)
+    {
+        int j = nVars;
+        while ( j > i && currPerm[j - 1] <= currPerm[i - 1 ])
+            j--;
+        ABC_SWAP( int, currPerm[i - 1], currPerm[j - 1] )
+        if ( pT ) Abc_TtSwapVars( pT, nTtVars, i-1, j-1 );
+        i++;
+        j = nVars;
+        while ( i < j )
+        {
+            ABC_SWAP( int, currPerm[i - 1], currPerm[j - 1] )
+            if ( pT ) Abc_TtSwapVars( pT, nTtVars, i-1, j-1 );
+            i++;
+            j--;
+        }
+    }
+}
+static int Abc_TtFactorial(int nVars)
+{
+    int i, Res = 1;
+    for ( i = 1; i <= nVars; i++ )
+        Res *= i;
+    return Res;
+}
+void Abc_TtPermGenTest()
+{
+    int i, k, nVars = 5, currPerm[5] = {0};
+    for ( i = 0; i < nVars; i++ )
+        currPerm[i] = i;
+    int fact = Abc_TtFactorial( nVars );
+    for ( i = 0; i < fact; i++ )
+    {
+        printf( "%3d :", i );
+        for ( k = 0; k < nVars; k++ )
+            printf( " %d", currPerm[k] );
+        printf( "\n" );
+        Abc_TtPermGen( currPerm, nVars, NULL, 0 );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Combination generation.]
+
+  Description [https://stackoverflow.com/questions/22650522/how-to-generate-chases-sequence]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_GenChaseNext(int a[], int w[], int *r) 
+{
+    int found_r = 0;
+    int j;
+    for (j = *r; !w[j]; j++) {
+        int b = a[j] + 1;
+        int n = a[j + 1];
+        if (b < (w[j + 1] ? n - (2 - (n & 1)) : n)) {
+            if ((b & 1) == 0 && b + 1 < n) b++;
+            a[j] = b;
+            if (!found_r) *r = j > 1 ? j - 1 : 0;
+            return;
+        }
+        w[j] = a[j] - 1 >= j;
+        if (w[j] && !found_r) {
+            *r = j;
+            found_r = 1;
+        }
+    }
+    int b = a[j] - 1;
+    if ((b & 1) != 0 && b - 1 >= j) b--;
+    a[j] = b;
+    w[j] = b - 1 >= j;
+    if (!found_r) *r = j;
+}
+Vec_Int_t * Abc_GenChasePairs( int N, int T ) 
+{
+    Vec_Int_t * vPairs = Vec_IntAlloc( 100 );
+    int j, z, r = 0, Count = 0, a[32], b[32], w[32];
+    for ( j = 0; j < T + 1; j++ ) {
+        a[j] = N - (T - j);
+        w[j] = 1;
+    }
+    do {
+        for ( z = 0; z <= T; z++ )
+            b[z] = a[z];
+        Abc_GenChaseNext( a, w, &r );
+        for ( z = 0; z < T; z++ ) {
+            if ( a[z] == b[z] )
+                continue;
+            Vec_IntPushTwo( vPairs, b[z], a[z] );
+            if ( 0 ) {
+                printf( "%3d : ", Count++ );
+                for (j = T - 1; j > -1; j--) printf("%x", b[j]);
+                printf( "  %d <-> %d  ", b[z], a[z] );
+                for (j = T - 1; j > -1; j--) printf("%x", a[j]);
+                printf( "\n" );
+            }
+            break;
+        }
+    } while (a[T] == N);
+    Vec_IntPushTwo( vPairs, 0, 0 );
+    return vPairs;
+}
+void Abc_GenChasePrint( int Count, int * pPerm, int nVars, int nFVars, int Var0, int Var1 )
+{
+    int k;
+    printf( "%3d :  ", Count++ );
+    for ( k = nVars-1; k >= nFVars; k-- )
+        printf( "%d", pPerm[k] );
+    printf( " " );
+    for ( k = nFVars-1; k >= 0; k-- )
+        printf( "%d", pPerm[k] );
+    printf( "  %d <-> %d\n", Var0, Var1 );
+}
+void Abc_GenChaseTest()
+{
+    int nVars  = 4;
+    int nFVars = 2;
+    Vec_Int_t * vPairs = Abc_GenChasePairs( nVars, nVars-nFVars );
+    int i, Var0, Var1, Pla2Var[32], Var2Pla[32];
+    for ( i = 0; i < nVars; i++ )
+        Pla2Var[i] = Var2Pla[i] = i;
+    int Count = 0;
+    Vec_IntForEachEntryDouble( vPairs, Var0, Var1, i ) {
+        Abc_GenChasePrint( Count++, Pla2Var, nVars, nFVars, Var0, Var1 );
+        int iPlace0 = Var2Pla[Var0];
+        int iPlace1 = Var2Pla[Var1];
+        //Abc_TtSwapVars( pTruth, nVars, iPlace0, iPlace1 );
+        Var2Pla[Pla2Var[iPlace0]] = iPlace1;
+        Var2Pla[Pla2Var[iPlace1]] = iPlace0;
+        Pla2Var[iPlace0] ^= Pla2Var[iPlace1];
+        Pla2Var[iPlace1] ^= Pla2Var[iPlace0];
+        Pla2Var[iPlace0] ^= Pla2Var[iPlace1];
+    }
+    Vec_IntFree( vPairs );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Bound-set evalution for one function.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Abc_BSEval_t * Abc_BSEvalAlloc()
+{
+    Abc_BSEval_t * p = ABC_CALLOC( Abc_BSEval_t, 1 );
+    p->vCounts  = Vec_IntStartFull( 1 << 16 );
+    p->vTable   = Vec_IntStartFull( 997 );
+    p->vUsed    = Vec_IntAlloc(100);
+    p->vStore   = Vec_WrdAlloc(1000);
+    return p;
+}
+void Abc_BSEvalFree( Abc_BSEval_t * p )
+{
+    Vec_IntFreeP( &p->vPairs );
+    Vec_IntFree( p->vCounts );
+    Vec_IntFree( p->vTable  );
+    Vec_IntFree( p->vUsed   );
+    Vec_WrdFree( p->vStore  );
+    Vec_WecFreeP( &p->vSets );
+    Vec_WrdFreeP( &p->vCofs );    
+    ABC_FREE( p );
+}
+void Abc_BSEvalOneTest( word * pT, int nVars, int nBVars, int fVerbose )
+{
+    assert( nVars > nBVars );
+    Abc_BSEval_t * p = Abc_BSEvalAlloc();
+    if ( p->nVars != nVars || p->nBVars != nBVars ) {
+        Vec_IntFreeP( &p->vPairs );
+        p->vPairs = Abc_GenChasePairs( nVars, nBVars );
+        p->nVars = nVars;
+        p->nBVars = nBVars;
+    }
+    int Best = Abc_TtGetCM( pT, nVars, nVars-nBVars, p->vCounts, p->vTable, p->vStore, p->vUsed, 0 );
+    printf( "Function: " ); Extra_PrintHex( stdout, (unsigned *)pT, nVars ); printf( "\n" );
+    printf( "The column multiplicity of the %d-var function with bound-sets of size %d is %d.\n", nVars, nBVars, Best );
+    Abc_BSEvalFree(p);
+}
+int Abc_BSEvalBest( Abc_BSEval_t * p, word * pIn, word * pBest, int nVars, int nCVars, int nFVars, int fVerbose, int * pPermBest, int fShared )
+{
+    int i, k, Var0, Var1, Pla2Var[32], Var2Pla[32];
+    int nPermVars = nVars-nCVars;
+    assert( p->nVars == nPermVars && p->nBVars == nPermVars-nFVars );
+    for ( i = 0; i < nVars; i++ )
+        Pla2Var[i] = Var2Pla[i] = i;
+    if ( pPermBest )
+        for ( i = 0; i < nVars; i++ )
+            pPermBest[i] = i;
+    int CostBest = 1 << nVars;
+    //int Count = 0;
+    Vec_IntForEachEntryDouble( p->vPairs, Var0, Var1, i ) {
+        //Abc_GenChasePrint( Count++, Pla2Var, nVars, nFVars, Var0, Var1 );
+        int  CostThis = Abc_TtGetCM( pIn, nVars, nFVars, p->vCounts, p->vTable, p->vStore, p->vUsed, fShared );
+        if ( CostBest > CostThis ) {
+            CostBest = CostThis;
+            if ( pBest )     Abc_TtCopy( pBest, pIn, Abc_Truth6WordNum(nVars), 0 );
+            if ( pPermBest ) memcpy( pPermBest, Pla2Var, sizeof(int)*nVars );
+        }
+        if ( fVerbose )
+        {
+            printf( "%3d : ", i/2 );
+            for ( k = nCVars-1; k >= 0; k-- )
+                printf( " %d", nVars-nCVars+k );
+            printf( " " );
+            for ( k = nPermVars-1; k >= nFVars; k-- )
+                printf( " %d", Pla2Var[k] );
+            printf( " " );
+            for ( k = nFVars-1; k >= 0; k-- )
+                printf( " %d", Pla2Var[k] );
+            printf( "  : Myu = %3d", CostThis );
+            printf( "\n" );
+        }
+        int iPlace0 = Var2Pla[Var0];
+        int iPlace1 = Var2Pla[Var1];
+        if ( iPlace0 == iPlace1 )
+            continue;
+        Abc_TtSwapVars( pIn, nVars, iPlace0, iPlace1 );
+        Var2Pla[Pla2Var[iPlace0]] = iPlace1;
+        Var2Pla[Pla2Var[iPlace1]] = iPlace0;
+        Pla2Var[iPlace0] ^= Pla2Var[iPlace1];
+        Pla2Var[iPlace1] ^= Pla2Var[iPlace0];
+        Pla2Var[iPlace0] ^= Pla2Var[iPlace1];
+    }
+    for ( i = 0; i < nPermVars; i++ )
+    {
+        int iPlace0 = i;
+        int iPlace1 = Var2Pla[i];
+        if ( iPlace0 == iPlace1 )
+            continue;
+        Abc_TtSwapVars( pIn, nVars, iPlace0, iPlace1 );
+        Var2Pla[Pla2Var[iPlace0]] = iPlace1;
+        Var2Pla[Pla2Var[iPlace1]] = iPlace0;
+        Pla2Var[iPlace0] ^= Pla2Var[iPlace1];
+        Pla2Var[iPlace1] ^= Pla2Var[iPlace0];
+        Pla2Var[iPlace0] ^= Pla2Var[iPlace1];
+    }
+    return CostBest;
+}
+void Abc_BSEvalBestTest( word * pIn, int nVars, int nBVars, int fShared, int fVerbose )
+{
+    assert( nVars > nBVars );
+    Abc_BSEval_t * p = Abc_BSEvalAlloc(); int i, pPerm[32] = {0};
+    if ( p->nVars != nVars || p->nBVars != nBVars ) {
+        Vec_IntFreeP( &p->vPairs );
+        p->vPairs = Abc_GenChasePairs( nVars, nBVars );
+        p->nVars = nVars;
+        p->nBVars = nBVars;        
+    }    
+    word * pFun = ABC_ALLOC( word, Abc_TtWordNum(nVars) );
+    int Best = Abc_BSEvalBest( p, pIn, pFun, nVars, 0, nVars-nBVars, fVerbose, pPerm, fShared );
+    printf( "The minimum %s of the %d-var function with bound-sets of size %d is %d.\n", 
+        fShared ? "number of rails" : "column multiplicity", nVars, nBVars, Best );
+    printf( "Original: " ); Extra_PrintHex( stdout, (unsigned *)pIn,  nVars ); printf( "\n" );
+    printf( "Permuted: " ); Extra_PrintHex( stdout, (unsigned *)pFun, nVars ); printf( "\n" );
+    printf( "Permutation is " );
+    for ( i = 0; i < nVars; i++ )
+        printf( "%d ", pPerm[i] );
+    printf( "\n" );
+    ABC_FREE( pFun );
+    Abc_BSEvalFree(p);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Testing on random functions.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_BSEvalBestGen( int nVars, int nBVars, int nFuncs, int nMints, int fTryAll, int fShared, int fVerbose )
+{
+    assert( nVars > nBVars );
+    abctime clkTotal = Abc_Clock();
+    Abc_BSEval_t * p = Abc_BSEvalAlloc();
+    Vec_Int_t * vCounts[2] = { Vec_IntStart(1 << nVars), Vec_IntStart(1 << nVars) };
+    int i, k, Count, nWords = Abc_TtWordNum(nVars);
+    word * pFun = ABC_ALLOC( word, nWords );
+    if ( p->nVars != nVars || p->nBVars != nBVars ) {
+        Vec_IntFreeP( &p->vPairs );
+        p->vPairs = Abc_GenChasePairs( nVars, nBVars );
+        p->nVars = nVars;
+        p->nBVars = nBVars;        
+    }    
+    Abc_Random(1);
+    for ( i = 0; i < nFuncs; i++ ) {
+        if ( nMints == 0 )
+            for ( k = 0; k < nWords; k++ )
+                pFun[k] = Abc_RandomW(0);
+        else {
+            Abc_TtClear( pFun, nWords );
+            for ( k = 0; k < nMints; k++ ) {
+                int iMint = 0;
+                do iMint = Abc_Random(0) % (1 << nVars);
+                while ( Abc_TtGetBit(pFun, iMint) );
+                Abc_TtSetBit( pFun, iMint );
+            }
+        }
+        if ( fVerbose ) {
+            printf( "Function %5d ", i );
+            if ( nMints )
+                printf( "with %d positive minterms ", nMints );
+            if ( nVars <= 8 ) {
+                printf( "has truth table: " );
+                Extra_PrintHex( stdout, (unsigned *)pFun, nVars );
+            }
+            if ( fTryAll )
+                printf( "\n" );
+            else 
+                printf( "  " );
+        }
+        
+        if ( fTryAll )
+            Count = Abc_BSEvalBest( p, pFun, NULL, nVars, 0, nVars-nBVars, fVerbose, NULL, fShared );
+        else 
+            Count = Abc_TtGetCM( pFun, nVars, nVars-nBVars, p->vCounts, p->vTable, p->vStore, p->vUsed, fShared );
+        if ( fVerbose )
+            printf( "Myu = %d\n", Count );        
+        Vec_IntAddToEntry( vCounts[0], Count, 1 );
+        Vec_IntAddToEntry( vCounts[1], Abc_Base2Log(Count), 1 );
+    }
+    ABC_FREE( pFun );
+    Abc_BSEvalFree(p);
+    if ( nMints )
+        printf( "Generated %d random %d-var functions with %d positive minterms.\n", nFuncs, nVars, nMints );
+    else
+        printf( "Generated %d random %d-var functions.\n", nFuncs, nVars );
+    if ( fShared ) {
+        printf( "Distribution of the %s number of rails for bound set size %d with one shared variable:\n", fTryAll ? "MINIMUM": "ORIGINAL", nBVars );
+        assert( Vec_IntSum(vCounts[0]) == nFuncs );
+        Vec_IntForEachEntry( vCounts[0], Count, i )
+            if ( Count ) printf( "%d=%d (%.2f %%)  ", i, Count, 100.0*Count/nFuncs );
+        printf( "\n" );
+    }
+    else {
+        printf( "Distribution of the %s column multiplicity for bound set size %d with no shared variables:\n", fTryAll ? "MINIMUM": "ORIGINAL", nBVars );
+        assert( Vec_IntSum(vCounts[0]) == nFuncs );
+        Vec_IntForEachEntry( vCounts[0], Count, i )
+            if ( Count ) printf( "%d=%d (%.2f %%)  ", i, Count, 100.0*Count/nFuncs );
+        printf( "\n" );
+        printf( "Distribution of the %s number of rails for bound set size %d with no shared variables:\n", fTryAll ? "MINIMUM": "ORIGINAL", nBVars );
+        assert( Vec_IntSum(vCounts[1]) == nFuncs );
+        Vec_IntForEachEntry( vCounts[1], Count, i )
+            if ( Count ) printf( "%d=%d (%.2f %%)  ", i, Count, 100.0*Count/nFuncs );
+        printf( "\n" );
+    }
+    Vec_IntFree( vCounts[0] );
+    Vec_IntFree( vCounts[1] );
+    Abc_PrintTime( 1, "Total runtime", Abc_Clock() - clkTotal );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Finds shared variables.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_BSEvalCreateCofs( int iSet, int nVars, Vec_Wrd_t * vCofs, Vec_Wrd_t * vElems )
+{
+    int nWords = Abc_Truth6WordNum(nVars);
+    int m, i, nUsed = 0, pUsed[32], Start = Vec_WrdSize(vCofs);
+    for ( i = 0; i < nVars; i++ )
+        if ( (iSet >> i) & 1 )
+            pUsed[nUsed++] = i;
+    Vec_WrdFillExtra( vCofs, Start + nWords*(1 << nUsed), ~(word)0 );
+    for ( m = 0; m < (1 << nUsed); m++ )
+    {
+        word * pCof = Vec_WrdEntryP(vCofs, Start + m*nWords);
+        for ( i = 0; i < nUsed; i++ )
+            Abc_TtAndSharp( pCof, pCof, Vec_WrdEntryP(vElems, nWords*pUsed[i]), nWords, ((m >> i) & 1) == 0 );
+    }
+}
+Vec_Wrd_t * Abc_BSEvalCreateCofactorSets( int nVars, Vec_Wec_t ** pvSets )
+{
+    Vec_Wrd_t * vElems = Vec_WrdStartTruthTables6( nVars );
+    Vec_Wrd_t * vCofs  = Vec_WrdAlloc( 1000 );
+    Vec_Wec_t * vSets  = Vec_WecStart( nVars+1 );
+    int m, nMints = 1 << nVars;
+    for ( m = 0; m < nMints; m++ )
+    {
+        int nOnes = __builtin_popcount(m);
+        Vec_WecPushTwo( vSets, nOnes, m, Vec_WrdSize(vCofs) );
+        Abc_BSEvalCreateCofs( m, nVars, vCofs, vElems );
+    }
+    Vec_WrdFree( vElems );
+    *pvSets = vSets;
+    return vCofs;
+}
+
+static inline int Abc_BSEvalCountUnique( word * pISets, int nISets, int nBSWords, word * pCof )
+{
+    int i, Count = 0;
+    for ( i = 0; i < nISets; i++ )
+        Count += Abc_TtIntersect(pISets + i*nBSWords, pCof, nBSWords, 0);
+    return Count;
+}
+static inline int Abc_BSEvalCountUniqueMax( word * pISets, int nISets, int nBSWords, word * pCofs, int nOnes, int nISetsMaxHave )
+{
+    int m, nMints = (1 << nOnes), CountMax = 0;
+    assert( nOnes > 0 && nOnes < 5 );
+    for ( m = 0; m < nMints; m++ )
+    {
+        int Count = Abc_BSEvalCountUnique( pISets, nISets, nBSWords, pCofs + m * nBSWords );
+        if ( Count > nISetsMaxHave )
+            return 0;
+        CountMax = Abc_MaxInt( CountMax, Count );
+    }
+    return CountMax;
+}
+int Abc_BSEvalFindShared( int nVars, word * pISets, int nISets, int nBSWords, Vec_Wec_t * vSets, Vec_Wrd_t * vCofs, int nSharedMax )
+{
+    Vec_Int_t * vLevel; int i, k, iSet, iStart, nMinMyu = nISets, nMinRails = Abc_Base2Log(nISets), MinShared = 0, MinSet = -1;
+    Vec_WecForEachLevelStartStop( vSets, vLevel, i, 1, nSharedMax+1 ) {
+        Vec_IntForEachEntryDouble( vLevel, iSet, iStart, k ) {
+            int Count = Abc_BSEvalCountUniqueMax( pISets, nISets, nBSWords, Vec_WrdEntryP(vCofs, iStart), i, 1 << (nMinRails-1) );
+            if ( Count == 0 )
+                continue;
+            int CountRails = Abc_Base2Log(Count);
+            if ( nMinRails > CountRails || (nMinRails == CountRails && nMinMyu > Count && MinShared == i) ) {
+                 nMinRails = CountRails;
+                 nMinMyu   = Count;
+                 MinShared = i;
+                 MinSet    = iSet;
+            }
+        }
+    }
+    return (MinSet << 16) | nMinMyu;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_SharedEvalBest( Abc_BSEval_t * p, word * pTruth, int nVars, int nCVars, int nFVars, int MyuMin, int nRails, int fVerbose, int * pSetShared, word * pPat )
+{
+    int nBSWords = Abc_Truth6WordNum( nVars - nFVars ), CVarMask = Abc_InfoMask(nCVars) << (nVars - nFVars - nCVars);
+    int MyuCur, Myu = Abc_TtGetCMInt( pTruth, nVars, nFVars, p->vCounts, p->vTable, p->vStore, p->vUsed, pPat );
+    int nRailsCur = Abc_Base2Log( Myu ); Vec_Int_t * vLevel; 
+    assert( Myu == MyuMin && nRailsCur > nRails );
+    int i, k, iSet, iStart, nSharedMax = nVars - nFVars - 1, nRailsMin = 100; 
+    Vec_WecForEachLevelStartStop( p->vSets, vLevel, i, 1, nSharedMax+1 ) {
+        Vec_IntForEachEntryDouble( vLevel, iSet, iStart, k ) {
+            if ( iSet & CVarMask )
+                continue;
+            MyuCur = Abc_BSEvalCountUniqueMax( pPat, Myu, nBSWords, Vec_WrdEntryP(p->vCofs, iStart), i, 1 << nRails );
+            if ( MyuCur == 0 )
+                continue;
+            nRailsCur = Abc_Base2Log(MyuCur);
+            if ( nRailsCur > nRails )
+                continue;
+            if ( nRailsMin > nRailsCur ) {
+                 nRailsMin = nRailsCur;
+                *pSetShared = iSet;
+            }
+        }
+        if ( nRailsMin <= nRails )
+            break;
+    }
+    return nRailsMin;
+}
+int Abc_DeriveLutDec( word * pTruth, int nVars, int nCVars, int nFVars, int * pPerm, int nRails, int Shared, int fVerbose, Vec_Wrd_t * vRes )
+{
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Decomposing truth table into a K-LUT cascade with R rails.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+word * Abc_LutCascade2( word * pFunc, int nVars, int nLutSize, int nLuts, int nRails, int nIters, int fVerbose )
+{
+    Abc_BSEval_t * p = Abc_BSEvalAlloc();
+    Vec_Wrd_t * vRes = Vec_WrdStart( 1 ); word * pRes = NULL;
+    word * pTruth = ABC_ALLOC( word, Abc_TtWordNum(nVars) );
+    word * pBest  = ABC_ALLOC( word, Abc_TtWordNum(nVars) );
+    Abc_TtCopy( pTruth, pFunc, Abc_TtWordNum(nVars), 0 );
+    int i, nVarsCur = nVars, nOutVars = 0; word pPat[1024];
+    while ( nVarsCur > nLutSize )
+    {
+        int pPerm[32] = {0};
+        if ( p->nVars != nVarsCur || p->nBVars != nLutSize ) {            
+            Vec_IntFreeP( &p->vPairs );
+            if ( p->nBVars != nLutSize ) {
+                Vec_WecFreeP( &p->vSets );
+                Vec_WrdFreeP( &p->vCofs );
+                p->vCofs = Abc_BSEvalCreateCofactorSets( nLutSize, &p->vSets );
+            }
+            p->vPairs = Abc_GenChasePairs( nVarsCur, nLutSize );
+            p->nVars  = nVarsCur;
+            p->nBVars = nLutSize;  
+        }
+        int MyuMin = Abc_BSEvalBest( p, pTruth, pBest, nVarsCur, nOutVars, nVarsCur-nLutSize, fVerbose, pPerm, 0 );
+        int Shared = 0, nRailsMin = Abc_Base2Log( MyuMin );
+        if ( nRailsMin > nRails )
+            nRailsMin = Abc_SharedEvalBest( p, pBest, nVarsCur, nOutVars, nVarsCur-nLutSize, MyuMin, nRails, fVerbose, &Shared, pPat );
+        if ( nRailsMin > nRails ) {
+            Vec_WrdFreeP( &vRes );
+            break;
+        }
+        // update nVarsCur, pTruth, nOutVars, and vRes
+        nVarsCur = Abc_DeriveLutDec( pBest, nVarsCur, nOutVars, nVarsCur-nLutSize, pPerm, nRailsMin, Shared, fVerbose, vRes );
+        Abc_TtCopy( pTruth, pBest, Abc_TtWordNum(nVarsCur), 0 );
+        nOutVars = nRailsMin;
+    }
+    if ( vRes ) // decomposition succeeded
+    {
+        // create the last node
+        assert( nVarsCur <= nLutSize );
+        Vec_WrdAddToEntry( vRes, 0, 1 );
+        Vec_WrdPush( vRes, nVarsCur+4 );
+        Vec_WrdPush( vRes, nVarsCur );
+        for ( i = 0; i < nVarsCur; i++ )
+            Vec_WrdPush( vRes, i );
+        Vec_WrdPush( vRes, 0 );
+        Vec_WrdPush( vRes, pTruth[0] );
+        // extract the output array
+        pRes = Vec_WrdReleaseArray( vRes );
+        Vec_WrdFree( vRes );
+    }
+    // cleanup and return
+    Abc_BSEvalFree(p);
+    ABC_FREE( pTruth );
+    ABC_FREE( pBest );
+    return pRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Computes bound set and shared set of the next stage.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+word Abc_TtFindBVarsSVars( word * pTruth, int nVars, int nRVars, int nRails, int nLutSize, int fVerbose )
+{
+    Abc_BSEval_t * p = Abc_BSEvalAlloc(); 
+    int nPermVars = nVars-nRVars;
+    if ( p->nVars != nPermVars || p->nBVars != nLutSize ) {
+        if ( p->nBVars != nLutSize ) {
+            Vec_WecFreeP( &p->vSets );
+            Vec_WrdFreeP( &p->vCofs );
+            p->vCofs = Abc_BSEvalCreateCofactorSets( nLutSize, &p->vSets );
+        }        
+        Vec_IntFreeP( &p->vPairs );
+        p->vPairs = Abc_GenChasePairs( nPermVars, nLutSize );
+        p->nVars  = nPermVars;
+        p->nBVars = nLutSize;        
+    }    
+
+    int v, nWords = Abc_TtWordNum(nVars);
+    word * pCopy = ABC_ALLOC( word, nWords );
+    Abc_TtCopy( pCopy, pTruth, nWords, 0 );
+    word pPat[1024];
+
+
+    int pPermBest[32] = {0};
+    word * pBest = ABC_ALLOC( word, nWords );
+    //printf("Function before: "); Abc_TtPrintHexRev( stdout, pCopy, nVars ); printf( "\n" );
+    int MyuMin = Abc_BSEvalBest( p, pCopy, pBest, nVars, nRVars, nVars-nLutSize, 0, pPermBest, 0 );
+    //printf("Function before: "); Abc_TtPrintHexRev( stdout, pCopy, nVars ); printf( "\n" );
+
+    if ( fVerbose ) {
+        printf( "Best perm: " );
+        for ( v = 0; v < nVars; v++ )
+            printf( "%d ", pPermBest[v] );
+        printf( "  Myu = %d.  ", MyuMin );
+    }
+
+    int Shared = 0, nRailsMin = Abc_Base2Log( MyuMin );
+    if ( nRailsMin > nRails ) {
+        nRailsMin = Abc_SharedEvalBest( p, pBest, nVars, nRVars, nVars-nLutSize, MyuMin, nRails, 0, &Shared, pPat );
+        MyuMin = 1 << nRailsMin;
+    }
+
+    if ( fVerbose )
+        printf( "Myu min = %d.  Rail min = %d. Shared = %x.\n", MyuMin, nRailsMin, Shared );
+
+    word mBVars = 0;
+    for ( v = 0; v < nLutSize; v++ )
+        mBVars |= (word)1 << pPermBest[nVars-nLutSize+v];
+
+    word mSVars = 0;
+    for ( v = 0; v < nLutSize; v++ )
+        if ( (Shared >> v) & 1 )
+            mSVars |= (word)1 << (nVars-nLutSize+v);
+
+    ABC_FREE( pCopy );
+    ABC_FREE( pBest );
+    Abc_BSEvalFree(p);
+    return ((word)MyuMin << 48) | (mSVars << 24) | mBVars;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/misc/util/utilTruth.h b/src/misc/util/utilTruth.h
index 323c96467..cf3d6cedf 100644
--- a/src/misc/util/utilTruth.h
+++ b/src/misc/util/utilTruth.h
@@ -74,6 +74,25 @@ static word s_Truths6Neg[6] = {
     ABC_CONST(0x00000000FFFFFFFF)
 };
 
+static word s_Truth26[2][6] = {
+    {
+        ABC_CONST(0xAAAAAAAAAAAAAAAA),
+        ABC_CONST(0xCCCCCCCCCCCCCCCC),
+        ABC_CONST(0xF0F0F0F0F0F0F0F0),
+        ABC_CONST(0xFF00FF00FF00FF00),
+        ABC_CONST(0xFFFF0000FFFF0000),
+        ABC_CONST(0xFFFFFFFF00000000)
+    },
+    {
+        ABC_CONST(0x5555555555555555),
+        ABC_CONST(0x3333333333333333),
+        ABC_CONST(0x0F0F0F0F0F0F0F0F),
+        ABC_CONST(0x00FF00FF00FF00FF),
+        ABC_CONST(0x0000FFFF0000FFFF),
+        ABC_CONST(0x00000000FFFFFFFF)
+    }
+};
+
 static word s_TruthXors[6] = {
     ABC_CONST(0x0000000000000000),
     ABC_CONST(0x6666666666666666),
@@ -1988,6 +2007,27 @@ static inline word Abc_Tt6RemoveVar( word t, int iVar )
         t = Abc_Tt6SwapAdjacent( t, iVar++ );
     return t;
 }
+// permutes two variables while keeping track of their places
+static inline void Abc_TtPermuteTwo( word * p, int nTTVars, int * Var2Pla, int * Pla2Var, int Var0, int Var1 )
+{
+    int iPlace0 = Var2Pla[Var0];
+    int iPlace1 = Var2Pla[Var1];
+    if ( iPlace0 == iPlace1 )
+        return;
+    Abc_TtSwapVars( p, nTTVars, iPlace0, iPlace1 );
+    Var2Pla[Pla2Var[iPlace0]] = iPlace1;
+    Var2Pla[Pla2Var[iPlace1]] = iPlace0;
+    Pla2Var[iPlace0] ^= Pla2Var[iPlace1];
+    Pla2Var[iPlace1] ^= Pla2Var[iPlace0];
+    Pla2Var[iPlace0] ^= Pla2Var[iPlace1];
+}
+// restores natural variable order
+static inline void Abc_TtRestoreOrder( word * p, int nTTVars, int * Var2Pla, int * Pla2Var, int nPermVars )
+{
+    int i;
+    for ( i = 0; i < nPermVars; i++ )
+        Abc_TtPermuteTwo( p, nTTVars, Var2Pla, Pla2Var, i, Var2Pla[i] );
+}
 
 /**Function*************************************************************
 
@@ -3663,6 +3703,7 @@ static inline void Abc_TtProcessBiDecExperiment()
 //    Dau_DsdPrintFromTruth( &This, Abc_TtBitCount16(resThis) );
 //    Dau_DsdPrintFromTruth( &That, Abc_TtBitCount16(resThat) );
     nVars = nSuppLim;
+    This = s_Truth26[0][0];
 }
 
 /**Function*************************************************************
@@ -3854,6 +3895,23 @@ static inline word * Abc_TtSymFunGenerate( char * pOnes, int nVars )
     return pTruth;
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Fix big-endian when dealilng with 5-var truth tables.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Abc_TtFlipVar5( word * p, int nVars )
+{
+    int Test = 1;
+    if ( *((char *)&Test) == 0 && nVars > 5 )
+        Abc_TtFlip( p, Abc_TtWordNum(nVars), 5 );
+}
 
 ABC_NAMESPACE_HEADER_END
 
diff --git a/src/misc/vec/vecBit.h b/src/misc/vec/vecBit.h
index 9b0af9d94..6cecfba87 100644
--- a/src/misc/vec/vecBit.h
+++ b/src/misc/vec/vecBit.h
@@ -350,6 +350,7 @@ static inline void Vec_BitGrow( Vec_Bit_t * p, int nCapMin )
 {
     if ( p->nCap >= nCapMin )
         return;
+    assert( p->nCap < ABC_INT_MAX );
     nCapMin = (nCapMin >> 5) + ((nCapMin & 31) > 0);
     p->pArray = ABC_REALLOC( int, p->pArray, nCapMin ); 
     assert( p->pArray );
@@ -405,7 +406,7 @@ static inline void Vec_BitFillExtra( Vec_Bit_t * p, int nSize, int Fill )
     if ( nSize > 2 * p->nCap )
         Vec_BitGrow( p, nSize );
     else if ( nSize > p->nCap )
-        Vec_BitGrow( p, 2 * p->nCap );
+        Vec_BitGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
 
     assert( p->nSize < nSize );
     if ( (p->nSize >> 5) == (nSize >> 5) )
@@ -527,7 +528,7 @@ static inline void Vec_BitPush( Vec_Bit_t * p, int Entry )
         if ( p->nCap < 16 )
             Vec_BitGrow( p, 16 );
         else
-            Vec_BitGrow( p, 2 * p->nCap );
+            Vec_BitGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     if ( Entry == 1 )
         p->pArray[p->nSize >> 5] |=  (1 << (p->nSize & 31));
diff --git a/src/misc/vec/vecFlt.h b/src/misc/vec/vecFlt.h
index ea43ae24e..7ff8a364f 100644
--- a/src/misc/vec/vecFlt.h
+++ b/src/misc/vec/vecFlt.h
@@ -454,6 +454,7 @@ static inline void Vec_FltGrow( Vec_Flt_t * p, int nCapMin )
 {
     if ( p->nCap >= nCapMin )
         return;
+    assert( p->nCap < ABC_INT_MAX );
     p->pArray = ABC_REALLOC( float, p->pArray, nCapMin ); 
     p->nCap   = nCapMin;
 }
@@ -497,7 +498,7 @@ static inline void Vec_FltFillExtra( Vec_Flt_t * p, int nSize, float Fill )
     if ( nSize > 2 * p->nCap )
         Vec_FltGrow( p, nSize );
     else if ( nSize > p->nCap )
-        Vec_FltGrow( p, 2 * p->nCap );
+        Vec_FltGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     for ( i = p->nSize; i < nSize; i++ )
         p->pArray[i] = Fill;
     p->nSize = nSize;
@@ -554,7 +555,7 @@ static inline void Vec_FltPush( Vec_Flt_t * p, float Entry )
         if ( p->nCap < 16 )
             Vec_FltGrow( p, 16 );
         else
-            Vec_FltGrow( p, 2 * p->nCap );
+            Vec_FltGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->pArray[p->nSize++] = Entry;
 }
@@ -578,7 +579,7 @@ static inline void Vec_FltPushOrder( Vec_Flt_t * p, float Entry )
         if ( p->nCap < 16 )
             Vec_FltGrow( p, 16 );
         else
-            Vec_FltGrow( p, 2 * p->nCap );
+            Vec_FltGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->nSize++;
     for ( i = p->nSize-2; i >= 0; i-- )
diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index 0b1ae6d30..f56f34da4 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -552,6 +552,7 @@ static inline void Vec_IntGrow( Vec_Int_t * p, int nCapMin )
 {
     if ( p->nCap >= nCapMin )
         return;
+    assert( p->nCap < ABC_INT_MAX );
     p->pArray = ABC_REALLOC( int, p->pArray, nCapMin ); 
     assert( p->pArray );
     p->nCap   = nCapMin;
@@ -633,7 +634,7 @@ static inline void Vec_IntFillExtra( Vec_Int_t * p, int nSize, int Fill )
     if ( nSize > 2 * p->nCap )
         Vec_IntGrow( p, nSize );
     else if ( nSize > p->nCap )
-        Vec_IntGrow( p, 2 * p->nCap );
+        Vec_IntGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     for ( i = p->nSize; i < nSize; i++ )
         p->pArray[i] = Fill;
     p->nSize = nSize;
@@ -751,7 +752,7 @@ static inline void Vec_IntPush( Vec_Int_t * p, int Entry )
         if ( p->nCap < 16 )
             Vec_IntGrow( p, 16 );
         else
-            Vec_IntGrow( p, 2 * p->nCap );
+            Vec_IntGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->pArray[p->nSize++] = Entry;
 }
@@ -810,7 +811,7 @@ static inline void Vec_IntPushFirst( Vec_Int_t * p, int Entry )
         if ( p->nCap < 16 )
             Vec_IntGrow( p, 16 );
         else
-            Vec_IntGrow( p, 2 * p->nCap );
+            Vec_IntGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->nSize++;
     for ( i = p->nSize - 1; i >= 1; i-- )
@@ -837,7 +838,7 @@ static inline void Vec_IntPushOrder( Vec_Int_t * p, int Entry )
         if ( p->nCap < 16 )
             Vec_IntGrow( p, 16 );
         else
-            Vec_IntGrow( p, 2 * p->nCap );
+            Vec_IntGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->nSize++;
     for ( i = p->nSize-2; i >= 0; i-- )
@@ -855,7 +856,7 @@ static inline void Vec_IntPushOrderCost( Vec_Int_t * p, int Entry, Vec_Int_t * v
         if ( p->nCap < 16 )
             Vec_IntGrow( p, 16 );
         else
-            Vec_IntGrow( p, 2 * p->nCap );
+            Vec_IntGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->nSize++;
     for ( i = p->nSize-2; i >= 0; i-- )
@@ -931,7 +932,7 @@ static inline void Vec_IntPushOrderReverse( Vec_Int_t * p, int Entry )
         if ( p->nCap < 16 )
             Vec_IntGrow( p, 16 );
         else
-            Vec_IntGrow( p, 2 * p->nCap );
+            Vec_IntGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->nSize++;
     for ( i = p->nSize-2; i >= 0; i-- )
diff --git a/src/misc/vec/vecPtr.h b/src/misc/vec/vecPtr.h
index 0f024f687..24a4a5d77 100644
--- a/src/misc/vec/vecPtr.h
+++ b/src/misc/vec/vecPtr.h
@@ -455,6 +455,7 @@ static inline void Vec_PtrGrow( Vec_Ptr_t * p, int nCapMin )
 {
     if ( p->nCap >= nCapMin )
         return;
+    assert( p->nCap < ABC_INT_MAX );
     p->pArray = ABC_REALLOC( void *, p->pArray, nCapMin ); 
     p->nCap   = nCapMin;
 }
@@ -506,7 +507,7 @@ static inline void Vec_PtrFillExtra( Vec_Ptr_t * p, int nSize, void * Fill )
     if ( nSize > 2 * p->nCap )
         Vec_PtrGrow( p, nSize );
     else if ( nSize > p->nCap )
-        Vec_PtrGrow( p, 2 * p->nCap );
+        Vec_PtrGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     for ( i = p->nSize; i < nSize; i++ )
         p->pArray[i] = Fill;
     p->nSize = nSize;
@@ -682,7 +683,7 @@ static inline void Vec_PtrPush( Vec_Ptr_t * p, void * Entry )
         if ( p->nCap < 16 )
             Vec_PtrGrow( p, 16 );
         else
-            Vec_PtrGrow( p, 2 * p->nCap );
+            Vec_PtrGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->pArray[p->nSize++] = Entry;
 }
@@ -717,7 +718,7 @@ static inline void Vec_PtrPushFirst( Vec_Ptr_t * p, void * Entry )
         if ( p->nCap < 16 )
             Vec_PtrGrow( p, 16 );
         else
-            Vec_PtrGrow( p, 2 * p->nCap );
+            Vec_PtrGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->nSize++;
     for ( i = p->nSize - 1; i >= 1; i-- )
diff --git a/src/misc/vec/vecQue.h b/src/misc/vec/vecQue.h
index 6a8a68d05..a367537fd 100644
--- a/src/misc/vec/vecQue.h
+++ b/src/misc/vec/vecQue.h
@@ -101,6 +101,7 @@ static inline void Vec_QueGrow( Vec_Que_t * p, int nCapMin )
 {
     if ( p->nCap >= nCapMin )
         return;
+    assert( p->nCap < ABC_INT_MAX );
     p->pHeap  = ABC_REALLOC( int, p->pHeap,  nCapMin );
     p->pOrder = ABC_REALLOC( int, p->pOrder, nCapMin ); 
     memset( p->pHeap  + p->nCap, 0xff, (size_t)(nCapMin - p->nCap) * sizeof(int) );
@@ -225,9 +226,9 @@ static inline int Vec_QueIsMember( Vec_Que_t * p, int v )
 static inline void Vec_QuePush( Vec_Que_t * p, int v )
 {
     if ( p->nSize >= p->nCap )
-        Vec_QueGrow( p, Abc_MaxInt(p->nSize+1, 2*p->nCap) );
+        Vec_QueGrow( p, Abc_MaxInt(p->nSize+1, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX) );
     if ( v >= p->nCap )
-        Vec_QueGrow( p, Abc_MaxInt(v+1, 2*p->nCap) );
+        Vec_QueGrow( p, Abc_MaxInt(v+1, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX) );
     assert( p->nSize < p->nCap );
     assert( p->pOrder[v] == -1 );
     assert( p->pHeap[p->nSize] == -1 );
diff --git a/src/misc/vec/vecStr.h b/src/misc/vec/vecStr.h
index 16e157619..cf0d272a7 100644
--- a/src/misc/vec/vecStr.h
+++ b/src/misc/vec/vecStr.h
@@ -423,6 +423,7 @@ static inline void Vec_StrGrow( Vec_Str_t * p, int nCapMin )
 {
     if ( p->nCap >= nCapMin )
         return;
+    assert( p->nCap < ABC_INT_MAX );
     p->pArray = ABC_REALLOC( char, p->pArray, nCapMin ); 
     p->nCap   = nCapMin;
 }
@@ -466,7 +467,7 @@ static inline void Vec_StrFillExtra( Vec_Str_t * p, int nSize, char Fill )
     if ( nSize > 2 * p->nCap )
         Vec_StrGrow( p, nSize );
     else if ( nSize > p->nCap )
-        Vec_StrGrow( p, 2 * p->nCap );
+        Vec_StrGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     for ( i = p->nSize; i < nSize; i++ )
         p->pArray[i] = Fill;
     p->nSize = nSize;
@@ -557,7 +558,7 @@ static inline void Vec_StrPush( Vec_Str_t * p, char Entry )
         if ( p->nCap < 16 )
             Vec_StrGrow( p, 16 );
         else
-            Vec_StrGrow( p, 2 * p->nCap );
+            Vec_StrGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->pArray[p->nSize++] = Entry;
 }
diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index 5bfee43fb..88a08a576 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -221,6 +221,37 @@ static inline Vec_Wrd_t * Vec_WrdStartTruthTablesRev( int nVars )
     }
     return p;
 }
+static inline Vec_Wrd_t * Vec_WrdStartTruthTables6( int nVars )
+{
+    word Masks[6] = {     
+        ABC_CONST(0xAAAAAAAAAAAAAAAA),
+        ABC_CONST(0xCCCCCCCCCCCCCCCC),
+        ABC_CONST(0xF0F0F0F0F0F0F0F0),
+        ABC_CONST(0xFF00FF00FF00FF00),
+        ABC_CONST(0xFFFF0000FFFF0000),
+        ABC_CONST(0xFFFFFFFF00000000)
+    };
+    int i, k, nWords = nVars <= 6 ? 1 : (1 << (nVars - 6));
+    Vec_Wrd_t * p = Vec_WrdStart( nWords * nVars );
+    for ( i = 0; i < nVars; i++ )
+    {
+        word * pTruth = p->pArray + nWords * i;
+        if ( i < 6 )
+        {
+            for ( k = 0; k < nWords; k++ )
+                pTruth[k] = Masks[i];
+        }
+        else
+        {
+            for ( k = 0; k < nWords; k++ )
+                if ( k & (1 << (i-6)) )
+                    pTruth[k] = ~(word)0;
+                else
+                    pTruth[k] = 0;
+        }
+    }
+    return p;
+}
 static inline int Vec_WrdShiftOne( Vec_Wrd_t * p, int nWords )
 {
     int i, nObjs = p->nSize/nWords;
@@ -553,6 +584,7 @@ static inline void Vec_WrdGrow( Vec_Wrd_t * p, int nCapMin )
 {
     if ( p->nCap >= nCapMin )
         return;
+    assert( p->nCap < ABC_INT_MAX );
     p->pArray = ABC_REALLOC( word, p->pArray, nCapMin ); 
     assert( p->pArray );
     p->nCap   = nCapMin;
@@ -597,7 +629,7 @@ static inline void Vec_WrdFillExtra( Vec_Wrd_t * p, int nSize, word Fill )
     if ( nSize > 2 * p->nCap )
         Vec_WrdGrow( p, nSize );
     else if ( nSize > p->nCap )
-        Vec_WrdGrow( p, 2 * p->nCap );
+        Vec_WrdGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     for ( i = p->nSize; i < nSize; i++ )
         p->pArray[i] = Fill;
     p->nSize = nSize;
@@ -705,7 +737,7 @@ static inline void Vec_WrdPush( Vec_Wrd_t * p, word Entry )
         if ( p->nCap < 16 )
             Vec_WrdGrow( p, 16 );
         else
-            Vec_WrdGrow( p, 2 * p->nCap );
+            Vec_WrdGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->pArray[p->nSize++] = Entry;
 }
@@ -753,7 +785,7 @@ static inline void Vec_WrdPushFirst( Vec_Wrd_t * p, word Entry )
         if ( p->nCap < 16 )
             Vec_WrdGrow( p, 16 );
         else
-            Vec_WrdGrow( p, 2 * p->nCap );
+            Vec_WrdGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->nSize++;
     for ( i = p->nSize - 1; i >= 1; i-- )
@@ -780,7 +812,7 @@ static inline void Vec_WrdPushOrder( Vec_Wrd_t * p, word Entry )
         if ( p->nCap < 16 )
             Vec_WrdGrow( p, 16 );
         else
-            Vec_WrdGrow( p, 2 * p->nCap );
+            Vec_WrdGrow( p, p->nCap < ABC_INT_MAX/2 ? 2 * p->nCap : ABC_INT_MAX );
     }
     p->nSize++;
     for ( i = p->nSize-2; i >= 0; i-- )
diff --git a/src/opt/dau/dauGia.c b/src/opt/dau/dauGia.c
index eebfa9a8d..a49a253cd 100644
--- a/src/opt/dau/dauGia.c
+++ b/src/opt/dau/dauGia.c
@@ -444,7 +444,7 @@ int Dsm_ManTruthToGia( void * p, word * pTruth, Vec_Int_t * vLeaves, Vec_Int_t *
     int fDelayBalance = 1;
     Gia_Man_t * pGia = (Gia_Man_t *)p;
     int nSizeNonDec;
-    char pDsd[1000];
+    char pDsd[DAU_MAX_STR];
     word pTruthCopy[DAU_MAX_WORD];
     Abc_TtCopy( pTruthCopy, pTruth, Abc_TtWordNum(Vec_IntSize(vLeaves)), 0 );
     m_Calls++;
diff --git a/src/opt/dau/dauMerge.c b/src/opt/dau/dauMerge.c
index 0fbd126be..e4f7bedcc 100644
--- a/src/opt/dau/dauMerge.c
+++ b/src/opt/dau/dauMerge.c
@@ -560,7 +560,7 @@ void Dau_DsdRemoveBraces( char * pDsd, int * pMatches )
     for ( q = p; *p; p++ )
         if ( *p != ' ' )
         {
-            if ( *p == '!' && *(q-1) == '!' && p != q )
+            if ( *p == '!' && p != q && *(q-1) == '!' )
             {
                 q--;
                 continue;
diff --git a/src/opt/mfs/mfsCore_.c b/src/opt/mfs/mfsCore_.c
deleted file mode 100644
index 38e407bc3..000000000
--- a/src/opt/mfs/mfsCore_.c
+++ /dev/null
@@ -1,394 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mfsCore.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [The good old minimization with complete don't-cares.]
-
-  Synopsis    [Core procedures of this package.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: mfsCore.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "mfsInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Abc_NtkMfsParsDefault( Mfs_Par_t * pPars )
-{
-    memset( pPars, 0, sizeof(Mfs_Par_t) );
-    pPars->nWinTfoLevs  =    2;
-    pPars->nFanoutsMax  =   10;
-    pPars->nDepthMax    =   20;
-    pPars->nWinSizeMax  =  300;
-    pPars->nGrowthLevel =    0;
-    pPars->nBTLimit     = 5000;
-    pPars->fResub       =    1;
-    pPars->fArea        =    0;
-    pPars->fMoreEffort  =    0;
-    pPars->fSwapEdge    =    0;
-    pPars->fOneHotness  =    0;
-    pPars->fVerbose     =    0;
-    pPars->fVeryVerbose =    0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsResub( Mfs_Man_t * p, Abc_Obj_t * pNode )
-{
-    clock_t clk;
-    p->nNodesTried++;
-    // prepare data structure for this node
-    Mfs_ManClean( p ); 
-    // compute window roots, window support, and window nodes
-clk = clock();
-    p->vRoots = Abc_MfsComputeRoots( pNode, p->pPars->nWinTfoLevs, p->pPars->nFanoutsMax );
-    p->vSupp  = Abc_NtkNodeSupport( p->pNtk, (Abc_Obj_t **)Vec_PtrArray(p->vRoots), Vec_PtrSize(p->vRoots) );
-    p->vNodes = Abc_NtkDfsNodes( p->pNtk, (Abc_Obj_t **)Vec_PtrArray(p->vRoots), Vec_PtrSize(p->vRoots) );
-p->timeWin += clock() - clk;
-    if ( p->pPars->nWinSizeMax && Vec_PtrSize(p->vNodes) > p->pPars->nWinSizeMax )
-        return 1;
-    // compute the divisors of the window
-clk = clock();
-    p->vDivs  = Abc_MfsComputeDivisors( p, pNode, Abc_ObjRequiredLevel(pNode) - 1 );
-    p->nTotalDivs += Vec_PtrSize(p->vDivs) - Abc_ObjFaninNum(pNode);
-p->timeDiv += clock() - clk;
-    // construct AIG for the window
-clk = clock();
-    p->pAigWin = Abc_NtkConstructAig( p, pNode );
-p->timeAig += clock() - clk;
-    // translate it into CNF
-clk = clock();
-    p->pCnf = Cnf_DeriveSimple( p->pAigWin, 1 + Vec_PtrSize(p->vDivs) );
-p->timeCnf += clock() - clk;
-    // create the SAT problem
-clk = clock();
-    p->pSat = Abc_MfsCreateSolverResub( p, NULL, 0, 0 );
-    if ( p->pSat == NULL )
-    {
-        p->nNodesBad++;
-        return 1;
-    }
-    // solve the SAT problem
-    if ( p->pPars->fPower )
-        Abc_NtkMfsEdgePower( p, pNode );
-    else if ( p->pPars->fSwapEdge )
-        Abc_NtkMfsEdgeSwapEval( p, pNode );
-    else
-    {
-        Abc_NtkMfsResubNode( p, pNode );
-        if ( p->pPars->fMoreEffort )
-            Abc_NtkMfsResubNode2( p, pNode );
-    }
-p->timeSat += clock() - clk;
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsNode( Mfs_Man_t * p, Abc_Obj_t * pNode )
-{
-    Hop_Obj_t * pObj;
-    int RetValue;
-    float dProb;
-    extern Hop_Obj_t * Abc_NodeIfNodeResyn( Bdc_Man_t * p, Hop_Man_t * pHop, Hop_Obj_t * pRoot, int nVars, Vec_Int_t * vTruth, unsigned * puCare, float dProb );
-
-    int nGain;
-    clock_t clk;
-    p->nNodesTried++;
-    // prepare data structure for this node
-    Mfs_ManClean( p );
-    // compute window roots, window support, and window nodes
-clk = clock();
-    p->vRoots = Abc_MfsComputeRoots( pNode, p->pPars->nWinTfoLevs, p->pPars->nFanoutsMax );
-    p->vSupp  = Abc_NtkNodeSupport( p->pNtk, (Abc_Obj_t **)Vec_PtrArray(p->vRoots), Vec_PtrSize(p->vRoots) );
-    p->vNodes = Abc_NtkDfsNodes( p->pNtk, (Abc_Obj_t **)Vec_PtrArray(p->vRoots), Vec_PtrSize(p->vRoots) );
-p->timeWin += clock() - clk;
-    // count the number of patterns
-//    p->dTotalRatios += Abc_NtkConstraintRatio( p, pNode );
-    // construct AIG for the window
-clk = clock();
-    p->pAigWin = Abc_NtkConstructAig( p, pNode );
-p->timeAig += clock() - clk;
-    // translate it into CNF
-clk = clock();
-    p->pCnf = Cnf_DeriveSimple( p->pAigWin, Abc_ObjFaninNum(pNode) );
-p->timeCnf += clock() - clk;
-    // create the SAT problem
-clk = clock();
-    p->pSat = Cnf_DataWriteIntoSolver( p->pCnf, 1, 0 );
-    if ( p->pSat && p->pPars->fOneHotness )
-        Abc_NtkAddOneHotness( p );
-    if ( p->pSat == NULL )
-        return 0;
-    // solve the SAT problem
-    RetValue = Abc_NtkMfsSolveSat( p, pNode );
-    p->nTotConfLevel += p->pSat->stats.conflicts;
-p->timeSat += clock() - clk;
-    if ( RetValue == 0 )
-    {
-        p->nTimeOutsLevel++;
-        p->nTimeOuts++;
-        return 0;
-    }
-    // minimize the local function of the node using bi-decomposition
-    assert( p->nFanins == Abc_ObjFaninNum(pNode) );
-    dProb = p->pPars->fPower? ((float *)p->vProbs->pArray)[pNode->Id] : -1.0;
-    pObj = Abc_NodeIfNodeResyn( p->pManDec, pNode->pNtk->pManFunc, pNode->pData, p->nFanins, p->vTruth, p->uCare, dProb );
-    nGain = Hop_DagSize(pNode->pData) - Hop_DagSize(pObj);
-    if ( nGain >= 0 )
-    {
-        p->nNodesDec++;
-        p->nNodesGained += nGain;
-        p->nNodesGainedLevel += nGain;
-        pNode->pData = pObj;    
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfs( Abc_Ntk_t * pNtk, Mfs_Par_t * pPars )
-{
-    extern Aig_Man_t * Abc_NtkToDar( Abc_Ntk_t * pNtk, int fExors, int fRegisters );
-
-    Bdc_Par_t Pars = {0}, * pDecPars = &Pars;
-    ProgressBar * pProgress;
-    Mfs_Man_t * p;
-    Abc_Obj_t * pObj;
-    Vec_Vec_t * vLevels;
-    Vec_Ptr_t * vNodes;
-    int i, k, nNodes, nFaninMax;
-    clock_t clk = clock(), clk2;
-    int nTotalNodesBeg = Abc_NtkNodeNum(pNtk);
-    int nTotalEdgesBeg = Abc_NtkGetTotalFanins(pNtk);
-
-    assert( Abc_NtkIsLogic(pNtk) );
-    nFaninMax = Abc_NtkGetFaninMax(pNtk);
-    if ( pPars->fResub )
-    {
-        if ( nFaninMax > 8 )
-        {
-            printf( "Nodes with more than %d fanins will not be processed.\n", 8 );
-            nFaninMax = 8;
-        }
-    }
-    else
-    {
-        if ( nFaninMax > MFS_FANIN_MAX )
-        {
-            printf( "Nodes with more than %d fanins will not be processed.\n", MFS_FANIN_MAX );
-            nFaninMax = MFS_FANIN_MAX;
-        }
-    }
-    // perform the network sweep
-    Abc_NtkSweep( pNtk, 0 );
-    // convert into the AIG
-    if ( !Abc_NtkToAig(pNtk) )
-    {
-        fprintf( stdout, "Converting to AIGs has failed.\n" );
-        return 0;
-    }
-    assert( Abc_NtkHasAig(pNtk) );
-
-    // start the manager
-    p = Mfs_ManAlloc( pPars );
-    p->pNtk = pNtk;
-    p->nFaninMax = nFaninMax;
-
-    // precomputer power-aware metrics
-    if ( pPars->fPower )
-    {
-        extern Vec_Int_t * Abc_NtkPowerEstimate( Abc_Ntk_t * pNtk, int fProbOne );
-        if ( pPars->fResub )
-            p->vProbs = Abc_NtkPowerEstimate( pNtk, 0 );
-        else
-            p->vProbs = Abc_NtkPowerEstimate( pNtk, 1 );
-        printf( "Total switching before = %7.2f.\n", Abc_NtkMfsTotalSwitching(pNtk) );
-    }
-
-    if ( pNtk->pExcare )
-    {
-        Abc_Ntk_t * pTemp;
-        if ( Abc_NtkPiNum(pNtk->pExcare) != Abc_NtkCiNum(pNtk) )
-            printf( "The PI count of careset (%d) and logic network (%d) differ. Careset is not used.\n", 
-                Abc_NtkPiNum(pNtk->pExcare), Abc_NtkCiNum(pNtk) );
-        else
-        {
-            pTemp = Abc_NtkStrash( pNtk->pExcare, 0, 0, 0 );
-            p->pCare = Abc_NtkToDar( pTemp, 0, 0 );
-            Abc_NtkDelete( pTemp );
-            p->vSuppsInv = Aig_ManSupportsInverse( p->pCare );
-        }
-    }
-    if ( p->pCare != NULL )
-        printf( "Performing optimization with %d external care clauses.\n", Aig_ManPoNum(p->pCare) );
-    // prepare the BDC manager
-    if ( !pPars->fResub )
-    {
-        pDecPars->nVarsMax = (nFaninMax < 3) ? 3 : nFaninMax;
-        pDecPars->fVerbose = pPars->fVerbose;
-        p->vTruth = Vec_IntAlloc( 0 );
-        p->pManDec = Bdc_ManAlloc( pDecPars );
-    }
-
-    // label the register outputs
-    if ( p->pCare )
-    {
-        Abc_NtkForEachCi( pNtk, pObj, i )
-            pObj->pData = (void *)(PORT_PTRUINT_T)i;
-    }
- 
-    // compute levels
-    Abc_NtkLevel( pNtk );
-    Abc_NtkStartReverseLevels( pNtk, pPars->nGrowthLevel );
-
-    // compute don't-cares for each node
-    nNodes = 0;
-    p->nTotalNodesBeg = nTotalNodesBeg;
-    p->nTotalEdgesBeg = nTotalEdgesBeg;
-    if ( pPars->fResub )
-    {
-        pProgress = Extra_ProgressBarStart( stdout, Abc_NtkObjNumMax(pNtk) );
-        Abc_NtkForEachNode( pNtk, pObj, i )
-        {
-            if ( p->pPars->nDepthMax && (int)pObj->Level > p->pPars->nDepthMax )
-                continue;
-            if ( Abc_ObjFaninNum(pObj) < 2 || Abc_ObjFaninNum(pObj) > nFaninMax )
-                continue;
-            if ( !p->pPars->fVeryVerbose )
-                Extra_ProgressBarUpdate( pProgress, i, NULL );
-            if ( pPars->fResub )
-                Abc_NtkMfsResub( p, pObj );
-            else
-                Abc_NtkMfsNode( p, pObj );
-        }
-        Extra_ProgressBarStop( pProgress );
-    }
-    else
-    {
-        pProgress = Extra_ProgressBarStart( stdout, Abc_NtkNodeNum(pNtk) );
-        vLevels = Abc_NtkLevelize( pNtk );
-        Vec_VecForEachLevelStart( vLevels, vNodes, k, 1 )
-        {
-            if ( !p->pPars->fVeryVerbose )
-                Extra_ProgressBarUpdate( pProgress, nNodes, NULL );
-            p->nNodesGainedLevel = 0;
-            p->nTotConfLevel = 0;
-            p->nTimeOutsLevel = 0;
-            clk2 = clock();
-            Vec_PtrForEachEntry( vNodes, pObj, i )
-            {
-                if ( p->pPars->nDepthMax && (int)pObj->Level > p->pPars->nDepthMax )
-                    break;
-                if ( Abc_ObjFaninNum(pObj) < 2 || Abc_ObjFaninNum(pObj) > nFaninMax )
-                    continue;
-                if ( pPars->fResub )
-                    Abc_NtkMfsResub( p, pObj );
-                else 
-                    Abc_NtkMfsNode( p, pObj );
-            }
-            nNodes += Vec_PtrSize(vNodes);
-            if ( pPars->fVerbose )
-            {
-            printf( "Lev = %2d. Node = %5d. Ave gain = %5.2f. Ave conf = %5.2f. T/o = %6.2f %%  ", 
-                k, Vec_PtrSize(vNodes),
-                1.0*p->nNodesGainedLevel/Vec_PtrSize(vNodes),
-                1.0*p->nTotConfLevel/Vec_PtrSize(vNodes),
-                100.0*p->nTimeOutsLevel/Vec_PtrSize(vNodes) );
-            PRT( "Time", clock() - clk2 );
-            }
-        }
-        Extra_ProgressBarStop( pProgress );
-        Vec_VecFree( vLevels );
-    }
-    Abc_NtkStopReverseLevels( pNtk );
-
-    // perform the sweeping
-    if ( !pPars->fResub )
-    {
-        extern void Abc_NtkBidecResyn( Abc_Ntk_t * pNtk, int fVerbose );
-//        Abc_NtkSweep( pNtk, 0 );
-//        Abc_NtkBidecResyn( pNtk, 0 );
-    }
-
-    p->nTotalNodesEnd = Abc_NtkNodeNum(pNtk);
-    p->nTotalEdgesEnd = Abc_NtkGetTotalFanins(pNtk);
-
-    // undo labesl
-    if ( p->pCare )
-    {
-        Abc_NtkForEachCi( pNtk, pObj, i )
-            pObj->pData = NULL;
-    }
-    if ( pPars->fPower )
-        printf( "Total switching after  = %7.2f.\n", Abc_NtkMfsTotalSwitching(pNtk) );
-
-    // free the manager
-    p->timeTotal = clock() - clk;
-    Mfs_ManStop( p );
-    return 1;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/opt/mfs/mfsResub_.c b/src/opt/mfs/mfsResub_.c
deleted file mode 100644
index b79ccd9e5..000000000
--- a/src/opt/mfs/mfsResub_.c
+++ /dev/null
@@ -1,567 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mfsResub.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [The good old minimization with complete don't-cares.]
-
-  Synopsis    [Procedures to perform resubstitution.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: mfsResub.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "mfsInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Updates the network after resubstitution.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Abc_NtkMfsUpdateNetwork( Mfs_Man_t * p, Abc_Obj_t * pObj, Vec_Ptr_t * vFanins, Hop_Obj_t * pFunc )
-{
-    Abc_Obj_t * pObjNew, * pFanin;
-    int k;
-    // create the new node
-    pObjNew = Abc_NtkCreateNode( pObj->pNtk );
-    pObjNew->pData = pFunc;
-    Vec_PtrForEachEntry( vFanins, pFanin, k )
-        Abc_ObjAddFanin( pObjNew, pFanin );
-    // replace the old node by the new node
-//printf( "Replacing node " ); Abc_ObjPrint( stdout, pObj );
-//printf( "Inserting node " ); Abc_ObjPrint( stdout, pObjNew );
-    // update the level of the node
-    Abc_NtkUpdate( pObj, pObjNew, p->vLevels );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints resub candidate stats.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Abc_NtkMfsPrintResubStats( Mfs_Man_t * p )
-{
-    Abc_Obj_t * pFanin, * pNode;
-    int i, k, nAreaCrits = 0, nAreaExpanse = 0;
-    int nFaninMax = Abc_NtkGetFaninMax(p->pNtk);
-    Abc_NtkForEachNode( p->pNtk, pNode, i )
-        Abc_ObjForEachFanin( pNode, pFanin, k )
-        {
-            if ( !Abc_ObjIsCi(pFanin) && Abc_ObjFanoutNum(pFanin) == 1 )
-            {
-                nAreaCrits++;
-                nAreaExpanse += (int)(Abc_ObjFaninNum(pNode) < nFaninMax);
-            }
-        }
-    printf( "Total area-critical fanins = %d. Belonging to expandable nodes = %d.\n", 
-        nAreaCrits, nAreaExpanse );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Tries resubstitution.]
-
-  Description [Returns 1 if it is feasible, or 0 if c-ex is found.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsTryResubOnce( Mfs_Man_t * p, int * pCands, int nCands )
-{
-    unsigned * pData;
-    int RetValue, iVar, i;
-    p->nSatCalls++;
-    RetValue = sat_solver_solve( p->pSat, pCands, pCands + nCands, (sint64)p->pPars->nBTLimit, (sint64)0, (sint64)0, (sint64)0 );
-//    assert( RetValue == l_False || RetValue == l_True );
-    if ( RetValue == l_False )
-        return 1;
-    if ( RetValue != l_True )
-    {
-        p->nTimeOuts++;
-        return -1;
-    }
-    p->nSatCexes++;
-    // store the counter-example
-    Vec_IntForEachEntry( p->vProjVars, iVar, i )
-    {
-        pData = Vec_PtrEntry( p->vDivCexes, i );
-        if ( !sat_solver_var_value( p->pSat, iVar ) ) // remove 0s!!!
-        {
-            assert( Aig_InfoHasBit(pData, p->nCexes) );
-            Aig_InfoXorBit( pData, p->nCexes );
-        }
-    }
-    p->nCexes++;
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs resubstitution for the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsSolveSatResub( Mfs_Man_t * p, Abc_Obj_t * pNode, int iFanin, int fOnlyRemove, int fSkipUpdate )
-{
-    int fVeryVerbose = p->pPars->fVeryVerbose && Vec_PtrSize(p->vDivs) < 80;
-    unsigned * pData;
-    int pCands[MFS_FANIN_MAX];
-    int RetValue, iVar, i, nCands, nWords, w;
-    clock_t clk;
-    Abc_Obj_t * pFanin;
-    Hop_Obj_t * pFunc;
-    assert( iFanin >= 0 );
-
-    // clean simulation info
-    Vec_PtrFillSimInfo( p->vDivCexes, 0, p->nDivWords ); 
-    p->nCexes = 0;
-    if ( fVeryVerbose )
-    {
-        printf( "\n" );
-        printf( "Node %5d : Level = %2d. Divs = %3d.  Fanin = %d (out of %d). MFFC = %d\n", 
-            pNode->Id, pNode->Level, Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode), 
-            iFanin, Abc_ObjFaninNum(pNode), 
-            Abc_ObjFanoutNum(Abc_ObjFanin(pNode, iFanin)) == 1 ? Abc_NodeMffcLabel(Abc_ObjFanin(pNode, iFanin)) : 0 );
-    }
-
-    // try fanins without the critical fanin
-    nCands = 0;
-    Vec_PtrClear( p->vFanins );
-    Abc_ObjForEachFanin( pNode, pFanin, i )
-    {
-        if ( i == iFanin )
-            continue;
-        Vec_PtrPush( p->vFanins, pFanin );
-        iVar = Vec_PtrSize(p->vDivs) - Abc_ObjFaninNum(pNode) + i;
-        pCands[nCands++] = toLitCond( Vec_IntEntry( p->vProjVars, iVar ), 1 );
-    }
-    RetValue = Abc_NtkMfsTryResubOnce( p, pCands, nCands );
-    if ( RetValue == -1 )
-        return 0;
-    if ( RetValue == 1 )
-    {
-        if ( fVeryVerbose )
-        printf( "Node %d: Fanin %d can be removed.\n", pNode->Id, iFanin );
-        p->nNodesResub++;
-        p->nNodesGainedLevel++;
-        if ( fSkipUpdate )
-            return 1;
-clk = clock();
-        // derive the function
-        pFunc = Abc_NtkMfsInterplate( p, pCands, nCands );
-        if ( pFunc == NULL )
-            return 0;
-        // update the network
-        Abc_NtkMfsUpdateNetwork( p, pNode, p->vFanins, pFunc );
-p->timeInt += clock() - clk;
-        return 1;
-    }
-
-    if ( fOnlyRemove )
-        return 0;
-
-    if ( fVeryVerbose )
-    {
-        for ( i = 0; i < 8; i++ )
-            printf( " " );
-        for ( i = 0; i < Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode); i++ )
-            printf( "%d", i % 10 );
-        for ( i = 0; i < Abc_ObjFaninNum(pNode); i++ )
-            if ( i == iFanin )
-                printf( "*" );
-            else
-                printf( "%c", 'a' + i );
-        printf( "\n" );
-    }
-    iVar = -1;
-    while ( 1 )
-    {
-        float * pProbab = (float *)(p->vProbs? p->vProbs->pArray : NULL);
-        assert( (pProbab != NULL) == p->pPars->fPower );
-        if ( fVeryVerbose )
-        {
-            printf( "%3d: %2d ", p->nCexes, iVar );
-            for ( i = 0; i < Vec_PtrSize(p->vDivs); i++ )
-            {
-                pData = Vec_PtrEntry( p->vDivCexes, i );
-                printf( "%d", Aig_InfoHasBit(pData, p->nCexes-1) );
-            }
-            printf( "\n" );
-        }
-
-        // find the next divisor to try
-        nWords = Aig_BitWordNum(p->nCexes);
-        assert( nWords <= p->nDivWords );
-        for ( iVar = 0; iVar < Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode); iVar++ )
-        {
-            if ( p->pPars->fPower )
-            {
-                Abc_Obj_t * pDiv = Vec_PtrEntry(p->vDivs, iVar);
-                // only accept the divisor if it is "cool"
-                if ( pProbab[Abc_ObjId(pDiv)] >= 0.2 )
-                    continue;
-            }
-            pData  = Vec_PtrEntry( p->vDivCexes, iVar );
-            for ( w = 0; w < nWords; w++ )
-                if ( pData[w] != ~0 )
-                    break;
-            if ( w == nWords )
-                break;
-        }
-        if ( iVar == Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode) )
-            return 0;
-
-        pCands[nCands] = toLitCond( Vec_IntEntry(p->vProjVars, iVar), 1 );
-        RetValue = Abc_NtkMfsTryResubOnce( p, pCands, nCands+1 );
-        if ( RetValue == -1 )
-            return 0;
-        if ( RetValue == 1 )
-        {
-            if ( fVeryVerbose )
-            printf( "Node %d: Fanin %d can be replaced by divisor %d.\n", pNode->Id, iFanin, iVar );
-            p->nNodesResub++;
-            p->nNodesGainedLevel++;
-            if ( fSkipUpdate )
-                return 1;
-clk = clock();
-            // derive the function
-            pFunc = Abc_NtkMfsInterplate( p, pCands, nCands+1 );
-            if ( pFunc == NULL )
-                return 0;
-            // update the network
-            Vec_PtrPush( p->vFanins, Vec_PtrEntry(p->vDivs, iVar) );
-            Abc_NtkMfsUpdateNetwork( p, pNode, p->vFanins, pFunc );
-p->timeInt += clock() - clk;
-            return 1;
-        }
-        if ( p->nCexes >= p->pPars->nDivMax )
-            break;
-    }
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs resubstitution for the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsSolveSatResub2( Mfs_Man_t * p, Abc_Obj_t * pNode, int iFanin, int iFanin2 )
-{
-    int fVeryVerbose = p->pPars->fVeryVerbose && Vec_PtrSize(p->vDivs) < 80;
-    unsigned * pData, * pData2;
-    int pCands[MFS_FANIN_MAX];
-    int RetValue, iVar, iVar2, i, w, nCands, nWords, fBreak;
-    clock_t clk;
-    Abc_Obj_t * pFanin;
-    Hop_Obj_t * pFunc;
-    assert( iFanin >= 0 );
-    assert( iFanin2 >= 0 || iFanin2 == -1 );
-
-    // clean simulation info
-    Vec_PtrFillSimInfo( p->vDivCexes, 0, p->nDivWords ); 
-    p->nCexes = 0;
-    if ( fVeryVerbose )
-    {
-        printf( "\n" );
-        printf( "Node %5d : Level = %2d. Divs = %3d.  Fanins = %d/%d (out of %d). MFFC = %d\n", 
-            pNode->Id, pNode->Level, Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode), 
-            iFanin, iFanin2, Abc_ObjFaninNum(pNode), 
-            Abc_ObjFanoutNum(Abc_ObjFanin(pNode, iFanin)) == 1 ? Abc_NodeMffcLabel(Abc_ObjFanin(pNode, iFanin)) : 0 );
-    }
-
-    // try fanins without the critical fanin
-    nCands = 0;
-    Vec_PtrClear( p->vFanins );
-    Abc_ObjForEachFanin( pNode, pFanin, i )
-    {
-        if ( i == iFanin || i == iFanin2 )
-            continue;
-        Vec_PtrPush( p->vFanins, pFanin );
-        iVar = Vec_PtrSize(p->vDivs) - Abc_ObjFaninNum(pNode) + i;
-        pCands[nCands++] = toLitCond( Vec_IntEntry( p->vProjVars, iVar ), 1 );
-    }
-    RetValue = Abc_NtkMfsTryResubOnce( p, pCands, nCands );
-    if ( RetValue == -1 )
-        return 0;
-    if ( RetValue == 1 )
-    {
-        if ( fVeryVerbose )
-        printf( "Node %d: Fanins %d/%d can be removed.\n", pNode->Id, iFanin, iFanin2 );
-        p->nNodesResub++;
-        p->nNodesGainedLevel++;
-clk = clock();
-        // derive the function
-        pFunc = Abc_NtkMfsInterplate( p, pCands, nCands );
-        if ( pFunc == NULL )
-            return 0;
-        // update the network
-        Abc_NtkMfsUpdateNetwork( p, pNode, p->vFanins, pFunc );
-p->timeInt += clock() - clk;
-        return 1;
-    }
-
-    if ( fVeryVerbose )
-    {
-        for ( i = 0; i < 11; i++ )
-            printf( " " );
-        for ( i = 0; i < Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode); i++ )
-            printf( "%d", i % 10 );
-        for ( i = 0; i < Abc_ObjFaninNum(pNode); i++ )
-            if ( i == iFanin || i == iFanin2 )
-                printf( "*" );
-            else
-                printf( "%c", 'a' + i );
-        printf( "\n" );
-    }
-    iVar = iVar2 = -1;
-    while ( 1 )
-    {
-        if ( fVeryVerbose )
-        {
-            printf( "%3d: %2d %2d ", p->nCexes, iVar, iVar2 );
-            for ( i = 0; i < Vec_PtrSize(p->vDivs); i++ )
-            {
-                pData = Vec_PtrEntry( p->vDivCexes, i );
-                printf( "%d", Aig_InfoHasBit(pData, p->nCexes-1) );
-            }
-            printf( "\n" );
-        }
-
-        // find the next divisor to try
-        nWords = Aig_BitWordNum(p->nCexes);
-        assert( nWords <= p->nDivWords );
-        fBreak = 0;
-        for ( iVar = 1; iVar < Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode); iVar++ )
-        {
-            pData  = Vec_PtrEntry( p->vDivCexes, iVar );
-            for ( iVar2 = 0; iVar2 < iVar; iVar2++ )
-            {
-                pData2 = Vec_PtrEntry( p->vDivCexes, iVar2 );
-                for ( w = 0; w < nWords; w++ )
-                    if ( (pData[w] | pData2[w]) != ~0 )
-                        break;
-                if ( w == nWords )
-                {
-                    fBreak = 1;
-                    break;
-                }
-            }
-            if ( fBreak )
-                break;
-        }
-        if ( iVar == Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode) )
-            return 0;
-
-        pCands[nCands]   = toLitCond( Vec_IntEntry(p->vProjVars, iVar2), 1 );
-        pCands[nCands+1] = toLitCond( Vec_IntEntry(p->vProjVars, iVar), 1 );
-        RetValue = Abc_NtkMfsTryResubOnce( p, pCands, nCands+2 );
-        if ( RetValue == -1 )
-            return 0;
-        if ( RetValue == 1 )
-        {
-            if ( fVeryVerbose )
-            printf( "Node %d: Fanins %d/%d can be replaced by divisors %d/%d.\n", pNode->Id, iFanin, iFanin2, iVar, iVar2 );
-            p->nNodesResub++;
-            p->nNodesGainedLevel++;
-clk = clock();
-            // derive the function
-            pFunc = Abc_NtkMfsInterplate( p, pCands, nCands+2 );
-            if ( pFunc == NULL )
-                return 0;
-            // update the network
-            Vec_PtrPush( p->vFanins, Vec_PtrEntry(p->vDivs, iVar2) );
-            Vec_PtrPush( p->vFanins, Vec_PtrEntry(p->vDivs, iVar) );
-            assert( Vec_PtrSize(p->vFanins) == nCands + 2 );
-            Abc_NtkMfsUpdateNetwork( p, pNode, p->vFanins, pFunc );
-p->timeInt += clock() - clk;
-            return 1;
-        }
-        if ( p->nCexes >= p->pPars->nDivMax )
-            break;
-    }
-    return 0;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Evaluates the possibility of replacing given edge by another edge.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsEdgeSwapEval( Mfs_Man_t * p, Abc_Obj_t * pNode )
-{
-    Abc_Obj_t * pFanin;
-    int i;
-    Abc_ObjForEachFanin( pNode, pFanin, i )
-        Abc_NtkMfsSolveSatResub( p, pNode, i, 0, 1 );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Evaluates the possibility of replacing given edge by another edge.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsEdgePower( Mfs_Man_t * p, Abc_Obj_t * pNode )
-{
-    Abc_Obj_t * pFanin;
-    float * pProbab = (float *)p->vProbs->pArray;
-    int i;
-    // try replacing area critical fanins
-    Abc_ObjForEachFanin( pNode, pFanin, i )
-        if ( pProbab[pFanin->Id] >= 0.4 )
-        {
-            if ( Abc_NtkMfsSolveSatResub( p, pNode, i, 0, 0 ) )
-                return 1;
-        }
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs resubstitution for the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsResubNode( Mfs_Man_t * p, Abc_Obj_t * pNode )
-{
-    Abc_Obj_t * pFanin;
-    int i;
-    // try replacing area critical fanins
-    Abc_ObjForEachFanin( pNode, pFanin, i )
-        if ( !Abc_ObjIsCi(pFanin) && Abc_ObjFanoutNum(pFanin) == 1 )
-        {
-            if ( Abc_NtkMfsSolveSatResub( p, pNode, i, 0, 0 ) )
-                return 1;
-        }
-    // try removing redundant edges
-    if ( !p->pPars->fArea )
-    {
-        Abc_ObjForEachFanin( pNode, pFanin, i )
-            if ( Abc_ObjIsCi(pFanin) || Abc_ObjFanoutNum(pFanin) != 1 )
-            {
-                if ( Abc_NtkMfsSolveSatResub( p, pNode, i, 1, 0 ) )
-                    return 1;
-            }
-    }
-    if ( Abc_ObjFaninNum(pNode) == p->nFaninMax )
-        return 0;
-    // try replacing area critical fanins while adding two new fanins
-    Abc_ObjForEachFanin( pNode, pFanin, i )
-        if ( !Abc_ObjIsCi(pFanin) && Abc_ObjFanoutNum(pFanin) == 1 )
-        {
-            if ( Abc_NtkMfsSolveSatResub2( p, pNode, i, -1 ) )
-                return 1;
-        }
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs resubstitution for the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NtkMfsResubNode2( Mfs_Man_t * p, Abc_Obj_t * pNode )
-{
-    Abc_Obj_t * pFanin, * pFanin2;
-    int i, k;
-/*
-    Abc_ObjForEachFanin( pNode, pFanin, i )
-        if ( !Abc_ObjIsCi(pFanin) && Abc_ObjFanoutNum(pFanin) == 1 )
-        {
-            if ( Abc_NtkMfsSolveSatResub( p, pNode, i, 0, 0 ) )
-                return 1;
-        }
-*/
-    if ( Abc_ObjFaninNum(pNode) < 2 )
-        return 0;
-    // try replacing one area critical fanin and one other fanin while adding two new fanins
-    Abc_ObjForEachFanin( pNode, pFanin, i )
-    {
-        if ( !Abc_ObjIsCi(pFanin) && Abc_ObjFanoutNum(pFanin) == 1 )
-        {
-            // consider second fanin to remove at the same time
-            Abc_ObjForEachFanin( pNode, pFanin2, k )
-            {
-                if ( i != k && Abc_NtkMfsSolveSatResub2( p, pNode, i, k ) )
-                    return 1;
-            }
-        }
-    }
-    return 0;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/opt/rar/module.make b/src/opt/rar/module.make
new file mode 100644
index 000000000..47e910196
--- /dev/null
+++ b/src/opt/rar/module.make
@@ -0,0 +1,4 @@
+SRC += src/opt/rar/rewire_rng.c \
+       src/opt/rar/rewire_map.c \
+       src/opt/rar/rewire_rar.c \
+       src/opt/rar/rewire_miaig.cpp
\ No newline at end of file
diff --git a/src/opt/rar/rewire_map.c b/src/opt/rar/rewire_map.c
new file mode 100644
index 000000000..b5f164a03
--- /dev/null
+++ b/src/opt/rar/rewire_map.c
@@ -0,0 +1,65 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_map.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_map.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "rewire_map.h"
+
+ABC_NAMESPACE_IMPL_START
+
+extern Abc_Ntk_t *Abc_NtkFromAigPhase(Aig_Man_t *pMan);
+extern Abc_Ntk_t *Abc_NtkDarAmap(Abc_Ntk_t *pNtk, Amap_Par_t *pPars);
+extern void *Abc_FrameReadLibGen2();
+extern Vec_Int_t * Abc_NtkWriteMiniMapping( Abc_Ntk_t * pNtk );
+extern void Abc_NtkPrintMiniMapping( int * pArray );
+extern Abc_Ntk_t * Abc_NtkFromMiniMapping( int *vMapping );
+extern Mini_Aig_t * Abc_MiniAigFromNtk ( Abc_Ntk_t *pNtk );
+
+Abc_Ntk_t *Gia_ManRewirePut(Gia_Man_t *pGia) {
+    Aig_Man_t *pMan = Gia_ManToAig(pGia, 0);
+    Abc_Ntk_t *pNtk = Abc_NtkFromAigPhase(pMan);
+    Aig_ManStop(pMan);
+    return pNtk;
+}
+
+Abc_Ntk_t *Abc_ManRewireMap(Abc_Ntk_t *pNtk) {
+    Amap_Par_t Pars, *pPars = &Pars;
+    Amap_ManSetDefaultParams(pPars);
+    Abc_Ntk_t *pNtkMapped = Abc_NtkDarAmap(pNtk, pPars);
+    if (pNtkMapped == NULL) {
+        Abc_NtkDelete(pNtk);
+        Abc_Print(-1, "Mapping has failed.\n");
+        return NULL;
+    }
+
+    return pNtkMapped;
+}
+
+Vec_Int_t *Abc_ManRewireNtkWriteMiniMapping(Abc_Ntk_t *pNtk) {
+    return Abc_NtkWriteMiniMapping(pNtk);
+}
+
+Abc_Ntk_t *Abc_ManRewireNtkFromMiniMapping(int *vMapping) {
+    return Abc_NtkFromMiniMapping(vMapping);
+}
+
+Mini_Aig_t *Abc_ManRewireMiniAigFromNtk(Abc_Ntk_t *pNtk) {
+    return Abc_MiniAigFromNtk(pNtk);
+}
+
+ABC_NAMESPACE_IMPL_END
\ No newline at end of file
diff --git a/src/opt/rar/rewire_map.h b/src/opt/rar/rewire_map.h
new file mode 100644
index 000000000..aa4a00c61
--- /dev/null
+++ b/src/opt/rar/rewire_map.h
@@ -0,0 +1,40 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_map.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_map.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef REWIRE_MAP_H
+#define REWIRE_MAP_H
+
+#include "base/abc/abc.h"
+#include "aig/gia/giaAig.h"
+#include "map/amap/amap.h"
+#include "map/mio/mio.h"
+#include "aig/miniaig/miniaig.h"
+
+ABC_NAMESPACE_HEADER_START
+
+Abc_Ntk_t *Gia_ManRewirePut(Gia_Man_t *pGia);
+Abc_Ntk_t *Abc_ManRewireMap(Abc_Ntk_t *pNtk);
+Vec_Int_t *Abc_ManRewireNtkWriteMiniMapping(Abc_Ntk_t *pNtk);
+Abc_Ntk_t *Abc_ManRewireNtkFromMiniMapping(int *vMapping);
+Mini_Aig_t *Abc_ManRewireMiniAigFromNtk(Abc_Ntk_t *pNtk);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif // REWIRE_MAP_H
\ No newline at end of file
diff --git a/src/opt/rar/rewire_miaig.cpp b/src/opt/rar/rewire_miaig.cpp
new file mode 100644
index 000000000..cbab82645
--- /dev/null
+++ b/src/opt/rar/rewire_miaig.cpp
@@ -0,0 +1,1179 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_miaig.cpp]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_miaig.cpp,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "rewire_rar.h"
+#include "rewire_miaig.h"
+
+#ifdef RW_ABC
+ABC_NAMESPACE_IMPL_START
+#endif // RW_ABC
+
+#ifdef RW_ABC
+Gia_Man_t *Gia_ManRewireInt(Gia_Man_t *pGia, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose) {
+    Random_Num(nSeed);
+
+    Rewire::Miaig pNtkMiaig(pGia);
+    Rewire::Miaig pNew = pNtkMiaig.rewire(nIters, nExpands, nGrowth, nDivs, nFaninMax, nTimeOut, nMode, nDist, fVerbose);
+
+    return pNew.toGia();
+}
+
+Abc_Ntk_t *Abc_ManRewireInt(Abc_Ntk_t *pNtk, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose) {
+    Random_Num(nSeed);
+
+    Rewire::Miaig pNtkMiaig(pNtk);
+    Rewire::Miaig pNew = pNtkMiaig.rewire(nIters, nExpands, nGrowth, nDivs, nFaninMax, nTimeOut, nMode, nDist, fVerbose);
+
+    return pNew.toNtk(nMode);
+}
+
+Mini_Aig_t *MiniAig_ManRewireInt(Mini_Aig_t *pAig, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose) {
+    Random_Num(nSeed);
+
+    Rewire::Miaig pNtkMiaig(pAig);
+    Rewire::Miaig pNew = pNtkMiaig.rewire(nIters, nExpands, nGrowth, nDivs, nFaninMax, nTimeOut, nMode, nDist, fVerbose);
+
+    return pNew.toMiniAig();
+}
+#endif // RW_ABC
+
+namespace Rewire {
+
+void Miaig::create(int nIns, int nOuts, int nObjsAlloc) {
+    assert(1 + nIns + nOuts <= nObjsAlloc);
+    release();
+
+    _data = (Miaig_Data *)calloc(sizeof(Miaig_Data), 1);
+
+    if (_data) {
+        _data->nIns = nIns;
+        _data->nOuts = nOuts;
+        _data->nObjs = 1 + nIns; // const0 + nIns
+        _data->nObjsAlloc = nObjsAlloc;
+        _data->nWords = Tt_WordNum(nIns);
+        _data->nTravIds = 0;
+        _data->pTravIds = (int *)calloc(sizeof(int), _data->nObjsAlloc);
+        _data->pCopy = (int *)calloc(sizeof(int), _data->nObjsAlloc);
+        _data->pRefs = (int *)calloc(sizeof(int), _data->nObjsAlloc);
+        _data->vOrder = Vi_Alloc(1000);
+        _data->vOrderF = Vi_Alloc(1000);
+        _data->vOrderF2 = Vi_Alloc(1000);
+        _data->vTfo = Vi_Alloc(1000);
+        _data->pvFans = (vi *)calloc(sizeof(vi), _data->nObjsAlloc);
+        _data->pLevel = nullptr;
+        _data->pTable = nullptr;
+        _data->refcount = 1;
+        _refcount = &_data->refcount;
+    }
+}
+
+void Miaig::print(void) {
+    int i, k, iLit;
+    printf("\nAIG printout:\n");
+    printf("Const0\n");
+    Miaig_ForEachInput(i)
+        printf("Pi%d\n", i);
+    Miaig_ForEachNode(i) {
+        printf("Node%d {", i);
+        Miaig_ForEachObjFanin(i, iLit, k)
+            printf(" %d", iLit);
+        printf(" }\n");
+    }
+    Miaig_ForEachOutput(i) {
+        printf("Po%d ", i);
+        Miaig_ForEachObjFanin(i, iLit, k)
+            printf(" %d", iLit);
+        printf("\n");
+    }
+}
+
+#ifdef RW_ABC
+int Miaig::fromGia(Gia_Man_t *pGia) {
+    Gia_Obj_t *pObj;
+    int *pCopy = (int *)calloc(sizeof(int), Gia_ManObjNum(pGia)); // obj2obj
+    // printf("[INFO] Converting GIA into MIAIG\n");
+    // printf("[INFO] PI/PO/OBJ = %d/%d/%d\n", Gia_ManPiNum(pGia), Gia_ManPoNum(pGia), Gia_ManObjNum(pGia));
+    create(Gia_ManPiNum(pGia), Gia_ManPoNum(pGia), Gia_ManObjNum(pGia));
+    int i;
+    pCopy[0] = Gia_ObjId(pGia, Gia_ManConst0(pGia));
+    Miaig_ForEachInput(i) {
+        pCopy[i] = i;
+    }
+    Gia_ManForEachAnd(pGia, pObj, i) {
+        pCopy[i] = appendObj();
+        assert(pCopy[i] == i);
+        appendFanin(pCopy[i], Rw_Lit2LitV(pCopy, Gia_Obj2Lit(pGia, Gia_ObjChild1(pObj))));
+        appendFanin(pCopy[i], Rw_Lit2LitV(pCopy, Gia_Obj2Lit(pGia, Gia_ObjChild0(pObj))));
+    }
+    Gia_ManForEachPo(pGia, pObj, i)
+        appendFanin(appendObj(), Rw_Lit2LitV(pCopy, Gia_Obj2Lit(pGia, Gia_ObjChild0(pObj))));
+    free(pCopy);
+    return 1;
+}
+
+int Miaig::fromMiniAig(Mini_Aig_t *pMiniAig) {
+    int *pCopy = (int *)calloc(sizeof(int), Mini_AigNodeNum(pMiniAig)); // obj2obj
+    create(Mini_AigPiNum(pMiniAig), Mini_AigPoNum(pMiniAig), Mini_AigNodeNum(pMiniAig));
+    int i;
+    Miaig_ForEachInput(i)
+        pCopy[i] = i;  
+    Mini_AigForEachAnd( pMiniAig, i ) {
+        pCopy[i] = appendObj();
+        assert( pCopy[i] == i );
+        appendFanin(pCopy[i], Rw_Lit2LitV(pCopy, Mini_AigNodeFanin0(pMiniAig, i)));
+        appendFanin(pCopy[i], Rw_Lit2LitV(pCopy, Mini_AigNodeFanin1(pMiniAig, i)));
+    }
+    Mini_AigForEachPo( pMiniAig, i )
+        appendFanin(appendObj(), Rw_Lit2LitV(pCopy, Mini_AigNodeFanin0(pMiniAig, i)));
+    free(pCopy);
+    return 1;
+}
+
+Gia_Man_t *Miaig::toGia(void) {
+    int i, k, iLit, And2 = countAnd2();
+    Gia_Man_t *pGia = Gia_ManStart(1 + nIns() + And2 + nOuts()), *pTemp;
+    Gia_ManHashAlloc(pGia);
+    memset(_data->pCopy, 0, sizeof(int) * nObjs());
+    Miaig_ForEachInput(i)
+        objCopy(i) = Gia_ManAppendCi(pGia);
+    Miaig_ForEachNode(i) {
+        assert(objFaninNum(i) > 0);
+        Miaig_ForEachObjFanin(i, iLit, k) {
+            if (k == 0)
+                objCopy(i) = Rw_Lit2LitL(_data->pCopy, iLit);
+            else 
+                objCopy(i) = Gia_ManHashAnd(pGia, objCopy(i), Rw_Lit2LitL(_data->pCopy, iLit));
+        }
+    }
+    Miaig_ForEachOutput(i) {
+        assert(objFaninNum(i) == 1);
+        Miaig_ForEachObjFanin(i, iLit, k)
+            Gia_ManAppendCo(pGia, Rw_Lit2LitL(_data->pCopy, iLit));
+    }
+    // assert(Gia_ManObjNum(pGia) == (1 + nIns() + nOuts() + And2));
+    pGia = Gia_ManCleanup(pTemp = pGia);
+    Gia_ManStop(pTemp);
+    return pGia;
+}
+
+Mini_Aig_t *Miaig::toMiniAig(void) {
+    int i, k, iLit;
+    Mini_Aig_t * pMini = Mini_AigStart();
+    memset(_data->pCopy, 0, sizeof(int) * nObjs());
+    Miaig_ForEachInput(i)
+        objCopy(i) = Mini_AigCreatePi(pMini);
+    Miaig_ForEachNode(i) {
+        assert(objFaninNum(i) > 0);
+        Miaig_ForEachObjFanin(i, iLit, k)
+        if (k == 0)
+            objCopy(i) = Rw_Lit2LitL(_data->pCopy, iLit);
+        else
+            objCopy(i) = Mini_AigAnd(pMini, objCopy(i), Rw_Lit2LitL(_data->pCopy, iLit));
+    }
+    Miaig_ForEachOutput(i) {
+        assert(objFaninNum(i) == 1);
+        Miaig_ForEachObjFanin(i, iLit, k)
+            Mini_AigCreatePo(pMini, Rw_Lit2LitL(_data->pCopy, iLit));
+    }
+    assert(pMini->nSize == 2 * (1 + nIns() + nOuts() + countAnd2()));
+    return pMini;    
+}
+
+Abc_Ntk_t *Miaig::toNtk(int fMapped) {
+    if (_data->pNtkMapped && fMapped) {
+        return Abc_ManRewireNtkFromMiniMapping(Vi_Array(_data->pNtkMapped));
+    }
+    Gia_Man_t *pGia = toGia();
+    Abc_Ntk_t *pNtk = Gia_ManRewirePut(pGia);
+    Gia_ManStop(pGia);
+    return pNtk;
+}
+#endif // RW_ABC
+
+// technology mapping
+float Miaig::countTransistors(int reset) {
+    if (!reset && _data->nTransistor) return _data->nTransistor;
+#ifdef RW_ABC
+    Abc_Ntk_t *pNtk = toNtk();
+    Abc_Ntk_t *pNtkMapped = Abc_ManRewireMap(pNtk);
+
+    float area = Abc_NtkGetMappedArea(pNtkMapped);
+    Vec_Int_t *vMapping = Abc_ManRewireNtkWriteMiniMapping(pNtkMapped);
+    _data->pNtkMapped = (vi *)malloc(sizeof(vi));
+    _data->pNtkMapped->size = Vec_IntSize(vMapping);
+    _data->pNtkMapped->cap = Vec_IntCap(vMapping);
+    _data->pNtkMapped->ptr = Vec_IntArray(vMapping);
+    free(vMapping);
+    Abc_NtkDelete(pNtk);
+    Abc_NtkDelete(pNtkMapped);
+#else
+    float area = 0;
+#endif // RW_ABC
+
+    return _data->nTransistor = area;
+}
+
+// topological collection
+void Miaig::topoCollect_rec(int iObj) {
+    int i, iLit;
+    if (objTravId(iObj) == nTravIds())
+        return;
+    objTravId(iObj) = nTravIds();
+    Vi_PushOrder(_data->vOrder, iObj);
+    Miaig_ForEachObjFanin(iObj, iLit, i)
+        topoCollect_rec(Abc_Lit2Var(iLit));
+}
+
+vi *Miaig::topoCollect(void) {
+    int i;
+    nTravIds()++;
+    Vi_Shrink(_data->vOrder, 0);
+    Miaig_ForEachConstInput(i)
+        objTravId(i) = nTravIds();
+    Miaig_ForEachOutput(i)
+        topoCollect_rec(Abc_Lit2Var(objFanin0(i)));
+    return _data->vOrder;
+}
+
+// initializeLevels
+int Miaig::initializeLevels_rec(int iObj) {
+    int i, iLit;
+    if (objLevel(iObj) != -1)
+        return objLevel(iObj);
+    int level = -1;
+    Miaig_ForEachObjFanin(iObj, iLit, i) {
+        level = Abc_MaxInt(initializeLevels_rec(Abc_Lit2Var(iLit)), level);
+    }
+    return objLevel(iObj) = level + 1;
+}
+
+void Miaig::initializeLevels(void) {
+    if (_data->pLevel) return;
+    _data->pLevel = (int *)malloc(sizeof(int) * nObjs());
+
+    int i;
+    Miaig_ForEachObj(i) {
+        objLevel(i) = -1;
+    }
+    Miaig_ForEachConstInput(i) {
+        objLevel(i) = 0;
+    }
+    Miaig_ForEachOutput(i) {
+        objLevel(i) = initializeLevels_rec(Abc_Lit2Var(objFanin0(i)));
+    }
+}
+
+// distance computation
+void Miaig::initializeDists(void) {
+    if (_data->pDist) return;
+    _data->pDist = (int *)malloc(sizeof(int) * nObjs());
+}
+
+void Miaig::markDistanceN_rec(int iObj, int n, int limit) {
+    int i, iLit;
+    if (objDist(iObj) >= 0 && objDist(iObj) <= n)
+        return;
+    objDist(iObj) = n;
+    if (n == limit)
+        return;
+    Miaig_ForEachObjFanin(iObj, iLit, i)
+        markDistanceN_rec(Abc_Lit2Var(iLit), n + 1, limit);
+}
+
+void Miaig::markDistanceN(int iObj, int n) {
+    int i, j, k, iLit;
+    memset(_data->pDist, 0xFF, sizeof(int) * nObjs());
+    markDistanceN_rec(iObj, 0, n);
+    for (i = 0; i < n; ++i) {
+        Miaig_ForEachNode(j) {
+            if (objDist(j) >= 0) continue;
+            int minDist = nObjs();
+            Miaig_ForEachObjFanin(j, iLit, k) {
+                if (objDist(Abc_Lit2Var(iLit)) == -1) continue;
+                minDist = Abc_MinInt(minDist, objDist(Abc_Lit2Var(iLit)));
+            }
+            if (minDist != nObjs()) {
+                markDistanceN_rec(j, minDist + 1, n);
+            }
+        }
+    }
+}
+
+// reference counting
+void Miaig::refObj(int iObj) {
+    int k, iLit;
+    Miaig_ForEachObjFanin(iObj, iLit, k)
+        objRef(Abc_Lit2Var(iLit))++;
+}
+
+void Miaig::derefObj(int iObj) {
+    int k, iLit;
+    Miaig_ForEachObjFanin(iObj, iLit, k)
+        objRef(Abc_Lit2Var(iLit))--;
+}
+
+void Miaig::derefObj_rec(int iObj, int iLitSkip) {
+    int k, iLit;
+    Miaig_ForEachObjFanin(iObj, iLit, k) { 
+        if (iLit != iLitSkip && --objRef(Abc_Lit2Var(iLit)) == 0 && objIsNode(Abc_Lit2Var(iLit))) {
+            derefObj_rec(Abc_Lit2Var(iLit), -1);
+            Vi_Fill(_data->pvFans + Abc_Lit2Var(iLit), 1, 0);
+            refObj(Abc_Lit2Var(iLit));
+        }
+    }
+}
+
+void Miaig::initializeRefs(void) {
+    int i;
+    memset(_data->pRefs, 0, sizeof(int) * _data->nObjs);
+    Miaig_ForEachNodeOutput(i)
+        refObj(i);
+}
+
+void Miaig::verifyRefs(void) {
+    int i;
+    Miaig_ForEachNodeOutput(i)
+        derefObj(i);
+    for (i = 0; i < _data->nObjs; i++)
+        if (objRef(i))
+            printf("Ref count of node %d is incorrect (%d).\n", i, objRef(i));
+    initializeRefs();
+}
+
+// this procedure marks Const0, PIs, POs, and used nodes with the current trav ID
+void Miaig::markDfs_rec(int iObj) {
+    int i, iLit;
+    if (objTravId(iObj) == nTravIds())
+        return;
+    objTravId(iObj) = nTravIds();
+    Miaig_ForEachObjFanin(iObj, iLit, i)
+        markDfs_rec(Abc_Lit2Var(iLit));
+}
+
+int Miaig::markDfs(void) {
+    int i, nUnused = 0;
+    nTravIds()++;
+    Miaig_ForEachConstInput(i)
+        objTravId(i) = nTravIds();
+    Miaig_ForEachOutput(i)
+        markDfs_rec(Abc_Lit2Var(objFanin0(i)));
+    Miaig_ForEachOutput(i)
+        objTravId(i) = nTravIds();
+    Miaig_ForEachNode(i)
+        nUnused += (int)(objTravId(i) != nTravIds());
+    return nUnused;
+}
+
+// simple duplicator (optionally removes unused nodes)
+Miaig Miaig::dup(int fRemDangle, int fMapped) {
+    // Miaig pNew = Maig_Alloc(nIns(), nOuts(), nObjs());
+    Miaig pNew(nIns(), nOuts(), nObjs());
+    memset(_data->pCopy, 0, sizeof(int) * nObjs());
+    int i, k, iLit; // obj2obj
+    if (fRemDangle)
+        markDfs();
+    Miaig_ForEachInput(i)
+        objCopy(i) = i;
+    Miaig_ForEachNodeOutput(i) {
+        assert(objFaninNum(i) > 0);
+        if (fRemDangle && objTravId(i) != nTravIds())
+            continue;
+        objCopy(i) = pNew.appendObj();
+        Miaig_ForEachObjFanin(i, iLit, k)
+            pNew.appendFanin(objCopy(i), Rw_Lit2LitV(_data->pCopy, iLit));
+    }
+    if (_data->pNtkMapped && fMapped)
+        pNew._data->pNtkMapped = Vi_Dup(_data->pNtkMapped);
+    return pNew;
+}
+
+// duplicator to restore the topological order
+// (the input AIG can have "hidden" internal nodes listed after primary outputs)
+void Miaig::dupDfs_rec(Miaig &pNew, int iObj) {
+    int i, iLit;
+    // 1. return if current node is already marked
+    if (objCopy(iObj) >= 0)
+        return;
+    // 2. create fanins for a given node
+    Miaig_ForEachObjFanin(iObj, iLit, i)
+        dupDfs_rec(pNew, Abc_Lit2Var(iLit));
+    assert(objCopy(iObj) < 0); // combinational loop catching
+    assert(objFaninNum(iObj) > 0);
+    // 3. create current node
+    objCopy(iObj) = pNew.appendObj();
+    // 4. append newly created fanins to the current node
+    Miaig_ForEachObjFanin(iObj, iLit, i)
+        pNew.appendFanin(objCopy(iObj), Rw_Lit2LitV(_data->pCopy, iLit));
+}
+
+Miaig Miaig::dupDfs(void) {
+    Miaig pNew(nIns(), nOuts(), nObjsAlloc());
+    // 1. the array is filled with -1 to distinct visited nodes from unvisited
+    memset(_data->pCopy, 0xFF, sizeof(int) * nObjsAlloc());
+    int i; // obj2obj
+    // for each primary input we mark it with it's index
+    Miaig_ForEachConstInput(i)
+        objCopy(i) = i;
+    // 2. for each primary output we call recursive function for it's fanin
+    Miaig_ForEachOutput(i)
+        dupDfs_rec(pNew, Abc_Lit2Var(objFanin0(i)));
+    // 3. for each primary output append it's fanin
+    Miaig_ForEachOutput(i)
+        pNew.appendFanin(pNew.appendObj(), Rw_Lit2LitV(_data->pCopy, objFanin0(i)));
+    return pNew;
+}
+
+// reduces multi-input and-gate represented by an array of fanin literals
+void Miaig::reduceFanins(vi *v) {
+    assert(Vi_Size(v) > 0);
+    Vi_SelectSort(v);
+
+    if (Vi_Read(v, 0) == 0) {
+        Vi_Shrink(v, 1);
+        return;
+    }
+    while (Vi_Read(v, 0) == 1)
+        Vi_Drop(v, 0);
+    if (Vi_Size(v) == 0) {
+        Vi_Push(v, 1);
+        return;
+    }
+    if (Vi_Size(v) == 1)
+        return;
+    int i, iLit, iPrev = Vi_Read(v, 0);
+    Vi_ForEachEntryStart(v, iLit, i, 1) {
+        if ((iPrev ^ iLit) == 1) {
+            Vi_Fill(v, 1, 0);
+            return;
+        }
+        if (iPrev == iLit)
+            Vi_Drop(v, i--);
+        else
+            iPrev = iLit;
+    }
+}
+
+int Miaig::hashTwo(int l0, int l1, int TableSize) {
+    unsigned Key = 0;
+    Key += Abc_Lit2Var(l0) * 7937;
+    Key += Abc_Lit2Var(l1) * 2971;
+    Key += Abc_LitIsCompl(l0) * 911;
+    Key += Abc_LitIsCompl(l1) * 353;
+    return Key % TableSize;
+}
+
+int *Miaig::hashLookup(int *pTable, int l0, int l1, int TableSize) {
+    int Key = hashTwo(l0, l1, TableSize);
+    for (; pTable[3 * Key]; Key = (Key + 1) % TableSize)
+        if (pTable[3 * Key] == l0 && pTable[3 * Key + 1] == l1)
+            return pTable + 3 * Key + 2;
+    assert(pTable[3 * Key] == 0);
+    assert(pTable[3 * Key + 1] == 0);
+    assert(pTable[3 * Key + 2] == 0);
+    pTable[3 * Key] = l0;
+    pTable[3 * Key + 1] = l1;
+    return pTable + 3 * Key + 2;
+}
+
+// this duplicator creates two-input nodes, propagates constants, and does structural hashing
+int Miaig::buildNode(int l0, int l1, int fCprop, int fStrash) {
+    if (fCprop) {
+        if (l0 == 0 || l1 == 0 || (l0 ^ l1) == 1) return 0;
+        if (l0 == l1 || l1 == 1) return l0;
+        if (l0 == 1) return l1;
+    }
+    int *pPlace = NULL;
+    if (fStrash) {
+        pPlace = hashLookup(_data->pTable, Abc_MinInt(l0, l1), Abc_MaxInt(l0, l1), _data->TableSize);
+        if (*pPlace)
+            return *pPlace;
+    }
+    int iObj = appendObj();
+    appendFanin(iObj, Abc_MinInt(l0, l1));
+    appendFanin(iObj, Abc_MaxInt(l0, l1));
+    return pPlace ? (*pPlace = Abc_Var2Lit(iObj, 0)) : Abc_Var2Lit(iObj, 0);
+}
+
+int Miaig::buildNodeBalance_rec(Miaig &pNew, vi *vFanins, int begin, int end, int fCprop, int fStrash) {
+    int length = end - begin + 1;
+    if (length == 1) {
+        return Rw_Lit2LitL(_data->pCopy, Vi_Read(vFanins, begin));
+    } else if (length == 2) {
+        return pNew.buildNode(Rw_Lit2LitL(_data->pCopy, Vi_Read(vFanins, begin)), Rw_Lit2LitL(_data->pCopy, Vi_Read(vFanins, end)), fCprop, fStrash);
+    }
+    int middle = begin + length / 2;
+    int iLit0 = buildNodeBalance_rec(pNew, vFanins, begin, middle - 1, fCprop, fStrash);
+    int iLit1 = buildNodeBalance_rec(pNew, vFanins, middle, end, fCprop, fStrash);
+    return pNew.buildNode(iLit0, iLit1, fCprop, fStrash);
+}
+
+int Miaig::buildNodeBalance(Miaig &pNew, vi *vFanins, int fCprop, int fStrash) {
+    return buildNodeBalance_rec(pNew, vFanins, 0, Vi_Size(vFanins) - 1, fCprop, fStrash);
+}
+
+int Miaig::buildNodeCascade(Miaig &pNew, vi *vFanins, int fCprop, int fStrash) {
+    int iLit = -1;
+    for (int i = 0; i < Vi_Size(vFanins); ++i) {
+        if (i == 0)
+            iLit = Rw_Lit2LitL(_data->pCopy, Vi_Read(vFanins, i));
+        else
+            iLit = pNew.buildNode(iLit, Rw_Lit2LitL(_data->pCopy, Vi_Read(vFanins, i)), fCprop, fStrash);
+    }
+    return iLit;
+}
+
+Miaig Miaig::dupStrash(int fCprop, int fStrash, int fCascade) {
+    int i, nObjsAlloc = 1 + nIns() + nOuts() + countAnd2();
+    Miaig pNew(nIns(), nOuts(), nObjsAlloc);
+    memset(_data->pCopy, 0, sizeof(int) * nObjs()); // obj2lit
+    if (fStrash) {
+        assert(pNew._data->pTable == NULL);
+        pNew._data->TableSize = Abc_PrimeCudd(3 * countAnd2());
+        pNew._data->pTable = (int *)calloc(sizeof(int), 3 * pNew._data->TableSize);
+    }
+    Miaig_ForEachInput(i)
+        objCopy(i) = Abc_Var2Lit(i, 0);
+    Miaig_ForEachNode(i) {
+        assert(objFaninNum(i) > 0);
+        if (fCascade)
+            objCopy(i) = buildNodeCascade(pNew, _data->pvFans + i, fCprop, fStrash);
+        else
+            objCopy(i) = buildNodeBalance(pNew, _data->pvFans + i, fCprop, fStrash);
+    }
+    Miaig_ForEachOutput(i)
+        pNew.appendFanin(pNew.appendObj(), Rw_Lit2LitL(_data->pCopy, objFanin0(i)));
+    return pNew.dup(1);
+}
+
+// this duplicator converts two-input-node AIG into multi-input-node AIG
+int *Miaig::createStops(void) {
+    int i, *pStop = (int *)calloc(sizeof(int), nObjs());
+    Miaig_ForEachConstInput(i)
+        pStop[i] = 2;
+    Miaig_ForEachNode(i) {
+        assert(objFaninNum(i) == 2);
+        int iLit0 = objFanin0(i);
+        int iLit1 = objFanin1(i);
+        pStop[Abc_Lit2Var(iLit0)] += 1 + Abc_LitIsCompl(iLit0);
+        pStop[Abc_Lit2Var(iLit1)] += 1 + Abc_LitIsCompl(iLit1);
+    }
+    Miaig_ForEachOutput(i)
+        pStop[Abc_Lit2Var(objFanin0(i))] += 2;
+    return pStop;
+}
+
+void Miaig::collectSuper_rec(int iLit, int *pStop, vi *vSuper) {
+    if (pStop[Abc_Lit2Var(iLit)] > 1)
+        Vi_Push(vSuper, Rw_Lit2LitL(_data->pCopy, iLit));
+    else {
+        assert(Abc_LitIsCompl(iLit) == 0);
+        collectSuper_rec(objFanin0(Abc_Lit2Var(iLit)), pStop, vSuper);
+        collectSuper_rec(objFanin1(Abc_Lit2Var(iLit)), pStop, vSuper);
+    }
+}
+
+Miaig Miaig::dupMulti(int nFaninMax_, int nGrowth) {
+    Miaig pNew(nIns(), nOuts(), nObjs());
+    int *pStop = createStops();
+    int i, k, iLit;
+    vi *vArray = Vi_Alloc(100);
+    assert(nFaninMax_ >= 2 && nGrowth >= 1);
+    memset(_data->pCopy, 0, sizeof(int) * nObjs()); // obj2lit
+    Miaig_ForEachConstInput(i)
+        objCopy(i) = Abc_Var2Lit(i, 0);
+    Miaig_ForEachNode(i) {
+        if (pStop[i] == 1)
+            continue;
+        assert(pStop[i] > 1); // no dangling
+        Vi_Shrink(vArray, 0);
+        collectSuper_rec(objFanin0(i), pStop, vArray);
+        collectSuper_rec(objFanin1(i), pStop, vArray);
+        assert(Vi_Size(vArray) > 1);
+        reduceFanins(vArray);
+        assert(Vi_Size(vArray) > 0);
+        if (Vi_Size(vArray) == 1)
+            objCopy(i) = Vi_Read(vArray, 0);
+        else {
+            int nFaninMaxLocal = 2 + (Random_Num(0) % (nFaninMax_ - 1));
+            int nGrowthLocal = 1 + (Random_Num(0) % nGrowth);
+            assert(nFaninMaxLocal >= 2 && nFaninMaxLocal <= nFaninMax_);
+            assert(nGrowthLocal >= 1 && nGrowthLocal <= nGrowth);
+
+            if (Vi_Size(vArray) > nFaninMaxLocal)
+                Vi_Randomize(vArray);
+            // create a cascade of nodes
+            while (Vi_Size(vArray) > nFaninMaxLocal) {
+                int iObj = pNew.appendObj();
+                vi *vFanins = pNew._data->pvFans + iObj;
+                assert(vFanins->ptr == NULL);
+                vFanins->cap = nFaninMaxLocal + nGrowthLocal;
+                vFanins->ptr = (int *)malloc(sizeof(int) * vFanins->cap);
+                Vi_ForEachEntryStop(vArray, iLit, k, nFaninMaxLocal)
+                    pNew.appendFanin(iObj, iLit);
+                assert(Vi_Space(vFanins) == nGrowthLocal);
+                for (k = 0; k < nFaninMaxLocal; k++)
+                    Vi_Drop(vArray, 0);
+                Vi_Push(vArray, Abc_Var2Lit(iObj, 0));
+            }
+            // create the last node
+            int iObj = pNew.appendObj();
+            vi *vFanins = pNew._data->pvFans + iObj;
+            assert(vFanins->ptr == NULL);
+            vFanins->cap = Vi_Size(vArray) + nGrowthLocal;
+            vFanins->ptr = (int *)malloc(sizeof(int) * vFanins->cap);
+            Vi_ForEachEntry(vArray, iLit, k)
+                pNew.appendFanin(iObj, iLit);
+            assert(Vi_Space(vFanins) == nGrowthLocal);
+            objCopy(i) = Abc_Var2Lit(iObj, 0);
+        }
+    }
+    Miaig_ForEachOutput(i)
+        pNew.appendFanin(pNew.appendObj(), Rw_Lit2LitL(_data->pCopy, objFanin0(i)));
+    Vi_Free(vArray);
+    free(pStop);
+    return pNew;
+}
+
+// compute truth table of the node
+void Miaig::truthSimNode(int i) {
+    int k, iLit;
+    Miaig_ForEachObjFanin(i, iLit, k) { 
+        if (k == 0) Tt_DupC(objTruth(i, objType(i)), objTruth(Abc_Lit2Var(iLit), objType(Abc_Lit2Var(iLit))), Abc_LitIsCompl(iLit), nWords());
+        else Tt_Sharp(objTruth(i, objType(i)), objTruth(Abc_Lit2Var(iLit), objType(Abc_Lit2Var(iLit))), Abc_LitIsCompl(iLit), nWords());
+    }
+}
+
+// compute truth table of the node using a subset of its current fanin
+word *Miaig::truthSimNodeSubset(int i, int m) {
+    int k, iLit, Counter = 0;
+    assert(m > 0);
+    Miaig_ForEachObjFanin(i, iLit, k) {
+        if ((m >> k) & 1) { // fanin is included in the subset
+            if (Counter++ == 0)
+                Tt_DupC(_data->pProd, objTruth(Abc_Lit2Var(iLit), 0), Abc_LitIsCompl(iLit), nWords());
+            else
+                Tt_Sharp(_data->pProd, objTruth(Abc_Lit2Var(iLit), 0), Abc_LitIsCompl(iLit), nWords());
+        }
+    }
+    assert(Counter == Tt_BitCount16(m));
+    return _data->pProd;
+}
+
+word *Miaig::truthSimNodeSubset2(int i, vi *vFanins, int nFanins) {
+    int k, iLit;
+    Vi_ForEachEntryStop(vFanins, iLit, k, nFanins) {
+        if (k == 0) Tt_DupC(_data->pProd, objTruth(Abc_Lit2Var(iLit), 0), Abc_LitIsCompl(iLit), nWords());
+        else Tt_Sharp(_data->pProd, objTruth(Abc_Lit2Var(iLit), 0), Abc_LitIsCompl(iLit), nWords());
+    }
+    return _data->pProd;
+}
+
+void Miaig::initializeTruth(void) {
+    int i;
+    if (_data->pTruths[0])
+        return;
+    _data->pTruths[0] = (word *)calloc(sizeof(word), 3 * nWords() * nObjs());
+    _data->pTruths[1] = _data->pTruths[0] + 1 * nWords() * nObjs();
+    _data->pTruths[2] = _data->pTruths[0] + 2 * nWords() * nObjs();
+    _data->pCare = (word *)calloc(sizeof(word), nWords());
+    _data->pProd = (word *)calloc(sizeof(word), nWords());
+    float MemMB = 8.0 * nWords() * (3 * nObjs() + 2) / (1 << 20);
+    if (MemMB > 100.0)
+        printf("Allocated %d truth tables of %d-variable functions (%.2f MB),\n", 3 * nObjs() + 2, nIns(), MemMB);
+    nTravIds()++;
+    Miaig_ForEachInput(i)
+        Tt_ElemInit(objTruth(i, 0), i - 1, nWords());
+    Miaig_ForEachNodeOutput(i)
+        truthSimNode(i);
+    Miaig_ForEachOutput(i)
+        assert(objFaninNum(i) == 1);
+    Miaig_ForEachOutput(i)
+        Tt_Dup(objTruth(i, 2), objTruth(i, 0), nWords());
+}
+
+void Miaig::truthUpdate(vi *vTfo) {
+    int i, iTemp, nFails = 0;
+    nTravIds()++;
+    Vi_ForEachEntry(vTfo, iTemp, i) {
+        truthSimNode(iTemp);
+        if (objIsPo(iTemp) && !Tt_Equal(objTruth(iTemp, 2), objTruth(iTemp, 0), nWords()))
+            printf("Verification failed at output %d.\n", iTemp - (nObjs() - nOuts())), nFails++;
+    }
+    if (nFails)
+        printf("Verification failed for %d outputs after updating node %d.\n", nFails, Vi_Read(vTfo, 0));
+}
+
+int Miaig::computeTfo_rec(int iObj) {
+    int k, iLit, Value = 0;
+    if (objTravId(iObj) == nTravIds())
+        return 1;
+    if (objTravId(iObj) == nTravIds() - 1)
+        return 0;
+    Miaig_ForEachObjFanin(iObj, iLit, k) {
+        Value |= computeTfo_rec(Abc_Lit2Var(iLit));
+    }
+    objTravId(iObj) = nTravIds() - 1 + Value;
+    if (Value) Vi_Push(_data->vTfo, iObj);
+    return Value;
+}
+
+vi *Miaig::computeTfo(int iObj) {
+    int i;
+    assert(objIsNode(iObj));
+    nTravIds() += 2;
+    objTravId(iObj) = nTravIds();
+    Vi_Fill(_data->vTfo, 1, iObj);
+    Miaig_ForEachConstInput(i)
+        objTravId(i) = nTravIds() - 1;
+    Miaig_ForEachOutput(i)
+        computeTfo_rec(i);
+    Miaig_ForEachNode(i) {
+        computeTfo_rec(i);
+    }
+    return _data->vTfo;
+}
+
+word *Miaig::computeCareSet(int iObj) {
+    vi *vTfo = computeTfo(iObj);
+    int i, iTemp;
+    Tt_Not(objTruth(iObj, 1), objTruth(iObj, 0), nWords());
+    Tt_Clear(_data->pCare, nWords());
+    Vi_ForEachEntryStart(vTfo, iTemp, i, 1) {
+        truthSimNode(iTemp);
+        if (objIsPo(iTemp))
+            Tt_OrXor(_data->pCare, objTruth(iTemp, 0), objTruth(iTemp, 1), nWords());
+    }
+    return _data->pCare;
+}
+
+// adds fanin pair to storage
+void Miaig::addPair(vi *vPair, int iFan1, int iFan2) {
+    assert(iFan1 < iFan2);
+    int i, *pArray = Vi_Array(vPair);
+    assert(Vi_Size(vPair) % 3 == 0);
+    for (i = 0; i < Vi_Size(vPair); i += 3)
+        if (pArray[i] == iFan1 && pArray[i + 1] == iFan2)
+            break;
+    if (i == Vi_Size(vPair)) {
+        Vi_Push(vPair, iFan1);
+        Vi_Push(vPair, iFan2);
+        Vi_Push(vPair, 1);
+        pArray = Vi_Array(vPair);
+    }
+    pArray[i + 2]++;
+    //printf( "Adding pair (%d, %d)\n", iFan1, iFan2 );
+}
+
+// find fanin pair that appears most often
+int Miaig::findPair(vi *vPair) {
+    int iBest = -1, BestCost = 0;
+    int i, *pArray = Vi_Array(vPair);
+    assert(Vi_Size(vPair) % 3 == 0);
+    for (i = 0; i < Vi_Size(vPair); i += 3)
+        if (BestCost < pArray[i + 2]) {
+            BestCost = pArray[i + 2];
+            iBest = i;
+        }
+    //if ( iBest >= 0 ) printf( "Extracting pair (%d, %d) used %d times.\n", pArray[iBest], pArray[iBest+1], pArray[iBest+2] );
+    return iBest;
+}
+
+// updates one fanin array by replacing the pair with a new literal (iLit)
+int Miaig::updateFanins(vi *vFans, int iFan1, int iFan2, int iLit) {
+    int f1, f2, iFan1_, iFan2_;
+    Vi_ForEachEntry(vFans, iFan1_, f1) if (iFan1_ == iFan1)
+        Vi_ForEachEntryStart(vFans, iFan2_, f2, f1 + 1) if (iFan2_ == iFan2) {
+        assert(f1 < f2);
+        Vi_Drop(vFans, f2);
+        Vi_Drop(vFans, f1);
+        Vi_Push(vFans, iLit);
+        return 1;
+    }
+    return 0;
+}
+
+// updates the network by extracting one pair
+void Miaig::extractBest(vi *vPairs) {
+    int i, iObj = appendObj();
+    int Counter = 0, *pArray = Vi_Array(vPairs);
+    int iBest = findPair(vPairs);
+    assert(iBest >= 0);
+    //printf( "Creating node %d with fanins (%d, %d).\n", iObj, pArray[iBest], pArray[iBest+1] );
+    assert(Vi_Size(_data->pvFans + iObj) == 0);
+    appendFanin(iObj, pArray[iBest]);
+    appendFanin(iObj, pArray[iBest + 1]);
+    Miaig_ForEachNode(i)
+        Counter += updateFanins(_data->pvFans + i, pArray[iBest], pArray[iBest + 1], Abc_Var2Lit(iObj, 0));
+    assert(Counter == pArray[iBest + 2]);
+}
+
+// find the set of all pairs that appear more than once
+vi *Miaig::findPairs(word *pSto, int nWords) {
+    vi *vPairs = Vi_Alloc(30);
+    int i, f1, f2, iFan1, iFan2;
+    Miaig_ForEachNode(i) {
+        vi *vFans = _data->pvFans + i;
+        Vi_ForEachEntry(vFans, iFan1, f1) {
+            word *pRowFan1 = pSto + iFan1 * nWords;
+            Vi_ForEachEntryStart(vFans, iFan2, f2, f1 + 1) {
+                if (Tt_GetBit(pRowFan1, iFan2)) addPair(vPairs, iFan1, iFan2);
+                else Tt_SetBit(pRowFan1, iFan2);
+            }
+        }
+    }
+    return vPairs;
+}
+
+// extract shared fanin pairs and return the number of pairs extracted
+int Miaig::findShared(int nNewNodesMax) {
+    if (nObjs() + nNewNodesMax > nObjsAlloc()) {
+        nObjsAlloc() = nObjs() + nNewNodesMax;
+        _data->pCopy = (int *)realloc((void *)_data->pCopy, sizeof(int) * nObjsAlloc());
+        _data->pvFans = (vi *)realloc((void *)_data->pvFans, sizeof(vi) * nObjsAlloc());
+        memset(_data->pCopy + nObjs(), 0, sizeof(int) * (nObjsAlloc() - nObjs()));
+        memset(_data->pvFans + nObjs(), 0, sizeof(vi) * (nObjsAlloc() - nObjs()));
+    }
+    assert(sizeof(word) == 8);
+    int i, nWords = (2 * nObjsAlloc() + 63) / 64; // how many words are needed to have a bitstring with one bit for each literal
+    int nBytesAll = sizeof(word) * nWords * 2 * nObjsAlloc();
+    word *pSto = (word *)malloc(nBytesAll);
+    vi *vPairs;
+    for (i = 0; i < nNewNodesMax; i++) {
+        memset(pSto, 0, nBytesAll);
+        nObjs() -= i;
+        vPairs = findPairs(pSto, nWords);
+        nObjs() += i;
+        if (Vi_Size(vPairs) > 0)
+            extractBest(vPairs);
+        int Size = Vi_Size(vPairs);
+        Vi_Free(vPairs);
+        if (Size == 0)
+            break;
+    }
+    free(pSto);
+    return i;
+}
+
+int Miaig::checkConst(int iObj, word *pCare, int fVerbose) {
+    word *pFunc = objTruth(iObj, 0);
+    if (!Tt_IntersectC(pCare, pFunc, 0, nWords())) {
+        derefObj_rec(iObj, -1);
+        Vi_Fill(_data->pvFans + iObj, 1, 0); // const0
+        refObj(iObj);
+        truthUpdate(_data->vTfo);
+        if (fVerbose) printf("Detected Const0 at node %d.\n", iObj);
+        return 1;
+    }
+    if (!Tt_IntersectC(pCare, pFunc, 1, nWords())) {
+        derefObj_rec(iObj, -1);
+        Vi_Fill(_data->pvFans + iObj, 1, 1); // const1
+        refObj(iObj);
+        truthUpdate(_data->vTfo);
+        if (fVerbose) printf("Detected Const1 at node %d.\n", iObj);
+        return 1;
+    }
+    return 0;
+}
+
+int Miaig::expandOne(int iObj, int nAddedMax, int nDist, int fVerbose) {
+    int i, k, n, iLit, nAdded = 0;
+    word *pCare = computeCareSet(iObj);
+    assert(nAddedMax > 0);
+    assert(nAddedMax <= Vi_Space(_data->pvFans + iObj));
+    // mark node's fanins
+    Miaig_ForEachObjFanin(iObj, iLit, k)
+        objTravId(Abc_Lit2Var(iLit)) = nTravIds();
+    // compute the onset
+    word *pOnset = objTruth(iObj, 0);
+    Tt_Sharp(pOnset, pCare, 0, nWords());
+    // create a random order of fanin candidates
+    Vi_Shrink(_data->vOrderF, 0);
+    if (nDist) markDistanceN(iObj, nDist);
+    Miaig_ForEachInputNode(i) {
+        if (nDist && objDist(i) < 0 && !objIsPi(i)) continue;
+        if (objTravId(i) != nTravIds() && (objIsPi(i) || (objFaninNum(i) > 1 && objRef(i) > 0))) // this node is NOT in the TFO
+            Vi_Push(_data->vOrderF, i);
+    }
+    Vi_Randomize(_data->vOrderF);
+
+    int *pOrderF = Vi_Array(_data->vOrderF);
+    std::stable_sort(pOrderF, pOrderF + Vi_Size(_data->vOrderF), [&](int a, int b) {
+        return objLevel(Abc_Lit2Var(a)) > objLevel(Abc_Lit2Var(b));
+    });
+    std::stable_sort(pOrderF, pOrderF + Vi_Size(_data->vOrderF), [&](int a, int b) {
+        if (objLevel(Abc_Lit2Var(a)) == 0 || objLevel(Abc_Lit2Var(b)) == 0) {
+            return false;
+        }
+        return objRef(Abc_Lit2Var(a)) < objRef(Abc_Lit2Var(b));
+    });
+
+    // iterate through candidate fanins (nodes that are not in the TFO of iObj)
+    Vi_ForEachEntry(_data->vOrderF, i, k) {
+        assert(objTravId(i) != nTravIds());
+        // new fanin can be added if its offset does not intersect with the node's onset
+        for (n = 0; n < 2; n++)
+            if (!Tt_IntersectC(pOnset, objTruth(i, 0), !n, nWords())) {
+                if (fVerbose) printf("Adding node %d fanin %d\n", iObj, Abc_Var2Lit(i, n));
+                appendFanin(iObj, Abc_Var2Lit(i, n));
+                objRef(i)++;
+                nAdded++;
+                break;
+            }
+        if (nAdded == nAddedMax)
+            break;
+    }
+    //printf( "Updating TFO of node %d:  ", iObj );  Vi_Print(_data->vTfo);
+    truthUpdate(_data->vTfo);
+    //assert( objFaninNum(iObj) <= nFaninMax );
+    return nAdded;
+}
+
+int Miaig::reduceOne(int iObj, int fOnlyConst, int fOnlyBuffer, int fHeuristic, int fVerbose) {
+    int n, k, iLit, nFans = objFaninNum(iObj);
+    word *pCare = computeCareSet(iObj);
+    if (checkConst(iObj, pCare, fVerbose))
+        return nFans;
+    if (fOnlyConst)
+        return 0;
+    if (nFans == 1)
+        return 0;
+    // if one fanin can be used, take it
+    word *pFunc = objTruth(iObj, 0);
+    Miaig_ForEachObjFanin(iObj, iLit, k) {
+        Tt_DupC(_data->pProd, objTruth(Abc_Lit2Var(iLit), 0), Abc_LitIsCompl(iLit), nWords());
+        if (Tt_EqualOnCare(pCare, pFunc, _data->pProd, nWords())) {
+            derefObj(iObj);
+            Vi_Fill(_data->pvFans + iObj, 1, iLit);
+            refObj(iObj);
+            truthUpdate(_data->vTfo);
+            if (fVerbose) printf("Reducing node %d fanin count from %d to %d.\n", iObj, nFans, objFaninNum(iObj));
+            return nFans - 1;
+        }
+    }
+    if (fOnlyBuffer)
+        return 0;
+    Vi_Shrink(_data->vOrderF, 0);
+    Miaig_ForEachObjFanin(iObj, iLit, k)
+        Vi_Push(_data->vOrderF, iLit);
+    Vi_Randomize(_data->vOrderF);
+
+    if (fHeuristic) {
+        int *pOrderF = Vi_Array(_data->vOrderF);
+        std::stable_sort(pOrderF, pOrderF + Vi_Size(_data->vOrderF), [&](int a, int b) {
+            return objLevel(Abc_Lit2Var(a)) < objLevel(Abc_Lit2Var(b));
+        });
+        std::stable_sort(pOrderF, pOrderF + Vi_Size(_data->vOrderF), [&](int a, int b) {
+            if (objLevel(Abc_Lit2Var(a)) == 0 || objLevel(Abc_Lit2Var(b)) == 0) {
+                return false;
+            }
+            return objRef(Abc_Lit2Var(a)) > objRef(Abc_Lit2Var(b));
+        });
+    }
+
+    assert(Vi_Size(_data->vOrderF) == nFans);
+    // try to remove fanins starting from the end of the list
+    for (n = Vi_Size(_data->vOrderF) - 1; n >= 0; n--) {
+        int iFanin = Vi_Drop(_data->vOrderF, n);
+        word *pProd = truthSimNodeSubset2(iObj, _data->vOrderF, Vi_Size(_data->vOrderF));
+        if (!Tt_EqualOnCare(pCare, pFunc, pProd, nWords()))
+            Vi_Push(_data->vOrderF, iFanin);
+    }
+    assert(Vi_Size(_data->vOrderF) >= 1);
+    // update the node if it is reduced
+    if (Vi_Size(_data->vOrderF) < nFans) {
+        derefObj(iObj);
+        Vi_Shrink(_data->pvFans + iObj, 0);
+        Vi_ForEachEntry(_data->vOrderF, iLit, k)
+            Vi_PushOrder(_data->pvFans + iObj, iLit);
+        refObj(iObj);
+        truthUpdate(_data->vTfo);
+        if (fVerbose) printf("Reducing node %d fanin count from %d to %d.\n", iObj, nFans, objFaninNum(iObj));
+        return nFans - Vi_Size(_data->vOrderF);
+    }
+    return 0;
+}
+
+int Miaig::expandThenReduceOne(int iNode, int nFaninAddLimit, int nDist, int fVerbose) {
+    expandOne(iNode, Abc_MinInt(Vi_Space(_data->pvFans + iNode), nFaninAddLimit), nDist, fVerbose);
+    reduceOne(iNode, 0, 0, 0, fVerbose);
+    return 0;
+}
+
+vi *Miaig::createRandomOrder(void) {
+    int i;
+    Vi_Shrink(_data->vOrder, 0);
+    Miaig_ForEachNode(i)
+        Vi_Push(_data->vOrder, i);
+    Vi_Randomize(_data->vOrder);
+    return _data->vOrder;
+}
+
+Miaig Miaig::expand(int nFaninAddLimitAll, int nDist, int fVerbose) {
+    int i, iNode, nAdded = 0;
+    assert(nFaninAddLimitAll > 0);
+    vi *vOrder = createRandomOrder();
+
+    initializeTruth();
+    initializeRefs();
+    initializeLevels();
+    if (nDist) initializeDists();
+    Vi_ForEachEntry(vOrder, iNode, i) {
+        nAdded += expandOne(iNode, Abc_MinInt(Vi_Space(_data->pvFans + iNode), nFaninAddLimitAll - nAdded), nDist, fVerbose);
+        if (nAdded >= nFaninAddLimitAll)
+            break;
+    }
+    assert(nAdded <= nFaninAddLimitAll);
+    verifyRefs();
+    return dupDfs();
+}
+
+// perform shared logic extraction
+Miaig Miaig::share(int nNewNodesMax) {
+    Miaig pCopy = dup(0);
+    int nNewNodes = pCopy.findShared(nNewNodesMax);
+    if (nNewNodes == 0)
+        return pCopy;
+    // temporarily create "hidden" nodes for DFS duplicator
+    pCopy.nObjs() -= nNewNodes;
+    Miaig pNew = pCopy.dupDfs();
+    pCopy.nObjs() += nNewNodes;
+    return pNew;
+}
+
+Miaig Miaig::reduce(int fVerbose) {
+    int i, iNode;
+    vi *vOrder = topoCollect();
+
+    initializeTruth();
+    initializeRefs();
+    initializeLevels();
+    // works best for final
+    Vi_ForEachEntry(vOrder, iNode, i)
+        reduceOne(iNode, 0, 0, 1, fVerbose);
+    verifyRefs();
+    return dupStrash(1, 1, 1);
+}
+
+Miaig Miaig::expandThenReduce(int nFaninAddLimit, int nDist, int fVerbose) {
+    Miaig pTemp;
+    int i, iNode;
+    vi *vOrder = topoCollect();
+
+    initializeTruth();
+    initializeRefs();
+    initializeLevels();
+    if (nDist) initializeDists();
+    Vi_ForEachEntry(vOrder, iNode, i) {
+        expandThenReduceOne(iNode, nFaninAddLimit, nDist, fVerbose);
+    }
+    verifyRefs();
+    return dupDfs().dupStrash(1, 1, 1);
+}
+
+Miaig Miaig::expandShareReduce(int nFaninAddLimitAll, int nDivs, int nDist, int nVerbose) {
+    // expand
+    Miaig pNew = expand(nFaninAddLimitAll, nDist, nVerbose);
+    // share
+    pNew = pNew.share(nDivs == -1 ? pNew.nObjs() : nDivs);
+    // reduce
+    pNew = pNew.reduce(nVerbose);
+    return pNew;
+}
+
+void randomAddBest(std::vector<Miaig> &pBests, Miaig pNew, int nBestSave) {
+    if (pBests.size() < nBestSave) {
+        pBests.push_back(pNew);
+    } else {
+        int iNum = Random_Num(0) % nBestSave;
+        pBests[iNum] = pNew;
+    }
+}
+
+Miaig randomRead(std::vector<Miaig> &pBests) {
+    return pBests[Random_Num(0) % pBests.size()];
+}
+
+Miaig Miaig::rewire(int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nVerbose) {
+    const int nRootSave = 8;
+    const int nBestSave = 4;
+    int nRestart = 5000;
+    std::vector<Miaig> pRoots = {this->dup(0)};
+    std::vector<Miaig> pBests = {this->dup(0)};
+    iword clkStart = Time_Clock();
+    Miaig pNew;
+    Miaig pRoot = pRoots[0];
+    Miaig pBest = this->dup(0);
+    float (Miaig::*Miaig_ObjectiveFunction)(int) = (nMode == 0) ? &Miaig::countAnd2 : &Miaig::countTransistors;
+
+    float PrevBest = ((&pBest)->*Miaig_ObjectiveFunction)(1);
+    int iterNotImproveAfterRestart = 0;
+    if (nVerbose) printf("Initial target    : %5g (AND2 = %5g Level = %3d)\n", PrevBest, this->countAnd2(1), this->countLevel());
+    for (int i = 0; i < nIters; i++) {
+        if (nVerbose) printf("\rIteration %7d : %5g -> ", i + 1, ((&pRoot)->*Miaig_ObjectiveFunction)(0));
+        if (nTimeOut && nTimeOut < 1.0 * (Time_Clock() - clkStart) / CLOCKS_PER_SEC) break;
+        pNew = pRoot.dupMulti(nFaninMax, nGrowth);
+
+        if (i % 2 == 0) {
+            pNew = pNew.expandThenReduce(nGrowth, nDist, nVerbose > 1);
+        }
+        pNew = pNew.expandShareReduce(nExpands, nDivs, nDist, nVerbose > 1);
+
+        ++iterNotImproveAfterRestart;
+        // report
+        float rootTarget = ((&pRoot)->*Miaig_ObjectiveFunction)(0);
+        float newTarget = ((&pNew)->*Miaig_ObjectiveFunction)(1);
+        if (PrevBest > newTarget) {
+            if (nVerbose) printf("%5g (AND2 = %5g Level = %3d) ", newTarget, pNew.countAnd2(), pNew.countLevel());
+            if (nVerbose) Time_PrintEndl("Elapsed time", Time_Clock() - clkStart);
+            PrevBest = newTarget;
+            pBests = {pNew.dup(0), pNew.dup(0)};
+            pBest = pNew.dup(0, 1);
+            iterNotImproveAfterRestart = 0;
+        } else if (PrevBest == newTarget) {
+            randomAddBest(pBests, pNew.dup(0), nBestSave);
+        }
+        // compare
+        if (rootTarget < newTarget) {
+            if (iterNotImproveAfterRestart > nRestart) {
+                pNew = randomRead(pBests).dupMulti(nFaninMax, nGrowth);
+                pNew = pNew.expand(nExpands, nDist, nVerbose > 1);
+                pNew = pNew.share(nDivs == -1 ? pNew.nObjs() : nDivs);
+                pNew = pNew.dupStrash(1, 1, 0);
+                pRoots = {pNew};
+                iterNotImproveAfterRestart = 0;
+            } else if (rootTarget * 1.05 > newTarget) {
+                pRoots = {pNew};
+            }
+        } else if (rootTarget == newTarget) {
+            randomAddBest(pRoots, pNew, nRootSave);
+        } else {
+            pRoots = {pNew};
+        }
+        pRoot = randomRead(pRoots);
+    }
+    if (nVerbose) Time_PrintEndl("Total solving time", Time_Clock() - clkStart);
+    return pBest;
+}
+
+} // namespace Rewire
+
+#ifdef RW_ABC
+ABC_NAMESPACE_IMPL_END
+#endif // RW_ABC
diff --git a/src/opt/rar/rewire_miaig.h b/src/opt/rar/rewire_miaig.h
new file mode 100644
index 000000000..c66b19bda
--- /dev/null
+++ b/src/opt/rar/rewire_miaig.h
@@ -0,0 +1,493 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_miaig.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_miaig.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef REWIRE_MIAIG_H
+#define REWIRE_MIAIG_H
+
+#define RW_ABC
+
+#ifdef RW_ABC
+#include "base/abc/abc.h"
+#include "aig/miniaig/miniaig.h"
+#include "rewire_map.h"
+#else
+#ifdef _WIN32
+typedef unsigned __int64 word;   // 32-bit windows
+#else
+typedef long long unsigned word; // other platforms
+#endif
+#ifdef _WIN32
+typedef __int64 iword;   // 32-bit windows
+#else
+typedef long long iword; // other platforms
+#endif
+#endif // RW_ABC
+#include "rewire_vec.h"
+#include "rewire_tt.h"
+#include "rewire_time.h"
+
+
+#include <vector>
+#include <algorithm>
+
+#ifdef RW_ABC
+ABC_NAMESPACE_CXX_HEADER_START
+#endif // RW_ABC
+
+namespace Rewire {
+
+#if RW_THREADS
+// exchange-add operation for atomic operations on reference counters
+#if defined __riscv && !defined __riscv_atomic
+// riscv target without A extension
+static inline int RW_XADD(int *addr, int delta) {
+    int tmp = *addr;
+    *addr += delta;
+    return tmp;
+}
+#elif defined __INTEL_COMPILER && !(defined WIN32 || defined _WIN32)
+// atomic increment on the linux version of the Intel(tm) compiler
+#define RW_XADD(addr, delta)    \
+    (int)_InterlockedExchangeAdd( \
+        const_cast<void *>(reinterpret_cast<volatile void *>(addr)), delta)
+#elif defined __GNUC__
+#if defined __clang__ && __clang_major__ >= 3 && !defined __ANDROID__ && !defined __EMSCRIPTEN__ && !defined(__CUDACC__)
+#ifdef __ATOMIC_ACQ_REL
+#define RW_XADD(addr, delta) \
+    __c11_atomic_fetch_add((_Atomic(int) *)(addr), delta, __ATOMIC_ACQ_REL)
+#else
+#define RW_XADD(addr, delta) \
+    __atomic_fetch_add((_Atomic(int) *)(addr), delta, 4)
+#endif
+#else
+#if defined __ATOMIC_ACQ_REL && !defined __clang__
+// version for gcc >= 4.7
+#define RW_XADD(addr, delta)                                     \
+    (int)__atomic_fetch_add((unsigned *)(addr), (unsigned)(delta), \
+                            __ATOMIC_ACQ_REL)
+#else
+#define RW_XADD(addr, delta) \
+    (int)__sync_fetch_and_add((unsigned *)(addr), (unsigned)(delta))
+#endif
+#endif
+#elif defined _MSC_VER && !defined RC_INVOKED
+#define RW_XADD(addr, delta) \
+    (int)_InterlockedExchangeAdd((long volatile *)addr, delta)
+#else
+// thread-unsafe branch
+static inline int RW_XADD(int *addr, int delta) {
+    int tmp = *addr;
+    *addr += delta;
+    return tmp;
+}
+#endif
+#else  // RW_THREADS
+static inline int RW_XADD(int *addr, int delta) {
+    int tmp = *addr;
+    *addr += delta;
+    return tmp;
+}
+#endif // RW_THREADS
+
+#define Miaig_CustomForEachConstInput(p, i)         for (i = 0; i <= p->nIns; i++)
+#define Miaig_CustomForEachInput(p, i)              for (i = 1; i <= p->nIns; i++)
+#define Miaig_CustomForEachNode(p, i)               for (i = 1 + p->nIns; i < p->nObjs - p->nOuts; i++)
+#define Miaig_CustomForEachNodeReverse(p, i)        for (i = p->nObjs - p->nOuts - 1; i > 1 + p->nIns; i--)
+#define Miaig_CustomForEachInputNode(p, i)          for (i = 1; i < p->nObjs - p->nOuts; i++)
+#define Miaig_CustomForEachNodeStart(p, i, s)       for (i = s; i < p->nObjs - p->nOuts; i++)
+#define Miaig_CustomForEachOutput(p, i)             for (i = p->nObjs - p->nOuts; i < p->nObjs; i++)
+#define Miaig_CustomForEachNodeOutput(p, i)         for (i = 1 + p->nIns; i < p->nObjs; i++)
+#define Miaig_CustomForEachNodeOutputStart(p, i, s) for (i = s; i < p->nObjs; i++)
+#define Miaig_CustomForEachObj(p, i)                for (i = 0; i < p->nObjs; i++)
+#define Miaig_CustomForEachObjFanin(p, i, iLit, k)  Vi_ForEachEntry(&p->pvFans[i], iLit, k)
+
+#define Miaig_ForEachConstInput(i)         for (i = 0; i <= _data->nIns; i++)
+#define Miaig_ForEachInput(i)              for (i = 1; i <= _data->nIns; i++)
+#define Miaig_ForEachNode(i)               for (i = 1 + _data->nIns; i < _data->nObjs - _data->nOuts; i++)
+#define Miaig_ForEachNodeReverse(i)        for (i = _data->nObjs - p->nOuts - 1; i > 1 + _data->nIns; i--)
+#define Miaig_ForEachInputNode(i)          for (i = 1; i < _data->nObjs - _data->nOuts; i++)
+#define Miaig_ForEachNodeStart(i, s)       for (i = s; i < _data->nObjs - _data->nOuts; i++)
+#define Miaig_ForEachOutput(i)             for (i = _data->nObjs - _data->nOuts; i < _data->nObjs; i++)
+#define Miaig_ForEachNodeOutput(i)         for (i = 1 + _data->nIns; i < _data->nObjs; i++)
+#define Miaig_ForEachNodeOutputStart(i, s) for (i = s; i < _data->nObjs; i++)
+#define Miaig_ForEachObj(i)                for (i = 0; i < _data->nObjs; i++)
+#define Miaig_ForEachObjFanin(i, iLit, k)  Vi_ForEachEntry(&_data->pvFans[i], iLit, k)
+
+static inline int Rw_Lit2LitV(int *pMapV2V, int Lit) {
+    assert(Lit >= 0);
+    return Abc_Var2Lit(pMapV2V[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit));
+}
+
+static inline int Rw_Lit2LitL(int *pMapV2L, int Lit) {
+    assert(Lit >= 0);
+    return Abc_LitNotCond(pMapV2L[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit));
+}
+
+struct Miaig_Data {
+    int refcount;          // Reference counter
+    int nIns;              // primary inputs
+    int nOuts;             // primary outputs
+    int nObjs;             // all objects
+    int nObjsAlloc;        // allocated space
+    int nWords;            // the truth table size
+    int nTravIds;          // traversal ID counter
+    int *pTravIds;         // traversal IDs
+    int *pCopy;            // temp copy
+    int *pRefs;            // reference counters
+    int *pLevel;           // levels
+    int *pDist;            // distances
+    word *pTruths[3];      // truth tables
+    word *pCare;           // careset
+    word *pProd;           // product
+    vi *vOrder;            // node order
+    vi *vOrderF;           // fanin order
+    vi *vOrderF2;          // fanin order
+    vi *vTfo;              // transitive fanout cone
+    vi *pvFans;            // the array of objects' fanins
+    int *pTable;           // structural hashing table
+    int TableSize;         // the size of the hash table
+    float nTransistor;     // objective value
+    vi *pNtkMapped;        // mapped network
+};
+
+class Miaig {
+public:
+    Miaig(void);
+    ~Miaig(void);
+    Miaig(const Miaig &m);
+    Miaig &operator=(const Miaig &m);
+    Miaig(int nIns, int nOuts, int nObjsAlloc);
+#ifdef RW_ABC
+    Miaig(Gia_Man_t *pGia);
+    Miaig(Abc_Ntk_t *pNtk);
+    Miaig(Mini_Aig_t *pMiniAig);
+#endif // RW_ABC
+
+public:
+    void addref(void);
+    void release(void);
+
+private:
+    void create(int nIns, int nOuts, int nObjsAlloc);
+
+public:
+    int fromGia(Gia_Man_t *pGia);
+    int fromMiniAig(Mini_Aig_t *pMiniAig);
+
+public:
+    int &nIns(void);
+    int &nOuts(void);
+    int &nObjs(void);
+    int &nObjsAlloc(void);
+    int objIsPi(int i);
+    int objIsPo(int i);
+    int objIsNode(int i);
+    void print(void);
+    int appendObj(void);
+    void appendFanin(int i, int iLit);
+    int objFaninNum(int i);
+    int objFanin0(int i);
+    int objFanin1(int i);
+    int &objLevel(int i);
+    int &objRef(int i);
+    int &objTravId(int i);
+    int &objCopy(int i);
+    int &objDist(int i);
+    int &nTravIds(void);
+    word *objTruth(int i, int n);
+    int objType(int i);
+    int nWords(void);
+    void refObj(int iObj);
+    void derefObj(int iObj);
+    void derefObj_rec(int iObj, int iLitSkip);
+
+private:
+    int initializeLevels_rec(int iObj);
+    void initializeLevels(void);
+    void initializeRefs(void);
+    void verifyRefs(void);
+    void initializeTruth(void);
+    void initializeDists(void);
+
+private:
+    void markDfs_rec(int iObj);
+    int markDfs(void);
+    void markDistanceN_rec(int iObj, int n, int limit);
+    void markDistanceN(int Obj, int n);
+    void topoCollect_rec(int iObj);
+    vi *topoCollect(void);
+    void reduceFanins(vi *v);
+    int *createStops(void);
+    void collectSuper_rec(int iLit, int *pStop, vi *vSuper);
+    int checkConst(int iObj, word *pCare, int fVerbose);
+    void truthSimNode(int i);
+    word *truthSimNodeSubset(int i, int m);
+    word *truthSimNodeSubset2(int i, vi *vFanins, int nFanins);
+    void truthUpdate(vi *vTfo);
+    int computeTfo_rec(int iObj);
+    vi *computeTfo(int iObj);
+    word *computeCareSet(int iObj);
+    vi *createRandomOrder(void);
+    void addPair(vi *vPair, int iFan1, int iFan2);
+    int findPair(vi *vPair);
+    int updateFanins(vi *vFans, int iFan1, int iFan2, int iLit);
+    void extractBest(vi *vPairs);
+    vi *findPairs(word *pSto, int nWords);
+    int findShared(int nNewNodesMax);
+    int hashTwo(int l0, int l1, int TableSize);
+    int *hashLookup(int *pTable, int l0, int l1, int TableSize);
+
+public:
+    float countAnd2(int reset = 0);
+    float countTransistors(int reset = 0);
+    int countLevel(void);
+
+private:
+    void dupDfs_rec(Miaig &pNew, int iObj);
+    int buildNodeBalance_rec(Miaig &pNew, vi *vFanins, int begin, int end, int fCprop, int fStrash);
+
+private:
+    int buildNode(int l0, int l1, int fCprop, int fStrash);
+    int buildNodeBalance(Miaig &pNew, vi *vFanins, int fCprop, int fStrash);
+    int buildNodeCascade(Miaig &pNew, vi *vFanins, int fCprop, int fStrash);
+
+private:
+    int expandOne(int iObj, int nAddedMax, int nDist, int fVerbose);
+    int reduceOne(int iObj, int fOnlyConst, int fOnlyBuffer, int fHeuristic, int fVerbose);
+    int expandThenReduceOne(int iNode, int nFaninAddLimit, int nDist, int fVerbose);
+
+public:
+    Miaig dup(int fRemDangle, int fMapped = 0);
+    Miaig dupDfs(void);
+    Miaig dupStrash(int fCprop, int fStrash, int fCascade);
+    Miaig dupMulti(int nFaninMax_, int nGrowth);
+    Miaig expand(int nFaninAddLimitAll, int nDist, int nVerbose);
+    Miaig share(int nNewNodesMax);
+    Miaig reduce(int fVerbose);
+    Miaig expandThenReduce(int nFaninAddLimit, int nDist, int fVerbose);
+    Miaig expandShareReduce(int nFaninAddLimitAll, int nDivs, int nDist, int nVerbose);
+    Miaig rewire(int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nVerbose);
+    #ifdef RW_ABC
+    Gia_Man_t *toGia(void);
+    Abc_Ntk_t *toNtk(int fMapped = 0);
+    Mini_Aig_t *toMiniAig(void);
+#endif // RW_ABC
+
+private:
+    int *_refcount;
+    Miaig_Data *_data;
+};
+
+inline Miaig::Miaig(void)
+    : _refcount(nullptr), _data(nullptr) {
+}
+
+inline Miaig::Miaig(int nIns, int nOuts, int nObjsAlloc)
+    : Miaig() {
+    create(nIns, nOuts, nObjsAlloc);
+}
+
+#ifdef RW_ABC
+inline Miaig::Miaig(Gia_Man_t *pGia) : Miaig() {
+    fromGia(pGia);
+}
+
+inline Miaig::Miaig(Abc_Ntk_t *pNtk) : Miaig() {
+    Mini_Aig_t *pMiniAig = Abc_ManRewireMiniAigFromNtk(pNtk);
+    fromMiniAig(pMiniAig);
+    Mini_AigStop(pMiniAig);
+}
+
+inline Miaig::Miaig(Mini_Aig_t *pMiniAig) : Miaig() {
+    fromMiniAig(pMiniAig);
+}
+#endif // RW_ABC
+
+inline Miaig::~Miaig(void) {
+    release();
+}
+
+inline Miaig::Miaig(const Miaig &m)
+    : _refcount(m._refcount), _data(m._data) {
+    addref();
+}
+
+inline Miaig &Miaig::operator=(const Miaig &m) {
+    if (this == &m) {
+        return *this;
+    }
+
+    if (m._refcount) {
+        RW_XADD(m._refcount, 1);
+    }
+
+    release();
+
+    _refcount = m._refcount;
+    _data = m._data;
+
+    return *this;
+}
+
+inline void Miaig::addref(void) {
+    if (_refcount) {
+        RW_XADD(_refcount, 1);
+    }
+}
+
+inline void Miaig::release(void) {
+    if (_refcount && RW_XADD(_refcount, -1) == 1) {
+        if (_data) {
+            for (int i = 0; i < _data->nObjsAlloc; ++i)
+                if (_data->pvFans[i].ptr)
+                    free(_data->pvFans[i].ptr);
+            free(_data->pvFans);
+            Vi_Free(_data->vOrder);
+            Vi_Free(_data->vOrderF);
+            Vi_Free(_data->vOrderF2);
+            Vi_Free(_data->vTfo);
+            free(_data->pTravIds);
+            free(_data->pCopy);
+            free(_data->pRefs);
+            free(_data->pTruths[0]);
+            if (_data->pCare) free(_data->pCare);
+            if (_data->pProd) free(_data->pProd);
+            if (_data->pLevel) free(_data->pLevel);
+            if (_data->pDist) free(_data->pDist);
+            if (_data->pTable) free(_data->pTable);
+            if (_data->pNtkMapped) Vi_Free(_data->pNtkMapped);
+            delete _data;
+        }
+    }
+
+    _data = nullptr;
+    _refcount = nullptr;
+}
+
+inline int &Miaig::nIns(void) {
+    return _data->nIns;
+}
+
+inline int &Miaig::nOuts(void) {
+    return _data->nOuts;
+}
+
+inline int &Miaig::nObjs(void) {
+    return _data->nObjs;
+}
+
+inline int &Miaig::nObjsAlloc(void) {
+    return _data->nObjsAlloc;
+}
+
+inline int Miaig::objIsPi(int i) {
+    return i > 0 && i <= _data->nIns;
+}
+
+inline int Miaig::objIsPo(int i) {
+    return i >= _data->nObjs - _data->nOuts;
+}
+
+inline int Miaig::objIsNode(int i) {
+    return i > _data->nIns && i < _data->nObjs - _data->nOuts;
+}
+
+inline int Miaig::appendObj(void) {
+    assert(_data->nObjs < _data->nObjsAlloc);
+    return _data->nObjs++;
+}
+
+inline void Miaig::appendFanin(int i, int iLit) {
+    Vi_PushOrder(_data->pvFans + i, iLit);
+}
+
+inline int Miaig::objFaninNum(int i) {
+    return Vi_Size(_data->pvFans + i);
+}
+
+inline int Miaig::objFanin0(int i) {
+    return Vi_Read(_data->pvFans + i, 0);
+}
+
+inline int Miaig::objFanin1(int i) {
+    assert(objFaninNum(i) == 2);
+    return Vi_Read(_data->pvFans + i, 1);
+}
+
+inline int &Miaig::objLevel(int i) {
+    return _data->pLevel[i];
+}
+
+inline int &Miaig::objRef(int i) {
+    return _data->pRefs[i];
+}
+
+inline int &Miaig::objTravId(int i) {
+    return _data->pTravIds[i];
+}
+
+inline int &Miaig::objCopy(int i) {
+    return _data->pCopy[i];
+}
+
+inline int &Miaig::objDist(int i) {
+    return _data->pDist[i];
+}
+
+inline int &Miaig::nTravIds(void) {
+    return _data->nTravIds;
+}
+
+inline int Miaig::nWords(void) {
+    return _data->nWords;
+}
+
+inline float Miaig::countAnd2(int reset) {
+    int i, Counter = 0;
+    Miaig_ForEachNode(i) {
+        Counter += objFaninNum(i) - 1;
+    }
+    return Counter;
+}
+
+inline int Miaig::countLevel(void) {
+    initializeLevels();
+    int i, Level = -1;
+    Miaig_ForEachOutput(i) {
+        Level = Abc_MaxInt(Level, objLevel(i));
+    }
+    return Level;
+}
+
+inline word *Miaig::objTruth(int i, int n) {
+    return _data->pTruths[n] + nWords() * i;
+}
+
+inline int Miaig::objType(int i) {
+    return objTravId(i) == nTravIds();
+}
+
+} // namespace Rewire
+
+#ifdef RW_ABC
+ABC_NAMESPACE_CXX_HEADER_END
+#endif // RW_ABC
+
+#endif // REWIRE_MIAIG_H
\ No newline at end of file
diff --git a/src/opt/rar/rewire_rar.c b/src/opt/rar/rewire_rar.c
new file mode 100644
index 000000000..335fada78
--- /dev/null
+++ b/src/opt/rar/rewire_rar.c
@@ -0,0 +1,37 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_rar.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_rar.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "rewire_rar.h"
+
+ABC_NAMESPACE_IMPL_START
+
+Gia_Man_t *Gia_ManRewire(Gia_Man_t *pGia, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose) {
+    return Gia_ManRewireInt(pGia, nIters, nExpands, nGrowth, nDivs, nFaninMax, nTimeOut, nMode, nDist, nSeed, fVerbose);
+}
+
+Abc_Ntk_t *Abc_ManRewire(Abc_Ntk_t *pNtk, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose) {
+    return Abc_ManRewireInt(pNtk, nIters, nExpands, nGrowth, nDivs, nFaninMax, nTimeOut, nMode, nDist, nSeed, fVerbose);
+}
+
+Mini_Aig_t *MiniAig_ManRewire(Mini_Aig_t *pAig, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose) {
+    return MiniAig_ManRewireInt(pAig, nIters, nExpands, nGrowth, nDivs, nFaninMax, nTimeOut, nMode, nDist, nSeed, fVerbose);
+}
+
+ABC_NAMESPACE_IMPL_END
\ No newline at end of file
diff --git a/src/opt/rar/rewire_rar.h b/src/opt/rar/rewire_rar.h
new file mode 100644
index 000000000..cdfa62a7e
--- /dev/null
+++ b/src/opt/rar/rewire_rar.h
@@ -0,0 +1,47 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_rar.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_rar.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef RAR_H
+#define RAR_H
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "base/abc/abc.h"
+#include "aig/gia/gia.h"
+#include "aig/miniaig/miniaig.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START
+
+Gia_Man_t *Gia_ManRewire(Gia_Man_t *pGia, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose);
+Gia_Man_t *Gia_ManRewireInt(Gia_Man_t *pGia, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose);
+Abc_Ntk_t *Abc_ManRewire(Abc_Ntk_t *pNtk, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose);
+Abc_Ntk_t *Abc_ManRewireInt(Abc_Ntk_t *pNtk, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose);
+Mini_Aig_t *MiniAig_ManRewire(Mini_Aig_t *pAig, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose);
+Mini_Aig_t *MiniAig_ManRewireInt(Mini_Aig_t *pAig, int nIters, int nExpands, int nGrowth, int nDivs, int nFaninMax, int nTimeOut, int nMode, int nDist, int nSeed, int fVerbose);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif // RAR_H
\ No newline at end of file
diff --git a/src/opt/rar/rewire_rng.c b/src/opt/rar/rewire_rng.c
new file mode 100644
index 000000000..ec1bcb699
--- /dev/null
+++ b/src/opt/rar/rewire_rng.c
@@ -0,0 +1,53 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_rng.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_rng.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "rewire_rng.h"
+
+ABC_NAMESPACE_IMPL_START
+
+unsigned Random_Int(int fReset) {
+    static unsigned int m_z = NUMBER1;
+    static unsigned int m_w = NUMBER2;
+    if (fReset) {
+        m_z = NUMBER1;
+        m_w = NUMBER2;
+    } 
+    m_z = 36969 * (m_z & 65535) + (m_z >> 16);
+    m_w = 18000 * (m_w & 65535) + (m_w >> 16);
+    return (m_z << 16) + m_w;
+}
+
+word Random_Word(int fReset) {
+    return ((word)Random_Int(fReset) << 32) | ((word)Random_Int(fReset) << 0);
+}
+
+// This procedure should be called once with Seed > 0 to initialize the generator.
+// After initialization, the generator should be always called with Seed == 0.
+unsigned Random_Num(int Seed) {
+    static unsigned RandMask = 0;
+    if (Seed == 0)
+        return RandMask ^ Random_Int(0);
+    RandMask = Random_Int(1);
+    for (int i = 0; i < Seed; i++)
+        RandMask = Random_Int(0);
+    return RandMask;
+}
+
+ABC_NAMESPACE_IMPL_END
\ No newline at end of file
diff --git a/src/opt/rar/rewire_rng.h b/src/opt/rar/rewire_rng.h
new file mode 100644
index 000000000..c8cb1ac38
--- /dev/null
+++ b/src/opt/rar/rewire_rng.h
@@ -0,0 +1,48 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_rng.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_rng.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef RAR_RNG_H
+#define RAR_RNG_H
+
+/*************************************************************
+                 random number generation
+**************************************************************/
+
+#include "base/abc/abc.h"
+
+// Creates a sequence of random numbers.
+// http://www.codeproject.com/KB/recipes/SimpleRNG.aspx
+
+ABC_NAMESPACE_HEADER_START
+
+#define NUMBER1 3716960521u
+#define NUMBER2 2174103536u
+
+unsigned Random_Int(int fReset);
+
+word Random_Word(int fReset);
+
+// This procedure should be called once with Seed > 0 to initialize the generator.
+// After initialization, the generator should be always called with Seed == 0.
+unsigned Random_Num(int Seed);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif // RAR_RNG_H
\ No newline at end of file
diff --git a/src/opt/rar/rewire_time.h b/src/opt/rar/rewire_time.h
new file mode 100644
index 000000000..02291f492
--- /dev/null
+++ b/src/opt/rar/rewire_time.h
@@ -0,0 +1,61 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_time.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_time.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef RAR_TIME_H
+#define RAR_TIME_H
+
+/*************************************************************
+                 counting wall time
+**************************************************************/
+
+#include "base/abc/abc.h"
+
+ABC_NAMESPACE_HEADER_START
+
+static inline iword Time_Clock() {
+#if defined(__APPLE__) && defined(__MACH__)
+#define APPLE_MACH (__APPLE__ & __MACH__)
+#else
+#define APPLE_MACH 0
+#endif
+#if (defined(LIN) || defined(LIN64)) && !APPLE_MACH && !defined(__MINGW32__)
+    struct timespec ts;
+    if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0)
+        return (iword)-1;
+    iword res = ((iword)ts.tv_sec) * CLOCKS_PER_SEC;
+    res += (((iword)ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
+    return res;
+#else
+    return (iword)clock();
+#endif
+}
+
+static inline void Time_Print(const char *pStr, iword time) {
+    printf("%s = %10.2f sec", pStr, (float)1.0 * ((double)(time)) / ((double)CLOCKS_PER_SEC));
+}
+
+static inline void Time_PrintEndl(const char *pStr, iword time) {
+    Time_Print(pStr, time);
+    printf("\n");
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif // RAR_TIME_H
diff --git a/src/opt/rar/rewire_tt.h b/src/opt/rar/rewire_tt.h
new file mode 100644
index 000000000..49fb9a0cd
--- /dev/null
+++ b/src/opt/rar/rewire_tt.h
@@ -0,0 +1,230 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_tt.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_tt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef RAR_TT_H
+#define RAR_TT_H
+
+/*************************************************************
+                 truth table manipulation
+**************************************************************/
+
+#include "base/abc/abc.h"
+
+ABC_NAMESPACE_HEADER_START
+
+// the bit count for the first 256 integer numbers
+static int Tt_BitCount8[256] = {
+    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
+
+static inline int Tt_BitCount16(int i) {
+    return Tt_BitCount8[i & 0xFF] + Tt_BitCount8[i >> 8];
+}
+
+static word ss_Truths6[6] = {
+    ABC_CONST(0xAAAAAAAAAAAAAAAA),
+    ABC_CONST(0xCCCCCCCCCCCCCCCC),
+    ABC_CONST(0xF0F0F0F0F0F0F0F0),
+    ABC_CONST(0xFF00FF00FF00FF00),
+    ABC_CONST(0xFFFF0000FFFF0000),
+    ABC_CONST(0xFFFFFFFF00000000)};
+
+static inline int Tt_HexDigitNum(int n) {
+    return n <= 2 ? 1 : 1 << (n - 2);
+}
+
+static inline void Tt_Print(word *p, int nWords) {
+    int k, Digit, nDigits = nWords * 16;
+    for (k = nDigits - 1; k >= 0; k--) {
+        Digit = (int)((p[k / 16] >> ((k % 16) * 4)) & 15);
+        if (Digit < 10)
+            printf("%d", Digit);
+        else
+            printf("%c", 'A' + Digit - 10);
+    }
+    printf("\n");
+}
+
+static inline int Tt_CountOnes(word x) {
+    x = x - ((x >> 1) & ABC_CONST(0x5555555555555555));
+    x = (x & ABC_CONST(0x3333333333333333)) + ((x >> 2) & ABC_CONST(0x3333333333333333));
+    x = (x + (x >> 4)) & ABC_CONST(0x0F0F0F0F0F0F0F0F);
+    x = x + (x >> 8);
+    x = x + (x >> 16);
+    x = x + (x >> 32);
+    return (int)(x & 0xFF);
+}
+
+static inline int Tt_CountOnes2(word x) {
+    return x ? Tt_CountOnes(x) : 0;
+}
+
+static inline int Tt_CountOnesVec(word *x, int nWords) {
+    int w, Count = 0;
+    for (w = 0; w < nWords; w++)
+        Count += Tt_CountOnes2(x[w]);
+    return Count;
+}
+
+static inline int Tt_CountOnesVecMask(word *x, word *pMask, int nWords) {
+    int w, Count = 0;
+    for (w = 0; w < nWords; w++)
+        Count += Tt_CountOnes2(pMask[w] & x[w]);
+    return Count;
+}
+
+static inline void Tt_Clear(word *pOut, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        pOut[w] = 0;
+}
+
+static inline void Tt_Fill(word *pOut, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        pOut[w] = ~(word)0;
+}
+
+static inline void Tt_Dup(word *pOut, word *pIn, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        pOut[w] = pIn[w];
+}
+
+static inline void Tt_DupC(word *pOut, word *pIn, int fC, int nWords) {
+    int w;
+    if (fC)
+        for (w = 0; w < nWords; w++)
+            pOut[w] = ~pIn[w];
+    else
+        for (w = 0; w < nWords; w++)
+            pOut[w] = pIn[w];
+}
+
+static inline void Tt_Not(word *pOut, word *pIn, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        pOut[w] = ~pIn[w];
+}
+
+static inline void Tt_And(word *pOut, word *pIn1, word *pIn2, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        pOut[w] = pIn1[w] & pIn2[w];
+}
+
+static inline void Tt_Sharp(word *pOut, word *pIn, int fC, int nWords) {
+    int w;
+    if (fC)
+        for (w = 0; w < nWords; w++)
+            pOut[w] &= ~pIn[w];
+    else
+        for (w = 0; w < nWords; w++)
+            pOut[w] &= pIn[w];
+}
+
+static inline void Tt_OrXor(word *pOut, word *pIn1, word *pIn2, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        pOut[w] |= pIn1[w] ^ pIn2[w];
+}
+
+static inline int Tt_WordNum(int n) {
+    return n > 6 ? (1 << (n - 6)) : 1;
+}
+
+static inline void Tt_ElemInit(word *pTruth, int iVar, int nWords) {
+    int k;
+    if (iVar < 6)
+        for (k = 0; k < nWords; k++)
+            pTruth[k] = ss_Truths6[iVar];
+    else
+        for (k = 0; k < nWords; k++)
+            pTruth[k] = (k & (1 << (iVar - 6))) ? ~(word)0 : 0;
+}
+
+static inline int Tt_IntersectC(word *pIn1, word *pIn2, int fC, int nWords) {
+    int w;
+    if (fC) {
+        for (w = 0; w < nWords; w++)
+            if (pIn1[w] & ~pIn2[w])
+                return 1;
+    } else {
+        for (w = 0; w < nWords; w++)
+            if (pIn1[w] & pIn2[w])
+                return 1;
+    }
+    return 0;
+}
+
+static inline int Tt_Equal(word *pIn1, word *pIn2, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        if (pIn1[w] != pIn2[w])
+            return 0;
+    return 1;
+}
+
+static inline int Tt_EqualOnCare(word *pCare, word *pIn1, word *pIn2, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        if (pCare[w] & (pIn1[w] ^ pIn2[w]))
+            return 0;
+    return 1;
+}
+
+static inline int Tt_IsConst0(word *pIn, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        if (pIn[w])
+            return 0;
+    return 1;
+}
+
+static inline int Tt_IsConst1(word *pIn, int nWords) {
+    int w;
+    for (w = 0; w < nWords; w++)
+        if (pIn[w] != ~(word)0)
+            return 0;
+    return 1;
+}
+
+// read/write/flip i-th bit of a bit string table:
+static inline int Tt_GetBit(word *p, int k) {
+    return (int)(p[k >> 6] >> (k & 63)) & 1;
+}
+
+static inline void Tt_SetBit(word *p, int k) {
+    p[k >> 6] |= (((word)1) << (k & 63));
+}
+
+static inline void Tt_XorBit(word *p, int k) {
+    p[k >> 6] ^= (((word)1) << (k & 63));
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif // RAR_TT_H
\ No newline at end of file
diff --git a/src/opt/rar/rewire_vec.h b/src/opt/rar/rewire_vec.h
new file mode 100644
index 000000000..13089d01d
--- /dev/null
+++ b/src/opt/rar/rewire_vec.h
@@ -0,0 +1,226 @@
+/**CFile****************************************************************
+
+  FileName    [rewire_vec.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Re-wiring.]
+
+  Synopsis    []
+
+  Author      [Jiun-Hao Chen]
+  
+  Affiliation [National Taiwan University]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: rewire_vec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef RAR_VI_H
+#define RAR_VI_H
+
+/*************************************************************
+                 vector of 32-bit integers
+**************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+
+#include "rewire_rng.h"
+
+ABC_NAMESPACE_HEADER_START
+
+// swapping two variables
+#define RW_SWAP(Type, a, b) \
+    {                       \
+        Type t = a;         \
+        a = b;              \
+        b = t;              \
+    }
+
+typedef struct vi_ {
+    int size;
+    int cap;
+    int *ptr;
+} vi;
+
+// iterator through the entries in the vector
+#define Vi_ForEachEntry(v, entry, i)             for (i = 0; (i < (v)->size) && (((entry) = Vi_Read((v), i)), 1); i++)
+#define Vi_ForEachEntryReverse(v, entry, i)      for (i = (v)->size - 1; (i >= 0) && (((entry) = Vi_Read((v), i)), 1); i--)
+#define Vi_ForEachEntryStart(v, entry, i, start) for (i = start; (i < (v)->size) && (((entry) = Vi_Read((v), i)), 1); i++)
+#define Vi_ForEachEntryStop(v, entry, i, stop)   for (i = 0; (i < stop) && (((entry) = Vi_Read((v), i)), 1); i++)
+
+static inline void Vi_Start(vi *v, int cap) {
+    v->size = 0;
+    v->cap = cap;
+    v->ptr = (int *)malloc(sizeof(int) * cap);
+}
+
+static inline vi *Vi_Alloc(int cap) {
+    vi *v = (vi *)malloc(sizeof(vi));
+    Vi_Start(v, cap);
+    return v;
+}
+
+static inline void Vi_Stop(vi *v) {
+    if (v->ptr) free(v->ptr);
+}
+
+static inline void Vi_Free(vi *v) {
+    if (v->ptr) free(v->ptr);
+    free(v);
+}
+
+static inline int Vi_Size(vi *v) {
+    return v->size;
+}
+
+static inline int Vi_Space(vi *v) {
+    return v->cap - v->size;
+}
+
+static inline int *Vi_Array(vi *v) {
+    return v->ptr;
+}
+
+static inline int Vi_Read(vi *v, int k) {
+    assert(k < v->size);
+    return v->ptr[k];
+}
+
+static inline void Vi_Write(vi *v, int k, int e) {
+    assert(k < v->size);
+    v->ptr[k] = e;
+}
+
+static inline void Vi_Shrink(vi *v, int k) {
+    assert(k <= v->size);
+    v->size = k;
+} // only safe to shrink !!
+
+static inline int Vi_Pop(vi *v) {
+    assert(v->size > 0);
+    return v->ptr[--v->size];
+}
+
+static inline void Vi_Grow(vi *v) {
+    if (v->size < v->cap)
+        return;
+    int newcap = (v->cap < 4) ? 8 : (v->cap / 2) * 3;
+    v->ptr = (int *)realloc(v->ptr, sizeof(int) * newcap);
+    if (v->ptr == NULL) {
+        printf("Failed to realloc memory from %.1f MB to %.1f MB.\n", 4.0 * v->cap / (1 << 20), (float)4.0 * newcap / (1 << 20));
+        fflush(stdout);
+    }
+    v->cap = newcap;
+}
+
+static inline vi *Vi_Dup(vi *v) {
+    vi *pNew = Vi_Alloc(v->size);
+    memcpy(pNew->ptr, v->ptr, sizeof(int) * v->size);
+    pNew->size = v->size;
+    return pNew;
+}
+
+static inline void Vi_Push(vi *v, int e) {
+    Vi_Grow(v);
+    v->ptr[v->size++] = e;
+}
+
+static inline void Vi_PushTwo(vi *v, int e1, int e2) {
+    Vi_Push(v, e1);
+    Vi_Push(v, e2);
+}
+
+static inline void Vi_PushArray(vi *v, int *p, int n) {
+    for (int i = 0; i < n; i++)
+        Vi_Push(v, p[i]);
+}
+
+static inline void Vi_PushOrder(vi *v, int e) {
+    Vi_Push(v, e);
+    if (v->size > 1)
+        for (int i = v->size - 2; i >= 0; i--) {
+            if (v->ptr[i] > v->ptr[i + 1]) {
+                RW_SWAP(int, v->ptr[i], v->ptr[i + 1])
+            } else {
+                break;
+            }
+        }
+}
+
+static inline void Vi_Fill(vi *v, int n, int fill) {
+    int i;
+    Vi_Shrink(v, 0);
+    for (i = 0; i < n; i++)
+        Vi_Push(v, fill);
+}
+
+static inline int Vi_Drop(vi *v, int i) {
+    assert(i >= 0 && i < v->size);
+    int Entry = v->ptr[i];
+    for (; i < v->size - 1; i++)
+        v->ptr[i] = v->ptr[i + 1];
+    Vi_Shrink(v, v->size - 1);
+    return Entry;
+}
+
+static inline int Vi_Find(vi *v, int e) {
+    int j;
+    for (j = 0; j < v->size; j++)
+        if (v->ptr[j] == e)
+            return j;
+    return -1;
+}
+
+static inline int Vi_Remove(vi *v, int e) {
+    int j = Vi_Find(v, e);
+    if (j == -1)
+        return 0;
+    Vi_Drop(v, j);
+    return 1;
+}
+
+static inline void Vi_Randomize(vi *v) {
+    for (int i = 0; i < v->size; i++) {
+        int iRand = Random_Num(0) % v->size;
+        RW_SWAP(int, v->ptr[iRand], v->ptr[i]);
+    }
+}
+
+static inline void Vi_Reverse(vi *v) {
+    int i, j;
+    for (i = 0, j = v->size - 1; i < j; i++, j--)
+        RW_SWAP(int, v->ptr[i], v->ptr[j]);
+}
+
+static inline void Vi_Print(vi *v) {
+    printf("Array with %d entries:", v->size);
+    int i, entry;
+    Vi_ForEachEntry(v, entry, i)
+        printf(" %d", entry);
+    printf("\n");
+}
+
+static inline void Vi_SelectSort(vi *v) {
+    int *pArray = Vi_Array(v);
+    int nSize = Vi_Size(v);
+    int temp, i, j, best_i;
+    for (i = 0; i < nSize - 1; i++) {
+        best_i = i;
+        for (j = i + 1; j < nSize; j++)
+            if (pArray[j] < pArray[best_i])
+                best_i = j;
+        temp = pArray[i];
+        pArray[i] = pArray[best_i];
+        pArray[best_i] = temp;
+    }
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif // RAR_VI_H
\ No newline at end of file
diff --git a/src/opt/rrr/rrr.h b/src/opt/rrr/rrr.h
new file mode 100644
index 000000000..f737b7ffc
--- /dev/null
+++ b/src/opt/rrr/rrr.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "rrrAndNetwork.h"
+#include "rrrScheduler.h"
+#include "rrrOptimizer.h"
+#include "rrrBddAnalyzer.h"
+#include "rrrBddMspfAnalyzer.h"
+#include "rrrAnalyzer.h"
+#include "rrrSatSolver.h"
+#include "rrrSimulator.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk>
+  void Perform(Ntk *pNtk, Parameter const *pPar) {
+    assert(!pPar->fUseBddCspf || !pPar->fUseBddMspf);
+    if(pPar->fUseBddCspf) {
+      Scheduler<Ntk, rrr::Optimizer<Ntk, rrr::BddAnalyzer<Ntk>>> sch(pNtk, pPar);
+      sch.Run();
+    } else if(pPar->fUseBddMspf) {
+      Scheduler<Ntk, rrr::Optimizer<Ntk, rrr::BddMspfAnalyzer<Ntk>>> sch(pNtk, pPar);
+      sch.Run();
+    } else {
+      Scheduler<Ntk, rrr::Optimizer<Ntk, rrr::Analyzer<Ntk, rrr::Simulator<Ntk>, rrr::SatSolver<Ntk>>>> sch(pNtk, pPar);
+      sch.Run();
+    }
+  }
+  
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrAbc.h b/src/opt/rrr/rrrAbc.h
new file mode 100644
index 000000000..307d5e0d0
--- /dev/null
+++ b/src/opt/rrr/rrrAbc.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "aig/gia/gia.h"
+#include "base/main/main.h"
+#include "base/cmd/cmd.h"
+
+#include "rrrUtils.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk>
+  void GiaReader(Gia_Man_t *pGia, Ntk *pNtk) {
+    int i;
+    Gia_Obj_t *pObj;
+    pNtk->Reserve(Gia_ManObjNum(pGia));
+    Gia_ManConst0(pGia)->Value = pNtk->GetConst0();
+    Gia_ManForEachObj1(pGia, pObj, i) {
+      if(Gia_ObjIsCi(pObj)) {
+        pObj->Value = pNtk->AddPi();
+      } else if(Gia_ObjIsCo(pObj)) {
+        pNtk->AddPo(Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj));
+      } else {
+        // TODO: support XOR (and BUF and MUX?), maybe create another function
+        pObj->Value = pNtk->AddAnd(Gia_ObjFanin0(pObj)->Value, Gia_ObjFanin1(pObj)->Value, Gia_ObjFaninC0(pObj), Gia_ObjFaninC1(pObj));
+      }
+    }
+  }
+
+  template <typename Ntk>
+  Gia_Man_t *CreateGia(Ntk *pNtk) {
+    Gia_Man_t *pGia = Gia_ManStart(pNtk->GetNumNodes());
+    Gia_ManHashStart(pGia);
+    std::vector<int> v(pNtk->GetNumNodes());
+    v[0] = Gia_ManConst0Lit();
+    pNtk->ForEachPi([&](int id) {
+      v[id] = Gia_ManAppendCi(pGia);
+    });
+    pNtk->ForEachInt([&](int id) {
+      assert(pNtk->GetNodeType(id) == rrr::AND);
+      int x = -1;
+      pNtk->ForEachFanin(id, [&](int fi, bool c) {
+        if(x == -1) {
+          x = Abc_LitNotCond(v[fi], c);
+        } else {
+          x = Gia_ManHashAnd(pGia, x, Abc_LitNotCond(v[fi], c));
+        }
+      });
+      if(x == -1) {
+        x = Abc_LitNot(v[0]);
+      }
+      v[id] = x;
+    });
+    pNtk->ForEachPoDriver([&](int fi, bool c) {
+      Gia_ManAppendCo(pGia, Abc_LitNotCond(v[fi], c));
+    });
+    Gia_ManHashStop(pGia);
+    return pGia;  
+  }
+
+  template <typename Ntk>
+  void Abc9Execute(Ntk *pNtk, std::string Command) {
+    Abc_Frame_t *pAbc = Abc_FrameGetGlobalFrame();
+    Abc_FrameUpdateGia(pAbc, CreateGia(pNtk));
+    if(Abc_FrameIsBatchMode()) {
+      int r = Cmd_CommandExecute(pAbc, Command.c_str());
+      assert(r == 0);
+    } else {
+      Abc_FrameSetBatchMode(1);
+      int r = Cmd_CommandExecute(pAbc, Command.c_str());
+      assert(r == 0);
+      Abc_FrameSetBatchMode(0);
+    }
+    pNtk->Read(Abc_FrameReadGia(pAbc), GiaReader<Ntk>);
+  }
+
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrAnalyzer.h b/src/opt/rrr/rrrAnalyzer.h
new file mode 100644
index 000000000..0689a3d11
--- /dev/null
+++ b/src/opt/rrr/rrrAnalyzer.h
@@ -0,0 +1,104 @@
+#pragma once
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk, typename Sim, typename Sol>
+  class Analyzer {
+  private:
+    // pointer to network
+    Ntk *pNtk;
+
+    // parameters
+    bool nVerbose;
+
+    // data
+    Sim sim;
+    Sol sol;
+
+  public:
+    // constructors
+    Analyzer(Parameter const *pPar);
+    void UpdateNetwork(Ntk *pNtk_, bool fSame);
+
+    // checks
+    bool CheckRedundancy(int id, int idx);
+    bool CheckFeasibility(int id, int fi, bool c);
+  };
+
+  /* {{{ Constructors */
+  
+  template <typename Ntk, typename Sim, typename Sol>
+  Analyzer<Ntk, Sim, Sol>::Analyzer(Parameter const *pPar) :
+    pNtk(NULL),
+    nVerbose(pPar->nAnalyzerVerbose),
+    sim(pPar),
+    sol(pPar) {
+  }
+  
+  template <typename Ntk, typename Sim, typename Sol>
+  void Analyzer<Ntk, Sim, Sol>::UpdateNetwork(Ntk *pNtk_, bool fSame) {
+    pNtk = pNtk_;
+    sim.UpdateNetwork(pNtk, fSame);
+    sol.UpdateNetwork(pNtk, fSame);
+  }
+
+  /* }}} */
+
+  /* {{{ Checks */
+  
+  template <typename Ntk, typename Sim, typename Sol>
+  bool Analyzer<Ntk, Sim, Sol>::CheckRedundancy(int id, int idx) {
+    if(sim.CheckRedundancy(id, idx)) {
+      if(nVerbose) {
+        std::cout << "node " << id << " fanin " << (pNtk->GetCompl(id, idx)? "!": "") << pNtk->GetFanin(id, idx) << " index " << idx << " seems redundant" << std::endl;
+      }
+      SatResult r = sol.CheckRedundancy(id, idx);
+      if(r == UNSAT) {
+        if(nVerbose) {
+          std::cout << "node " << id << " fanin " << (pNtk->GetCompl(id, idx)? "!": "") << pNtk->GetFanin(id, idx) << " index " << idx << " is redundant" << std::endl;
+        }
+        return true;
+      }
+      if(r == SAT) {
+        if(nVerbose) {
+          std::cout << "node " << id << " fanin " << (pNtk->GetCompl(id, idx)? "!": "") << pNtk->GetFanin(id, idx) << " index " << idx << " is NOT redundant" << std::endl;
+        }
+        sim.AddCex(sol.GetCex());
+      }
+    }
+    return false;
+  }
+  
+  template <typename Ntk, typename Sim, typename Sol>
+  bool Analyzer<Ntk, Sim, Sol>::CheckFeasibility(int id, int fi, bool c) {
+    if(sim.CheckFeasibility(id, fi, c)) {
+      if(nVerbose) {
+        std::cout << "node " << id << " fanin " << (c? "!": "") << fi << " seems feasible" << std::endl;
+      }
+      SatResult r = sol.CheckFeasibility(id, fi, c);
+      if(r == UNSAT) {
+        if(nVerbose) {
+          std::cout << "node " << id << " fanin " << (c? "!": "") << fi << " is feasible" << std::endl;
+        }
+        return true;
+      }
+      if(r == SAT) {
+        if(nVerbose) {
+          std::cout << "node " << id << " fanin " << (c? "!": "") << fi << " is NOT feasible" << std::endl;
+        }
+        sim.AddCex(sol.GetCex());
+      }
+    }
+    return false;
+  }
+
+  /* }}} */
+  
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrAndNetwork.h b/src/opt/rrr/rrrAndNetwork.h
new file mode 100644
index 000000000..00afd2386
--- /dev/null
+++ b/src/opt/rrr/rrrAndNetwork.h
@@ -0,0 +1,1497 @@
+#pragma once
+
+#include <utility>
+#include <list>
+#include <map>
+#include <algorithm>
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  class AndNetwork {
+  private:
+    // aliases
+    using itr = std::list<int>::iterator;
+    using citr = std::list<int>::const_iterator;
+    using ritr = std::list<int>::reverse_iterator;
+    using critr = std::list<int>::const_reverse_iterator;
+    using Callback = std::function<void(Action const &)>;
+
+    // network data
+    int nNodes; // number of allocated nodes
+    std::vector<int> vPis;
+    std::list<int> lInts; // internal nodes in topological order
+    std::set<int> sInts; // internal nodes as a set
+    std::vector<int> vPos;
+    std::vector<std::vector<int>> vvFaninEdges; // complementable edges, no duplicated fanins allowed (including complements), and nodes without fanins are treated as const-1
+    std::vector<int> vRefs; // reference count (number of fanouts)
+
+    // mark for network traversal
+    bool fLockTrav;
+    unsigned iTrav;
+    std::vector<unsigned> vTrav;
+
+    // flag used during constant propagation
+    bool fPropagating;
+
+    // callback functions
+    std::vector<Callback> vCallbacks;
+
+    // network backups
+    std::vector<AndNetwork> vBackups;
+
+    // conversion between node and edge
+    int  Node2Edge(int id, bool c) const { return (id << 1) + (int)c; }
+    int  Edge2Node(int f)          const { return f >> 1;             }
+    bool EdgeIsCompl(int f)        const { return f & 1;              }
+
+    // other private functions
+    int  CreateNode();
+    void SortInts(itr it);
+    unsigned StartTraversal(int n = 1);
+    void EndTraversal();
+    void ForEachTfiRec(int id, std::function<void(int)> const &f);
+    void TakenAction(Action const &action) const;
+
+  public:
+    // constructors
+    AndNetwork();
+    AndNetwork(AndNetwork const &x);
+    AndNetwork &operator=(AndNetwork const &x);
+
+    // initialization APIs (should not be called after optimization has started)
+    void Clear();
+    void Reserve(int nReserve);
+    int  AddPi();
+    int  AddAnd(int id0, int id1, bool c0, bool c1);
+    int  AddPo(int id, bool c);
+    template <typename Ntk, typename Reader>
+    void Read(Ntk *pFrom, Reader &reader);
+
+    // network properties
+    bool UseComplementedEdges() const;
+    int  GetNumNodes() const; // number of allocated nodes (max id + 1)
+    int  GetNumPis() const;
+    int  GetNumInts() const;
+    int  GetNumPos() const;
+    int  GetConst0() const;
+    int  GetPi(int idx) const;
+    int  GetPo(int idx) const;
+    std::vector<int> GetPis() const;
+    std::vector<int> GetInts() const;
+    std::vector<int> GetPisInts() const;
+    std::vector<int> GetPos() const;
+    
+    // node properties
+    bool IsPi(int id) const;
+    bool IsInt(int id) const;
+    bool IsPo(int id) const;
+    NodeType GetNodeType(int id) const;
+    bool IsPoDriver(int id) const;
+    int  GetPiIndex(int id) const;
+    int  GetIntIndex(int id) const;
+    int  GetPoIndex(int id) const;
+    int  GetNumFanins(int id) const;
+    int  GetNumFanouts(int id) const;
+    int  GetFanin(int id, int idx) const;
+    bool GetCompl(int id, int idx) const;
+    int  FindFanin(int id, int fi) const;
+    bool IsReconvergent(int id);
+    std::vector<int> GetNeighbors(int id, bool fPis, int nHops);
+    template <template <typename...> typename Container, typename ... Ts, template <typename...> typename Container2, typename ... Ts2>
+    bool IsReachable(Container<Ts...> const &srcs, Container2<Ts2...> const &dsts);
+    template <template <typename...> typename Container, typename ... Ts, template <typename...> typename Container2, typename ... Ts2>
+    std::vector<int> GetInners(Container<Ts...> const &srcs, Container2<Ts2...> const &dsts);
+
+    // network traversal
+    void ForEachPi(std::function<void(int)> const &func) const;
+    void ForEachInt(std::function<void(int)> const &func) const;
+    void ForEachIntReverse(std::function<void(int)> const &func) const;
+    void ForEachPiInt(std::function<void(int)> const &func) const;
+    void ForEachPo(std::function<void(int)> const &func) const;
+    template <typename Func>
+    void ForEachPoDriver(Func const &func) const;
+    template <typename Func>
+    void ForEachFanin(int id, Func const &func) const;
+    template <typename Func>
+    void ForEachFaninIdx(int id, Func const &func) const; // func(index of fi in fanin list of id, fi[, c])
+    template <typename Func>
+    void ForEachFanout(int id, bool fPos, Func const &func) const;
+    template <typename Func>
+    void ForEachFanoutRidx(int id, bool fPos, Func const &func) const; // func(fo[, c], index of id in fanin list of fo)
+    void ForEachTfi(int id, bool fPis, std::function<void(int)> const &func);
+    template <template <typename...> typename Container, typename ... Ts>
+    void ForEachTfiEnd(int id, Container<Ts...> const &ends, std::function<void(int)> const &func);
+    void ForEachTfo(int id, bool fPos, std::function<void(int)> const &func);
+    void ForEachTfoReverse(int id, bool fPos, std::function<void(int)> const &func);
+    void ForEachTfoUpdate(int id, bool fPos, std::function<bool(int)> const &func);
+    template <template <typename...> typename Container, typename ... Ts>
+    void ForEachTfos(Container<Ts...> const &ids, bool fPos, std::function<void(int)> const &func);
+    template <template <typename...> typename Container, typename ... Ts>
+    void ForEachTfosUpdate(Container<Ts...> const &ids, bool fPos, std::function<bool(int)> const &func);
+
+    // extraction
+    template <template <typename...> typename Container, typename ... Ts>
+    AndNetwork *Extract(Container<Ts...> const &ids, std::vector<int> const &vInputs, std::vector<int> const &vOutputs);
+
+    // actions
+    void RemoveFanin(int id, int idx);
+    void RemoveUnused(int id, bool fRecursive = false, bool fSweeping = false);
+    void RemoveBuffer(int id);
+    void RemoveConst(int id);
+    void AddFanin(int id, int fi, bool c);
+    void TrivialCollapse(int id);
+    void TrivialDecompose(int id);
+    template <typename Func>
+    void SortFanins(int id, Func const &cost);
+    std::pair<std::vector<int>, std::vector<bool>> Insert(AndNetwork *pNtk, std::vector<int> const &vInputs, std::vector<bool> const &vCompls, std::vector<int> const &vOutputs);
+
+    // Network cleanup
+    void Propagate(int id = -1); // all nodes unless specified
+    void Sweep(bool fPropagate = true);
+
+    // save & load
+    int  Save(int slot = -1); // slot is assigned automatically unless specified
+    void Load(int slot);
+    void PopBack(); // deletes the last entry of backups
+
+    // misc
+    void AddCallback(Callback const &callback);
+    void Print() const;
+  };
+
+  /* {{{ Private functions */
+
+  inline int AndNetwork::CreateNode() {
+    // TODO: reuse already allocated but dead nodes? or perform garbage collection?
+    vvFaninEdges.emplace_back();
+    vRefs.push_back(0);
+    assert(!check_int_max(nNodes));
+    return nNodes++;
+  }
+
+  void AndNetwork::SortInts(itr it) {
+    ForEachFanin(*it, [&](int fi) {
+      itr it2 = std::find(it, lInts.end(), fi);
+      if(it2 != lInts.end()) {
+        lInts.erase(it2);
+        it2 = lInts.insert(it, fi);
+        SortInts(it2);
+      }
+    });
+  }
+
+  inline unsigned AndNetwork::StartTraversal(int n) {
+    assert(!fLockTrav);
+    fLockTrav = true;
+    do {
+      for(int i = 0; i < n; i++) {
+        iTrav++;
+        if(iTrav == 0) {
+          vTrav.clear();
+          break;
+        }
+      }
+    } while(iTrav == 0);
+    vTrav.resize(nNodes);
+    return iTrav - n + 1;
+  }
+  
+  inline void AndNetwork::EndTraversal() {
+    assert(fLockTrav);
+    fLockTrav = false;
+  }
+
+  void AndNetwork::ForEachTfiRec(int id, std::function<void(int)> const &func) {
+    for(int fi_edge: vvFaninEdges[id]) {
+      int fi = Edge2Node(fi_edge);
+      if(vTrav[fi] == iTrav) {
+        continue;
+      }
+      func(fi);
+      vTrav[fi] = iTrav;
+      ForEachTfiRec(fi, func);
+    }
+  }
+  
+  inline void AndNetwork::TakenAction(Action const &action) const {
+    for(Callback const &callback: vCallbacks) {
+      callback(action);
+    }
+  }
+
+  /* }}} */
+
+  /* {{{ Constructors */
+
+  AndNetwork::AndNetwork() :
+    nNodes(0),
+    fLockTrav(false),
+    iTrav(0),
+    fPropagating(false) {
+    // add constant node
+    vvFaninEdges.emplace_back();
+    vRefs.push_back(0);
+    nNodes++;
+  }
+
+  AndNetwork::AndNetwork(AndNetwork const &x) :
+    fLockTrav(false),
+    iTrav(0),
+    fPropagating(false) {
+    nNodes       = x.nNodes;
+    vPis         = x.vPis;
+    lInts        = x.lInts;
+    sInts        = x.sInts;
+    vPos         = x.vPos;
+    vvFaninEdges = x.vvFaninEdges;
+    vRefs        = x.vRefs;
+  }
+  
+  AndNetwork &AndNetwork::operator=(AndNetwork const &x) {
+    nNodes       = x.nNodes;
+    vPis         = x.vPis;
+    lInts        = x.lInts;
+    sInts        = x.sInts;
+    vPos         = x.vPos;
+    vvFaninEdges = x.vvFaninEdges;
+    vRefs        = x.vRefs;
+    return *this;
+  }
+  
+  /* }}} */
+
+  /* {{{ Initialization APIs */
+
+  void AndNetwork::Clear() {
+    nNodes = 0;
+    vPis.clear();
+    lInts.clear();
+    sInts.clear();
+    vPos.clear();
+    vvFaninEdges.clear();
+    vRefs.clear();
+    fLockTrav = false;
+    iTrav = 0;
+    vTrav.clear();
+    fPropagating = false;
+    vCallbacks.clear();
+    vBackups.clear();
+    // add constant node
+    vvFaninEdges.emplace_back();
+    vRefs.push_back(0);
+    nNodes++;
+  }
+
+  void AndNetwork::Reserve(int nReserve) {
+    vvFaninEdges.reserve(nReserve);
+    vRefs.reserve(nReserve);
+  }
+  
+  inline int AndNetwork::AddPi() {
+    vPis.push_back(nNodes);
+    vvFaninEdges.emplace_back();
+    vRefs.push_back(0);
+    assert(!check_int_max(nNodes));
+    return nNodes++;
+  }
+  
+  inline int AndNetwork::AddAnd(int id0, int id1, bool c0, bool c1) {
+    assert(id0 < nNodes);
+    assert(id1 < nNodes);
+    assert(id0 != id1);
+    lInts.push_back(nNodes);
+    sInts.insert(nNodes);
+    vRefs[id0]++;
+    vRefs[id1]++;
+    vvFaninEdges.emplace_back(std::initializer_list<int>({Node2Edge(id0, c0), Node2Edge(id1, c1)}));
+    vRefs.push_back(0);
+    assert(!check_int_max(nNodes));
+    return nNodes++;
+  }
+
+  inline int AndNetwork::AddPo(int id, bool c) {
+    assert(id < nNodes);
+    vPos.push_back(nNodes);
+    vRefs[id]++;
+    vvFaninEdges.emplace_back(std::initializer_list<int>({Node2Edge(id, c)}));
+    vRefs.push_back(0);
+    assert(!check_int_max(nNodes));
+    return nNodes++;
+  }
+
+  template <typename Ntk, typename Reader>
+  void AndNetwork::Read(Ntk *pFrom, Reader &reader) {
+    Clear();
+    reader(pFrom, this);
+  }
+  
+  /* }}} */
+  
+  /* {{{ Network properties */
+  
+  inline bool AndNetwork::UseComplementedEdges() const {
+    return true;
+  }
+  
+  inline int AndNetwork::GetNumNodes() const {
+    return nNodes;
+  }
+
+  inline int AndNetwork::GetNumPis() const {
+    return int_size(vPis);
+  }
+  
+  inline int AndNetwork::GetNumInts() const {
+    return int_size(lInts);
+  }
+  
+  inline int AndNetwork::GetNumPos() const {
+    return int_size(vPos);
+  }
+
+  inline int AndNetwork::GetConst0() const {
+    return 0;
+  }
+  
+  inline int AndNetwork::GetPi(int idx) const {
+    return vPis[idx];
+  }
+
+  inline int AndNetwork::GetPo(int idx) const {
+    return vPos[idx];
+  }
+
+  inline std::vector<int> AndNetwork::GetPis() const {
+    return vPis;
+  }
+
+  inline std::vector<int> AndNetwork::GetInts() const {
+    return std::vector<int>(lInts.begin(), lInts.end());
+  }
+  
+  inline std::vector<int> AndNetwork::GetPisInts() const {
+    std::vector<int> vPisInts = vPis;
+    vPisInts.insert(vPisInts.end(), lInts.begin(), lInts.end());
+    return vPisInts;
+  }
+  
+  inline std::vector<int> AndNetwork::GetPos() const {
+    return vPos;
+  }
+  
+  /* }}} */
+
+  /* {{{ Node properties */
+  
+  inline bool AndNetwork::IsPi(int id) const {
+    return GetNumFanins(id) == 0 && std::find(vPis.begin(), vPis.end(), id) != vPis.end();
+  }
+
+  inline bool AndNetwork::IsInt(int id) const {
+    return sInts.count(id);
+  }
+
+  inline bool AndNetwork::IsPo(int id) const {
+    return GetNumFanouts(id) == 0 && std::find(vPos.begin(), vPos.end(), id) != vPos.end();
+  }
+  
+  inline NodeType AndNetwork::GetNodeType(int id) const {
+    if(IsPi(id)) {
+      return PI;
+    }
+    if(IsPo(id)) {
+      return PO;
+    }
+    return AND;
+  }
+
+  inline bool AndNetwork::IsPoDriver(int id) const {
+    for(int po: vPos) {
+      if(GetFanin(po, 0) == id) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  inline int AndNetwork::GetPiIndex(int id) const {
+    assert(IsPi(id));
+    assert(check_int_size(vPis));
+    std::vector<int>::const_iterator it = std::find(vPis.begin(), vPis.end(), id);
+    assert(it != vPis.end());
+    return std::distance(vPis.begin(), it);
+  }
+  
+  inline int AndNetwork::GetIntIndex(int id) const {
+    assert(check_int_size(lInts));
+    int index = 0;
+    citr it = lInts.begin();
+    for(; it != lInts.end(); it++) {
+      if(*it == id) {
+        break;
+      }
+      index++;
+    }
+    assert(it != lInts.end());
+    return index;
+  }
+
+  inline int AndNetwork::GetPoIndex(int id) const {
+    assert(IsPo(id));
+    assert(check_int_size(vPos));
+    std::vector<int>::const_iterator it = std::find(vPos.begin(), vPos.end(), id);
+    assert(it != vPos.end());
+    return std::distance(vPos.begin(), it);
+  }
+  
+  inline int AndNetwork::GetNumFanins(int id) const {
+    return int_size(vvFaninEdges[id]);
+  }
+
+  inline int AndNetwork::GetNumFanouts(int id) const {
+    return vRefs[id];
+  }
+
+  inline int AndNetwork::GetFanin(int id, int idx) const {
+    return Edge2Node(vvFaninEdges[id][idx]);
+  }
+
+  inline bool AndNetwork::GetCompl(int id, int idx) const {
+    return EdgeIsCompl(vvFaninEdges[id][idx]);
+  }
+
+  inline int AndNetwork::FindFanin(int id, int fi) const {
+    for(int idx = 0; idx < GetNumFanins(id); idx++) {
+      if(GetFanin(id, idx) == fi) {
+        return idx;
+      }
+    }
+    return -1;
+  }
+  
+  inline bool AndNetwork::IsReconvergent(int id) {
+    if(GetNumFanouts(id) <= 1) {
+      return false;
+    }
+    unsigned iTravStart = StartTraversal(GetNumFanouts(id));
+    int idx = 0;
+    ForEachFanout(id, false, [&](int fo) {
+      vTrav[fo] = iTravStart + idx;
+      idx++;
+    });
+    if(idx <= 1) {
+      // less than two fanouts excluding POs
+      EndTraversal();
+      return false;
+    }
+    citr it = lInts.begin();
+    while(vTrav[*it] < iTravStart && it != lInts.end()) {
+      it++;
+    }
+    it++;
+    for(; it != lInts.end(); it++) {
+      for(int fi_edge: vvFaninEdges[*it]) {
+        int fi = Edge2Node(fi_edge);
+        if(vTrav[fi] >= iTravStart) {
+          if(vTrav[*it] >= iTravStart && vTrav[*it] != vTrav[fi]) {
+            EndTraversal();
+            return true;
+          }
+          vTrav[*it] = vTrav[fi];
+        }
+      }
+    }
+    EndTraversal();
+    return false;
+  }
+
+  inline std::vector<int> AndNetwork::GetNeighbors(int id, bool fPis, int nHops) {
+    StartTraversal();
+    vTrav[id] = iTrav;
+    std::vector<int> vPrevs, vNexts;
+    vNexts.push_back(id);
+    for(int i = 0; i < nHops; i++) {
+      vPrevs.swap(vNexts);
+      for(int id: vPrevs) {
+        ForEachFanin(id, [&](int fi) {
+          if(vTrav[fi] != iTrav) {
+            vNexts.push_back(fi);
+            vTrav[fi] = iTrav;
+          }
+        });
+        ForEachFanout(id, false, [&](int fo) {
+          if(vTrav[fo] != iTrav) {
+            vNexts.push_back(fo);
+            vTrav[fo] = iTrav;
+          }
+        });
+      }
+      vPrevs.clear();
+    }
+    vTrav[id] = 0;
+    std::vector<int> v;
+    if(fPis) {
+      ForEachPiInt([&](int id) {
+        if(vTrav[id] == iTrav) {
+          v.push_back(id);
+        }
+      });
+    } else {
+      ForEachInt([&](int id) {
+        if(vTrav[id] == iTrav) {
+          v.push_back(id);
+        }
+      });
+    }
+    EndTraversal();
+    return v;
+  }
+
+  template <template <typename...> typename Container, typename ... Ts, template <typename...> typename Container2, typename ... Ts2>
+  inline bool AndNetwork::IsReachable(Container<Ts...> const &srcs, Container2<Ts2...> const &dsts) {
+    if(srcs.empty() || dsts.empty()) {
+      return false;
+    }
+    // mark destinations
+    unsigned iTravStart = StartTraversal(2);
+    for(int id: dsts) {
+      vTrav[id] = iTravStart;
+    }
+    // mark sources
+    for(int id: srcs) {
+      if(vTrav[id] == iTravStart) {
+        EndTraversal();
+        return true;
+      }
+      vTrav[id] = iTrav;
+    }
+    // find the first source
+    citr it = lInts.begin();
+    while(vTrav[*it] != iTrav && it != lInts.end()) {
+      it++;
+    }
+    // check if sources are reachable to destinations
+    for(; it != lInts.end(); it++) {
+      if(vTrav[*it] == iTrav) {
+        continue;
+      }
+      for(int fi_edge: vvFaninEdges[*it]) {
+        if(vTrav[Edge2Node(fi_edge)] == iTrav) {
+          if(vTrav[*it] == iTravStart) {
+            EndTraversal();
+            return true;
+          }
+          vTrav[*it] = iTrav;
+          break;
+        }
+      }
+    }
+    for(int po: vPos) {
+      if(vTrav[po] == iTrav) {
+        continue;
+      }
+      if(vTrav[GetFanin(po, 0)] == iTrav) {
+        if(vTrav[po] == iTravStart) {
+          EndTraversal();
+          return true;
+        }
+        vTrav[po] = iTrav;
+      }
+    }
+    EndTraversal();
+    return false;
+  }
+
+  template <template <typename...> typename Container, typename ... Ts, template <typename...> typename Container2, typename ... Ts2>
+  inline std::vector<int> AndNetwork::GetInners(Container<Ts...> const &srcs, Container2<Ts2...> const &dsts) {
+    // this includes sources and destinations that are connected
+    if(srcs.empty() || dsts.empty()) {
+      return std::vector<int>();
+    }
+    unsigned iTravStart = StartTraversal(4);
+    unsigned iDst = iTravStart;
+    unsigned iTfo = iTravStart + 1;
+    unsigned iInner = iTravStart + 2;
+    // mark destinations (to prevent nodes between destinations to sources being included)
+    for(int id: dsts) {
+      vTrav[id] = iDst;
+    }
+    // mark TFOs of sources until destinations, which will be marekd as inner
+    for(int id: srcs) {
+      if(vTrav[id] == iDst) {
+        vTrav[id] = iInner;
+      } else {
+        vTrav[id] = iTfo;
+      }
+    }
+    citr it = lInts.begin();
+    while(vTrav[*it] != iTfo && it != lInts.end()) {
+      it++;
+    }
+    for(; it != lInts.end(); it++) {
+      if(vTrav[*it] >= iTfo) { // TFO or inner
+        continue;
+      }
+      for(int fi_edge: vvFaninEdges[*it]) {
+        if(vTrav[Edge2Node(fi_edge)] == iTfo) {
+          if(vTrav[*it] == iDst) {
+            vTrav[*it] = iInner;
+          } else {
+            vTrav[*it] = iTfo;
+          }
+          break;
+        }
+      }
+    }
+    // traverse TFIs of connected destinations
+    std::vector<int> vInners;
+    for(int id: dsts) {
+      if(vTrav[id] == iInner) {
+        vInners.push_back(id);
+        vTrav[id] = iTrav;
+        ForEachTfiRec(id, [&](int fi) {
+          if(vTrav[fi] == iTfo || vTrav[fi] == iInner) {
+            vInners.push_back(fi);
+          }
+        });
+      }
+    }
+    EndTraversal();
+    return vInners;
+  }
+
+  /* }}} */
+
+  /* {{{ Network traversal */
+
+  inline void AndNetwork::ForEachPi(std::function<void(int)> const &func) const {
+    for(int pi: vPis) {
+      func(pi);
+    }
+  }
+  
+  inline void AndNetwork::ForEachInt(std::function<void(int)> const &func) const {
+    for(int id: lInts) {
+      func(id);
+    }
+  }
+
+  inline void AndNetwork::ForEachIntReverse(std::function<void(int)> const &func) const {
+    for(critr it = lInts.rbegin(); it != lInts.rend(); it++) {
+      func(*it);
+    }
+  }
+
+  inline void AndNetwork::ForEachPiInt(std::function<void(int)> const &func) const {
+    for(int pi: vPis) {
+      func(pi);
+    }
+    for(int id: lInts) {
+      func(id);
+    }
+  }
+  
+  inline void AndNetwork::ForEachPo(std::function<void(int)> const &func) const {
+    for(int po: vPos) {
+      func(po);
+    }
+  }
+
+  template <typename Func>
+  inline void AndNetwork::ForEachPoDriver(Func const &func) const {
+    static_assert(is_invokable<Func, int>::value || is_invokable<Func, int, bool>::value, "for each edge function format error");
+    for(int po: vPos) {
+      if constexpr(is_invokable<Func, int>::value) {
+        func(GetFanin(po, 0));
+      } else if constexpr(is_invokable<Func, int, bool>::value) {
+        func(GetFanin(po, 0), GetCompl(po, 0));
+      }
+    }
+  }
+
+  template <typename Func>
+  inline void AndNetwork::ForEachFanin(int id, Func const &func) const {
+    static_assert(is_invokable<Func, int>::value || is_invokable<Func, int, bool>::value, "for each edge function format error");
+    for(int fi_edge: vvFaninEdges[id]) {
+      if constexpr(is_invokable<Func, int>::value) {
+        func(Edge2Node(fi_edge));
+      } else if constexpr(is_invokable<Func, int, bool>::value) {
+        func(Edge2Node(fi_edge), EdgeIsCompl(fi_edge));
+      }
+    }
+  }
+
+  template <typename Func>
+  inline void AndNetwork::ForEachFaninIdx(int id, Func const &func) const {
+    static_assert(is_invokable<Func, int, int>::value || is_invokable<Func, int, int, bool>::value, "for each edge function format error");
+    for(int idx = 0; idx < GetNumFanins(id); idx++) {
+      if constexpr(is_invokable<Func, int, int>::value) {
+        func(idx, GetFanin(id, idx));
+      } else if constexpr(is_invokable<Func, int, int, bool>::value) {
+        func(idx, GetFanin(id, idx), GetCompl(id, idx));
+      }
+    }
+  }
+  
+  template <typename Func>
+  inline void AndNetwork::ForEachFanout(int id, bool fPos, Func const &func) const {
+    static_assert(is_invokable<Func, int>::value || is_invokable<Func, int, bool>::value, "for each edge function format error");
+    if(vRefs[id] == 0) {
+      return;
+    }
+    citr it = lInts.begin();
+    if(IsInt(id)) {
+      it = std::find(it, lInts.end(), id);
+      assert(it != lInts.end());
+      it++;
+    }
+    int nRefs = vRefs[id];
+    for(; nRefs != 0 && it != lInts.end(); it++) {
+      int idx = FindFanin(*it, id);
+      if(idx >= 0) {
+        if constexpr(is_invokable<Func, int>::value) {
+          func(*it);
+        } else if constexpr(is_invokable<Func, int, bool>::value) {
+          func(*it, GetCompl(*it, idx));
+        }
+        nRefs--;
+      }
+    }
+    if(fPos && nRefs != 0) {
+      for(int po: vPos) {
+        if(GetFanin(po, 0) == id) {
+          if constexpr(is_invokable<Func, int>::value) {
+            func(po);
+          } else if constexpr(is_invokable<Func, int, bool>::value) {
+            func(po, GetCompl(po, 0));
+          }
+          nRefs--;
+          if(nRefs == 0) {
+            break;
+          }
+        }
+      }
+    }
+    assert(!fPos || nRefs == 0);
+  }
+
+  template <typename Func>
+  inline void AndNetwork::ForEachFanoutRidx(int id, bool fPos, Func const &func) const {
+    static_assert(is_invokable<Func, int, int>::value || is_invokable<Func, int, bool, int>::value, "for each edge function format error");
+    if(vRefs[id] == 0) {
+      return;
+    }
+    citr it = lInts.begin();
+    if(IsInt(id)) {
+      it = std::find(it, lInts.end(), id);
+      assert(it != lInts.end());
+      it++;
+    }
+    int nRefs = vRefs[id];
+    for(; nRefs != 0 && it != lInts.end(); it++) {
+      int idx = FindFanin(*it, id);
+      if(idx >= 0) {
+        if constexpr(is_invokable<Func, int, int>::value) {
+          func(*it, idx);
+        } else if constexpr(is_invokable<Func, int, bool, int>::value) {
+          func(*it, GetCompl(*it, idx), idx);
+        }
+        nRefs--;
+      }
+    }
+    if(fPos && nRefs != 0) {
+      for(int po: vPos) {
+        if(GetFanin(po, 0) == id) {
+          if constexpr(is_invokable<Func, int, int>::value) {
+            func(po, 0);
+          } else if constexpr(is_invokable<Func, int, bool, int>::value) {
+            func(po, GetCompl(po, 0), 0);
+          }
+          nRefs--;
+          if(nRefs == 0) {
+            break;
+          }
+        }
+      }
+    }
+    assert(!fPos || nRefs == 0);
+  }
+
+  inline void AndNetwork::ForEachTfi(int id, bool fPis, std::function<void(int)> const &func) {
+    // this does not include id itself
+    StartTraversal();
+    if(!fPis) {
+      for(int pi: vPis) {
+        vTrav[pi] = iTrav;
+      }
+    }
+    ForEachTfiRec(id, func);
+    EndTraversal();
+  }
+
+  template <template <typename...> typename Container, typename ... Ts>
+  inline void AndNetwork::ForEachTfiEnd(int id, Container<Ts...> const &ends, std::function<void(int)> const &func) {
+    // this does not include id itself
+    StartTraversal();
+    for(int end: ends) {
+      vTrav[end] = iTrav;
+    }
+    ForEachTfiRec(id, func);
+    EndTraversal();
+  }
+
+  inline void AndNetwork::ForEachTfo(int id, bool fPos, std::function<void(int)> const &func) {
+    // this does not include id itself
+    if(vRefs[id] == 0) {
+      return;
+    }
+    StartTraversal();
+    vTrav[id] = iTrav;
+    citr it = std::find(lInts.begin(), lInts.end(), id);
+    assert(it != lInts.end());
+    it++;
+    for(; it != lInts.end(); it++) {
+      for(int fi_edge: vvFaninEdges[*it]) {
+        if(vTrav[Edge2Node(fi_edge)] == iTrav) {
+          func(*it);
+          vTrav[*it] = iTrav;
+          break;
+        }
+      }
+    }
+    if(fPos) {
+      for(int po: vPos) {
+        if(vTrav[GetFanin(po, 0)] == iTrav) {
+          func(po);
+          vTrav[po] = iTrav;
+        }
+      }
+    }
+    EndTraversal();
+  }
+
+  inline void AndNetwork::ForEachTfoReverse(int id, bool fPos, std::function<void(int)> const &func) {
+    // this does not include id itself
+    if(vRefs[id] == 0) {
+      return;
+    }
+    StartTraversal();
+    vTrav[id] = iTrav;
+    citr it = std::find(lInts.begin(), lInts.end(), id);
+    assert(it != lInts.end());
+    it++;
+    for(; it != lInts.end(); it++) {
+      for(int fi_edge: vvFaninEdges[*it]) {
+        if(vTrav[Edge2Node(fi_edge)] == iTrav) {
+          vTrav[*it] = iTrav;
+          break;
+        }
+      }
+    }
+    if(fPos) {
+      for(int po: vPos) {
+        if(vTrav[GetFanin(po, 0)] == iTrav) {
+          vTrav[po] = iTrav;
+        }
+      }
+    }
+    EndTraversal(); // release here so func can call IsReconvergent
+    unsigned iTravTfo = iTrav;
+    if(fPos) {
+      // use reverse order even for POs
+      for(std::vector<int>::const_reverse_iterator it = vPos.rbegin(); it != vPos.rend(); it++) {
+        assert(vTrav[*it] <= iTravTfo); // make sure func does not touch vTrav of preceding nodes
+        if(vTrav[*it] == iTravTfo) {
+          func(*it);
+        }
+      }
+    }
+    for(critr it = lInts.rbegin(); *it != id; it++) {
+      assert(vTrav[*it] <= iTravTfo); // make sure func does not touch vTrav of preceding nodes
+      if(vTrav[*it] == iTravTfo) {
+        func(*it);
+      }
+    }
+  }
+
+  inline void AndNetwork::ForEachTfoUpdate(int id, bool fPos, std::function<bool(int)> const &func) {
+    // this does not include id itself
+    if(vRefs[id] == 0) {
+      return;
+    }
+    StartTraversal();
+    vTrav[id] = iTrav;
+    citr it = std::find(lInts.begin(), lInts.end(), id);
+    assert(it != lInts.end());
+    it++;
+    for(; it != lInts.end(); it++) {
+      for(int fi_edge: vvFaninEdges[*it]) {
+        if(vTrav[Edge2Node(fi_edge)] == iTrav) {
+          if(func(*it)) {
+            vTrav[*it] = iTrav;
+          }
+          break;
+        }
+      }
+    }
+    if(fPos) {
+      for(int po: vPos) {
+        if(vTrav[GetFanin(po, 0)] == iTrav) {
+          if(func(po)) {
+            vTrav[po] = iTrav;
+          }
+        }
+      }
+    }
+    EndTraversal();
+  }
+
+  template <template <typename...> typename Container, typename ... Ts>
+  inline void AndNetwork::ForEachTfos(Container<Ts...> const &ids, bool fPos, std::function<void(int)> const &func) {
+    // this includes ids themselves
+    StartTraversal();
+    for(int id: ids) {
+      vTrav[id] = iTrav;
+    }
+    citr it = lInts.begin();
+    while(vTrav[*it] != iTrav && it != lInts.end()) {
+      it++;
+    }
+    for(; it != lInts.end(); it++) {
+      if(vTrav[*it] == iTrav) {
+        func(*it);
+      } else {
+        for(int fi_edge: vvFaninEdges[*it]) {
+          if(vTrav[Edge2Node(fi_edge)] == iTrav) {
+            func(*it);
+            vTrav[*it] = iTrav;
+            break;
+          }
+        }
+      }
+    }
+    if(fPos) {
+      for(int po: vPos) {
+        if(vTrav[po] == iTrav || vTrav[GetFanin(po, 0)] == iTrav) {
+          func(po);
+          vTrav[po] = iTrav;
+        }
+      }
+    }
+    EndTraversal();
+  }
+  
+  template <template <typename...> typename Container, typename ... Ts>
+  inline void AndNetwork::ForEachTfosUpdate(Container<Ts...> const &ids, bool fPos, std::function<bool(int)> const &func) {
+    // this includes ids themselves
+    StartTraversal();
+    for(int id: ids) {
+      vTrav[id] = iTrav;
+    }
+    citr it = lInts.begin();
+    while(vTrav[*it] != iTrav && it != lInts.end()) {
+      it++;
+    }
+    for(; it != lInts.end(); it++) {
+      if(vTrav[*it] == iTrav) {
+        if(!func(*it)) {
+          vTrav[*it] = 0;
+        }
+      } else {
+        for(int fi_edge: vvFaninEdges[*it]) {
+          if(vTrav[Edge2Node(fi_edge)] == iTrav) {
+            if(func(*it)) {
+              vTrav[*it] = iTrav;
+            }
+            break;
+          }
+        }
+      }
+    }
+    if(fPos) {
+      for(int po: vPos) {
+        if(vTrav[po] == iTrav) {
+          if(!func(po)) {
+            vTrav[po] = 0;
+          }
+        } else if(vTrav[GetFanin(po, 0)] == iTrav) {
+          if(func(po)) {
+            vTrav[po] = iTrav;
+          }
+        }
+      }
+    }
+    EndTraversal();
+  }
+
+  /* }}} */
+
+  /* {{{ Extraction */
+
+  template <template <typename...> typename Container, typename ... Ts>
+  AndNetwork *AndNetwork::Extract(Container<Ts...> const &ids, std::vector<int> const &vInputs, std::vector<int> const &vOutputs) {
+    AndNetwork *pNtk = new AndNetwork;
+    pNtk->Reserve(int_size(vInputs) + int_size(ids) + int_size(vOutputs));
+    std::map<int, int> m;
+    m[GetConst0()] = pNtk->GetConst0();
+    for(int id: vInputs) {
+      m[id] = pNtk->AddPi();
+    }
+    StartTraversal();
+    for(int id: ids) {
+      vTrav[id] = iTrav;
+    }
+    ForEachInt([&](int id) {
+      if(vTrav[id] == iTrav) {
+        m[id] = pNtk->CreateNode();
+        pNtk->lInts.push_back(m[id]);
+        pNtk->sInts.insert(m[id]);
+        pNtk->vvFaninEdges[m[id]].resize(GetNumFanins(id));
+        ForEachFaninIdx(id, [&](int idx, int fi, bool c) {
+          assert(m.count(fi));
+          pNtk->vvFaninEdges[m[id]][idx] = pNtk->Node2Edge(m[fi], c);
+          pNtk->vRefs[m[fi]]++;
+        });
+      }
+    });
+    EndTraversal();
+    for(int id: vOutputs) {
+      assert(m.count(id));
+      pNtk->AddPo(m[id], false);
+    }
+    return pNtk;
+  }
+  
+  /* }}} */
+  
+  /* {{{ Actions */
+  
+  void AndNetwork::RemoveFanin(int id, int idx) {
+    Action action;
+    action.type = REMOVE_FANIN;
+    action.id = id;
+    action.idx = idx;
+    int fi = GetFanin(id, idx);
+    bool c = GetCompl(id, idx);
+    action.fi = fi;
+    action.c = c;
+    vRefs[fi]--;
+    vvFaninEdges[id].erase(vvFaninEdges[id].begin() + idx);
+    TakenAction(action);
+  }
+
+  void AndNetwork::RemoveUnused(int id, bool fRecursive, bool fSweeping) {
+    assert(vRefs[id] == 0);
+    Action action;
+    action.type = REMOVE_UNUSED;
+    action.id = id;
+    ForEachFanin(id, [&](int fi) {
+      action.vFanins.push_back(fi);
+      vRefs[fi]--;
+    });
+    vvFaninEdges[id].clear();
+    if(!fSweeping) {
+      itr it = std::find(lInts.begin(), lInts.end(), id);
+      lInts.erase(it);
+    }
+    sInts.erase(id);
+    TakenAction(action);
+    if(fRecursive) {
+      for(int fi: action.vFanins) {
+        if(vRefs[fi] == 0 && IsInt(fi)) {
+          RemoveUnused(fi, fRecursive, fSweeping);
+        }
+      }
+    }
+  }
+
+  void AndNetwork::RemoveBuffer(int id) {
+    assert(GetNumFanins(id) == 1);
+    assert(!fPropagating || fLockTrav);
+    int fi = GetFanin(id, 0);
+    bool c = GetCompl(id, 0);
+    // check if it is buffering constant
+    if(fi == GetConst0()) {
+      RemoveConst(id);
+      return;
+    }
+    // remove if substitution would lead to duplication with the same polarity
+    ForEachFanoutRidx(id, false, [&](int fo, bool foc, int idx) {
+      int idx2 = FindFanin(fo, fi);
+      if(idx2 != -1 && GetCompl(fo, idx2) == (c ^ foc)) {
+        RemoveFanin(fo, idx);
+        if(fPropagating && GetNumFanins(fo) == 1) {
+          vTrav[fo] = iTrav;
+        }
+      }
+    });
+    // substitute node with fanin or const-0
+    Action action;
+    action.type = REMOVE_BUFFER;
+    action.id = id;
+    action.fi = fi;
+    action.c = c;
+    ForEachFanoutRidx(id, true, [&](int fo, bool foc, int idx) {
+      action.vFanouts.push_back(fo);
+      int idx2 = FindFanin(fo, fi);
+      if(idx2 != -1) { // substitute with const-0 in case of duplication
+        assert(GetCompl(fo, idx2) != (c ^ foc)); // of a different polarity
+        vRefs[GetConst0()]++;
+        vvFaninEdges[fo][idx] = Node2Edge(GetConst0(), 0);
+        if(fPropagating) {
+          vTrav[fo] = iTrav;
+        }
+      } else { // otherwise, substitute with fanin
+        vvFaninEdges[fo][idx] = Node2Edge(fi, c ^ foc);
+        vRefs[fi]++;
+      }
+    });
+    // remove node
+    vRefs[id] = 0;
+    vRefs[fi]--;
+    vvFaninEdges[id].clear();
+    if(!fPropagating) {
+      itr it = std::find(lInts.begin(), lInts.end(), id);
+      lInts.erase(it);
+    }
+    sInts.erase(id);
+    TakenAction(action);
+  }
+
+  void AndNetwork::RemoveConst(int id) {
+    assert(GetNumFanins(id) == 0 || FindFanin(id, GetConst0()) != -1);
+    assert(!fPropagating || fLockTrav);
+    bool c = (GetNumFanins(id) == 0);
+    // just remove immediately if polarity is true but not PO
+    ForEachFanoutRidx(id, false, [&](int fo, bool foc, int idx) {
+      if(c ^ foc) {
+        assert(!IsPo(fo));
+        RemoveFanin(fo, idx);
+        if(fPropagating && GetNumFanins(fo) <= 1) {
+          vTrav[fo] = iTrav;
+        }
+      }
+    });
+    // substitute with constant
+    Action action;
+    action.type = REMOVE_CONST;
+    action.id = id;
+    ForEachFanoutRidx(id, true, [&](int fo, bool foc, int idx) {
+      action.vFanouts.push_back(fo);
+      vRefs[GetConst0()]++;
+      vvFaninEdges[fo][idx] = Node2Edge(GetConst0(), c ^ foc);
+      if(fPropagating) {
+        vTrav[fo] = iTrav;
+      }
+    });
+    // remove node
+    vRefs[id] = 0;
+    ForEachFanin(id, [&](int fi) {
+      vRefs[fi]--;
+      action.vFanins.push_back(fi);
+    });
+    vvFaninEdges[id].clear();
+    if(!fPropagating) {
+      itr it = std::find(lInts.begin(), lInts.end(), id);
+      lInts.erase(it);
+    }
+    sInts.erase(id);
+    TakenAction(action);
+  }
+
+  void AndNetwork::AddFanin(int id, int fi, bool c) {
+    assert(FindFanin(id, fi) == -1); // no duplication
+    assert(fi != GetConst0() || !c); // no const-1
+    Action action;
+    action.type = ADD_FANIN;
+    action.id = id;
+    action.idx = GetNumFanins(id);
+    action.fi = fi;
+    action.c = c;
+    itr it = std::find(lInts.begin(), lInts.end(), id);
+    itr it2 = std::find(it, lInts.end(), fi);
+    if(it2 != lInts.end()) {
+      lInts.erase(it2);
+      it2 = lInts.insert(it, fi);
+      SortInts(it2);
+    }
+    vRefs[fi]++;
+    vvFaninEdges[id].push_back(Node2Edge(fi, c));
+    TakenAction(action);
+  }
+
+  void AndNetwork::TrivialCollapse(int id) {
+    for(int idx = 0; idx < GetNumFanins(id);) {
+      int fi_edge = vvFaninEdges[id][idx];
+      int fi = Edge2Node(fi_edge);
+      bool c = EdgeIsCompl(fi_edge);
+      if(!IsPi(fi) && !c && vRefs[fi] == 1) {
+        Action action;
+        action.type = TRIVIAL_COLLAPSE;
+        action.id = id;
+        action.idx = idx;
+        action.fi = fi;
+        action.c = c;
+        std::vector<int>::iterator it = vvFaninEdges[id].begin() + idx;
+        it = vvFaninEdges[id].erase(it);
+        vvFaninEdges[id].insert(it, vvFaninEdges[fi].begin(), vvFaninEdges[fi].end());
+        ForEachFanin(fi, [&](int fi) {
+          action.vFanins.push_back(fi);
+        });
+        // remove collapsed fanin
+        vRefs[fi] = 0;
+        vvFaninEdges[fi].clear();
+        lInts.erase(std::find(lInts.begin(), lInts.end(), fi));
+        sInts.erase(fi);
+        TakenAction(action);
+      } else {
+        idx++;
+      }
+    }
+  }
+
+  void AndNetwork::TrivialDecompose(int id) {
+    while(GetNumFanins(id) > 2) {
+      Action action;
+      action.type = TRIVIAL_DECOMPOSE;
+      action.id = id;
+      action.idx = GetNumFanins(id) - 2;
+      int new_fi = CreateNode();
+      action.fi = new_fi;
+      int fi_edge1 = vvFaninEdges[id].back();
+      vvFaninEdges[id].pop_back();
+      int fi_edge0 = vvFaninEdges[id].back();
+      vvFaninEdges[id].pop_back();
+      vvFaninEdges[new_fi].push_back(fi_edge0);
+      action.vFanins.push_back(Edge2Node(fi_edge0));
+      vvFaninEdges[new_fi].push_back(fi_edge1);
+      action.vFanins.push_back(Edge2Node(fi_edge1));
+      vvFaninEdges[id].push_back(Node2Edge(new_fi, false));
+      vRefs[new_fi]++;
+      itr it = std::find(lInts.begin(), lInts.end(), id);
+      lInts.insert(it, new_fi);
+      sInts.insert(new_fi);
+      TakenAction(action);
+    }
+  }
+
+  template <typename Func>
+  void AndNetwork::SortFanins(int id, Func const &comp) {
+    static_assert(is_invokable<Func, int, int>::value || is_invokable<Func, int, bool, int, bool>::value, "fanin cost function format error");
+    std::vector<int> vFaninEdges = vvFaninEdges[id];
+    std::sort(vvFaninEdges[id].begin(), vvFaninEdges[id].end(), [&](int i, int j) {
+      if constexpr(is_invokable<Func, int, int>::value) {
+        return comp(Edge2Node(i), Edge2Node(j));
+      } else if constexpr(is_invokable<Func, int, bool, int, bool>::value) {
+        return comp(Edge2Node(i), EdgeIsCompl(i), Edge2Node(j), EdgeIsCompl(j));
+      }
+    });
+    if(vFaninEdges == vvFaninEdges[id]) {
+      return;
+    }
+    Action action;
+    action.type = SORT_FANINS;
+    action.id = id;
+    assert(check_int_size(vFaninEdges));
+    for(int fanin_edge: vvFaninEdges[id]) {
+      std::vector<int>::const_iterator it = std::find(vFaninEdges.begin(), vFaninEdges.end(), fanin_edge);
+      action.vIndices.push_back(std::distance(vFaninEdges.cbegin(), it));
+    }
+    TakenAction(action);
+  }
+
+  std::pair<std::vector<int>, std::vector<bool>> AndNetwork::Insert(AndNetwork *pNtk, std::vector<int> const &vInputs, std::vector<bool> const &vCompls, std::vector<int> const &vOutputs) {
+    Reserve(nNodes + pNtk->GetNumInts());
+    std::map<int, std::pair<int, bool>> m;
+    m[pNtk->GetConst0()] = std::make_pair(GetConst0(), false);
+    assert(pNtk->GetNumPis() == int_size(vInputs));
+    assert(vInputs.size() == vCompls.size());
+    for(int i = 0; i < pNtk->GetNumPis(); i++) {
+      assert(IsInt(vInputs[i]) || IsPi(vInputs[i]));
+      m[pNtk->GetPi(i)] = std::make_pair(vInputs[i], vCompls[i]);
+    }
+    pNtk->ForEachInt([&](int id) {
+      int id2 = CreateNode();
+      lInts.push_back(id2);
+      sInts.insert(id2);
+      vvFaninEdges[id2].resize(pNtk->GetNumFanins(id));
+      pNtk->ForEachFaninIdx(id, [&](int idx, int fi, bool c) {
+        assert(m.count(fi));
+        vvFaninEdges[id2][idx] = Node2Edge(m[fi].first, c ^ m[fi].second);
+        vRefs[m[fi].first]++;
+      });
+      m[id] = std::make_pair(id2, false);
+    });
+    assert(pNtk->GetNumPos() == int_size(vOutputs));
+    std::vector<int> vNewOutputs(pNtk->GetNumPos());
+    std::vector<bool> vNewCompls(pNtk->GetNumPos());
+    for(int i = 0; i < pNtk->GetNumPos(); i++) {
+      int id = vOutputs[i];
+      int po = pNtk->GetPo(i);
+      assert(m.count(pNtk->GetFanin(po, 0)));
+      int fi = m[pNtk->GetFanin(po, 0)].first;
+      bool c = pNtk->GetCompl(po, 0) ^ m[pNtk->GetFanin(po, 0)].second;
+      assert(id != fi);
+      vNewOutputs[i] = fi;
+      vNewCompls[i] = c;
+      // remove if substitution would lead to duplication with the same polarity
+      ForEachFanoutRidx(id, false, [&](int fo, bool foc, int idx) {
+        int idx2 = FindFanin(fo, fi);
+        if(idx2 != -1 && GetCompl(fo, idx2) == (c ^ foc)) {
+          RemoveFanin(fo, idx);
+        }
+      });
+      ForEachFanoutRidx(id, true, [&](int fo, bool foc, int idx) {
+        int idx2 = FindFanin(fo, fi);
+        if(idx2 != -1) { // substitute with const-0 in case of duplication
+          assert(GetCompl(fo, idx2) != (c ^ foc)); // of a different polarity
+          vRefs[GetConst0()]++;
+          vvFaninEdges[fo][idx] = Node2Edge(GetConst0(), 0);
+        } else { // otherwise, substitute with fanin
+          vvFaninEdges[fo][idx] = Node2Edge(fi, c ^ foc);
+          vRefs[fi]++;
+          // sort internal nodes
+          itr it = std::find(lInts.begin(), lInts.end(), id);
+          itr it2 = std::find(it, lInts.end(), fi);
+          if(it2 != lInts.end()) {
+            lInts.erase(it2);
+            it2 = lInts.insert(it, fi);
+            SortInts(it2);
+          }
+        }
+      });
+      vRefs[id] = 0;
+    }
+    Action action;
+    action.type = INSERT;
+    action.vFanins = vInputs;
+    action.vFanouts = vOutputs;
+    TakenAction(action);
+    for(int id: vOutputs) {
+      RemoveUnused(id, true);
+    }
+    return std::make_pair(std::move(vNewOutputs), std::move(vNewCompls));
+  }
+
+  /* }}} */
+
+  /* {{{ Network cleanup */
+  
+  void AndNetwork::Propagate(int id) {
+    StartTraversal();
+    itr it;
+    if(id == -1) {
+      ForEachInt([&](int id) {
+        if(GetNumFanins(id) <= 1 || FindFanin(id, GetConst0()) != -1) {
+          vTrav[id] = iTrav;
+        }
+      });
+      it = lInts.begin();
+      while(vTrav[*it] != iTrav && it != lInts.end()) {
+        it++;
+      }
+    } else {
+      vTrav[id] = iTrav;
+      it = std::find(lInts.begin(), lInts.end(), id);
+    }
+    fPropagating = true;
+    while(it != lInts.end()) {
+      if(vTrav[*it] == iTrav) {
+        if(GetNumFanins(*it) == 1) {
+          RemoveBuffer(*it);
+        } else {
+          RemoveConst(*it);
+        }
+        it = lInts.erase(it);
+      } else {
+        it++;
+      }
+    }
+    fPropagating = false;
+    EndTraversal();
+  }
+
+  void AndNetwork::Sweep(bool fPropagate) {
+    if(fPropagate) {
+      Propagate();
+    }
+    for(ritr it = lInts.rbegin(); it != lInts.rend();) {
+      if(vRefs[*it] == 0) {
+        RemoveUnused(*it, false, true);
+        it = ritr(lInts.erase(--it.base()));
+      } else {
+        it++;
+      }
+    }
+  }
+  
+  /* }}} */
+
+  /* {{{ Save & load */
+
+  int AndNetwork::Save(int slot) {
+    Action action;
+    action.type = SAVE;
+    if(slot < 0) {
+      slot = int_size(vBackups);
+      vBackups.push_back(*this);
+      assert(check_int_size(vBackups));
+    } else {
+      assert(slot < int_size(vBackups));
+      vBackups[slot] = *this;
+    }
+    action.idx = slot;
+    TakenAction(action);
+    return slot;
+  }
+
+  void AndNetwork::Load(int slot) {
+    assert(slot >= 0);
+    assert(slot < int_size(vBackups));
+    Action action;
+    action.type = LOAD;
+    action.idx = slot;
+    *this = vBackups[slot];
+    TakenAction(action);
+  }
+
+  void AndNetwork::PopBack() {
+    assert(!vBackups.empty());
+    Action action;
+    action.type = POP_BACK;
+    action.idx = int_size(vBackups) - 1;
+    vBackups.pop_back();
+    TakenAction(action);
+  }
+
+  /* }}} */
+  
+  /* {{{ Misc */
+
+  void AndNetwork::AddCallback(Callback const &callback) {
+    vCallbacks.push_back(callback);
+  }
+  
+  void AndNetwork::Print() const {
+    std::cout << "inputs: " << vPis << std::endl;
+    ForEachInt([&](int id) {
+      std::cout << "node " << id << ": ";
+      PrintComplementedEdges(std::bind(&AndNetwork::ForEachFanin<std::function<void(int, bool)>>, this, id, std::placeholders::_1));
+      std::cout << " (ref = " << vRefs[id] << ")";
+      std::cout << std::endl;
+    });
+    std::cout << "outputs: ";
+    PrintComplementedEdges(std::bind(&AndNetwork::ForEachPoDriver<std::function<void(int, bool)>>, this, std::placeholders::_1));
+    std::cout << std::endl;
+  }
+
+  /* }}} */
+
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrBddAnalyzer.h b/src/opt/rrr/rrrBddAnalyzer.h
new file mode 100644
index 000000000..a9112a9ba
--- /dev/null
+++ b/src/opt/rrr/rrrBddAnalyzer.h
@@ -0,0 +1,634 @@
+#pragma once
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+#include "rrrBddManager.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk>
+  class BddAnalyzer {
+  private:
+    // aliases
+    using lit = int;
+    static constexpr lit LitMax = 0xffffffff;
+
+    // pointer to network
+    Ntk *pNtk;
+    
+    // parameters
+    int nVerbose;
+    
+    // data
+    NewBdd::Man *pBdd;
+    int target;
+    std::vector<lit> vFs;
+    std::vector<lit> vGs;
+    std::vector<std::vector<lit>> vvCs;
+    bool fResim;
+    std::vector<bool> vUpdates;
+    std::vector<bool> vGUpdates;
+    std::vector<bool> vCUpdates;
+
+    // backups
+    std::vector<BddAnalyzer> vBackups;
+
+    // BDD utils
+    void IncRef(lit x) const;
+    void DecRef(lit x) const;
+    void Assign(lit &x, lit y) const;
+    void CopyVec(std::vector<lit> &x, std::vector<lit> const &y) const;
+    void DelVec(std::vector<lit> &v) const;
+    void CopyVecVec(std::vector<std::vector<lit>> &x, std::vector<std::vector<lit>> const &y) const;
+    void DelVecVec(std::vector<std::vector<lit>> &v) const;
+    lit  Xor(lit x, lit y) const;
+
+    // callback
+    void ActionCallback(Action const &action);
+
+    // allocation
+    void Allocate();
+
+    // simulation
+    void SimulateNode(int id, std::vector<lit> &v) const;
+    void Simulate();
+    
+    // CSPF computation
+    bool ComputeG(int id);
+    void ComputeC(int id);
+    void CspfNode(int id);
+    void Cspf(int id = -1, bool fC = true);
+
+    // save & load
+    void Save(int slot);
+    void Load(int slot);
+    void PopBack();
+
+  public:
+    // constructors
+    BddAnalyzer();
+    BddAnalyzer(Parameter const *pPar);
+    ~BddAnalyzer();
+    void UpdateNetwork(Ntk *pNtk_, bool fSame);
+
+    // checks
+    bool CheckRedundancy(int id, int idx);
+    bool CheckFeasibility(int id, int fi, bool c);
+  };
+  
+  /* {{{ BDD utils */
+  
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::IncRef(lit x) const {
+    if(x != LitMax) {
+      pBdd->IncRef(x);
+    }
+  }
+  
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::DecRef(lit x) const {
+    if(x != LitMax) {
+      pBdd->DecRef(x);
+    }
+  }
+  
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::Assign(lit &x, lit y) const {
+    DecRef(x);
+    x = y;
+    IncRef(x);
+  }
+
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::CopyVec(std::vector<lit> &x, std::vector<lit> const &y) const {
+    for(size_t i = y.size(); i < x.size(); i++) {
+      DecRef(x[i]);
+    }
+    x.resize(y.size(), LitMax);
+    for(size_t i = 0; i < y.size(); i++) {
+      if(x[i] != y[i]) {
+        DecRef(x[i]);
+        x[i] = y[i];
+        IncRef(x[i]);
+      }
+    }
+  }
+
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::DelVec(std::vector<lit> &v) const {
+    for(lit x: v) {
+      DecRef(x);
+    }
+    v.clear();
+  }
+
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::CopyVecVec(std::vector<std::vector<lit>> &x, std::vector<std::vector<lit>> const &y) const {
+    for(size_t i = y.size(); i < x.size(); i++) {
+      DelVec(x[i]);
+    }
+    x.resize(y.size());
+    for(size_t i = 0; i < y.size(); i++) {
+      CopyVec(x[i], y[i]);
+    }
+  }
+
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::DelVecVec(std::vector<std::vector<lit>> &v) const {
+    for(size_t i = 0; i < v.size(); i++) {
+      DelVec(v[i]);
+    }
+    v.clear();
+  }
+  
+  template <typename Ntk>
+  inline int BddAnalyzer<Ntk>::Xor(lit x, lit y) const {
+    lit f = pBdd->And(x, pBdd->LitNot(y));
+    pBdd->IncRef(f);
+    lit g = pBdd->And(pBdd->LitNot(x), y);
+    pBdd->IncRef(g);
+    lit r = pBdd->Or(f, g);
+    pBdd->DecRef(f);
+    pBdd->DecRef(g);
+    return r;
+  }
+  
+  /* }}} */
+
+  /* {{{ Callback */
+
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::ActionCallback(Action const &action) {
+    switch(action.type) {
+    case REMOVE_FANIN:
+      vUpdates[action.id] = true;
+      vGUpdates[action.fi] = true;
+      DecRef(vvCs[action.id][action.idx]);
+      vvCs[action.id].erase(vvCs[action.id].begin() + action.idx);
+      break;
+    case REMOVE_UNUSED:
+      if(vGUpdates[action.id] || vCUpdates[action.id]) {
+        for(int fi: action.vFanins) {
+          vGUpdates[fi] = true;
+        }
+      }
+      Assign(vFs[action.id], LitMax);
+      Assign(vGs[action.id], LitMax);
+      DelVec(vvCs[action.id]);
+      break;
+    case REMOVE_BUFFER:
+      if(vUpdates[action.id]) {
+        for(int fo: action.vFanouts) {
+          vUpdates[fo] = true;
+          vCUpdates[fo] = true;
+        }
+      }
+      if(vGUpdates[action.id] || vCUpdates[action.id]) {
+        vGUpdates[action.fi] = true;
+      }
+      Assign(vFs[action.id], LitMax);
+      Assign(vGs[action.id], LitMax);
+      DelVec(vvCs[action.id]);
+      break;
+    case REMOVE_CONST:
+      if(vUpdates[action.id]) {
+        for(int fo: action.vFanouts) {
+          vUpdates[fo] = true;
+          vCUpdates[fo] = true;
+        }
+      }
+      for(int fi: action.vFanins) {
+        vGUpdates[fi] = true;
+      }
+      Assign(vFs[action.id], LitMax);
+      Assign(vGs[action.id], LitMax);
+      DelVec(vvCs[action.id]);
+      break;
+    case ADD_FANIN:
+      vUpdates[action.id] = true;
+      vCUpdates[action.id] = true;
+      vvCs[action.id].insert(vvCs[action.id].begin() + action.idx, LitMax);
+      break;
+    case TRIVIAL_COLLAPSE: {
+      if(vGUpdates[action.fi] || vCUpdates[action.fi]) {
+        vCUpdates[action.id] = true;
+      }
+      std::vector<lit>::iterator it = vvCs[action.id].begin() + action.idx;
+      DecRef(*it);
+      it = vvCs[action.id].erase(it);
+      vvCs[action.id].insert(it,  vvCs[action.fi].begin(), vvCs[action.fi].end());
+      vvCs[action.fi].clear();
+      Assign(vFs[action.fi], LitMax);
+      Assign(vGs[action.fi], LitMax);
+      break;
+    }
+    case TRIVIAL_DECOMPOSE: {
+      Allocate();
+      SimulateNode(action.fi, vFs);
+      assert(vGs[action.fi] == LitMax);
+      Assign(vGs[action.fi], vGs[action.id]);
+      std::vector<lit>::iterator it = vvCs[action.id].begin() + action.idx;
+      assert(vvCs[action.fi].empty());
+      vvCs[action.fi].insert(vvCs[action.fi].begin(), it, vvCs[action.id].end());
+      vvCs[action.id].erase(it, vvCs[action.id].end());
+      assert(vvCs[action.id].size() == action.idx);
+      vvCs[action.id].resize(action.idx + 1, LitMax);
+      Assign(vvCs[action.id][action.idx], vGs[action.fi]);
+      vUpdates[action.fi] = false;
+      vGUpdates[action.fi] = false;
+      vCUpdates[action.fi] = vCUpdates[action.id];
+      break;
+    }
+    case SORT_FANINS: {
+      std::vector<lit> vCs = vvCs[action.id];
+      vvCs[action.id].clear();
+      for(int index: action.vIndices) {
+        vvCs[action.id].push_back(vCs[index]);
+      }
+      if(!fResim && target != -1 && target != action.id) {
+        pNtk->ForEachTfo(target, false, [&](int fo) {
+          if(fResim) {
+            return;
+          }
+          if(fo == action.id) {
+            fResim = true;
+          }
+        });
+      }
+      vCUpdates[action.id] = true;
+      break;
+    }
+    case SAVE:
+      Save(action.idx);
+      break;
+    case LOAD:
+      Load(action.idx);
+      break;
+    case POP_BACK:
+      PopBack();
+      break;
+    default:
+      assert(0);
+    }
+  }
+  
+  /* }}} */
+
+  /* {{{ Allocation */
+
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::Allocate() {
+    int nNodes = pNtk->GetNumNodes();
+    vFs.resize(nNodes, LitMax);
+    vGs.resize(nNodes, LitMax);
+    vvCs.resize(nNodes);
+    vUpdates.resize(nNodes);
+    vGUpdates.resize(nNodes);
+    vCUpdates.resize(nNodes);
+  }
+
+  /* }}} */
+  
+  /* {{{ Simulation */
+  
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::SimulateNode(int id, std::vector<lit> &v) const {
+    if(nVerbose) {
+      std::cout << "simulating node " << id << std::endl;
+    }
+    Assign(v[id], pBdd->Const1());
+    pNtk->ForEachFanin(id, [&](int fi, bool c) {
+      Assign(v[id], pBdd->And(v[id], pBdd->LitNotCond(v[fi], c)));
+    });
+  }
+  
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::Simulate() {
+    if(nVerbose) {
+      std::cout << "symbolic simulation with BDD" << std::endl;
+    }
+    pNtk->ForEachInt([&](int id) {
+      if(vUpdates[id]) {
+        lit x = vFs[id];
+        IncRef(x);
+        SimulateNode(id, vFs);
+        DecRef(x);
+        if(!pBdd->LitIsEq(x, vFs[id])) {
+          pNtk->ForEachFanout(id, false, [&](int fo) {
+            vUpdates[fo] = true;
+            vCUpdates[fo] = true;
+          });
+        }
+        vUpdates[id] = false;
+      }
+    });
+  }
+
+  /* }}} */
+
+  /* {{{ CSPF computation */
+  
+  template <typename Ntk>
+  inline bool BddAnalyzer<Ntk>::ComputeG(int id) {
+    if(pNtk->GetNumFanouts(id) == 0) {
+      if(pBdd->IsConst1(vGs[id])) {
+        return false;
+      }
+      Assign(vGs[id], pBdd->Const1());
+      return true;
+    }
+    lit x = pBdd->Const1();
+    IncRef(x);
+    pNtk->ForEachFanoutRidx(id, true, [&](int fo, int idx) {
+      Assign(x, pBdd->And(x, vvCs[fo][idx]));
+    });
+    if(pBdd->LitIsEq(vGs[id], x)) {
+      DecRef(x);
+      return false;
+    }
+    Assign(vGs[id], x);
+    DecRef(x);
+    return true;
+  }
+
+  template <typename Ntk>
+  inline void BddAnalyzer<Ntk>::ComputeC(int id) {
+    int nFanins = pNtk->GetNumFanins(id);
+    assert(vvCs[id].size() == nFanins);
+    if(pBdd->IsConst1(vGs[id])) {
+      for(int idx = 0; idx < nFanins; idx++) {
+        if(!pBdd->IsConst1(vvCs[id][idx])) {
+          Assign(vvCs[id][idx], pBdd->Const1());
+          int fi = pNtk->GetFanin(id, idx);
+          vGUpdates[fi] = true;
+        }
+      }
+      return;
+    }
+    for(int idx = 0; idx < nFanins; idx++) {
+      lit x = pBdd->Const1();
+      IncRef(x);
+      for(int idx2 = idx + 1; idx2 < nFanins; idx2++) {
+        int fi = pNtk->GetFanin(id, idx2);
+        bool c = pNtk->GetCompl(id, idx2);
+        Assign(x, pBdd->And(x, pBdd->LitNotCond(vFs[fi], c)));
+      }
+      Assign(x, pBdd->Or(pBdd->LitNot(x), vGs[id]));
+      if(!pBdd->LitIsEq(vvCs[id][idx], x)) {
+        Assign(vvCs[id][idx], x);
+        int fi = pNtk->GetFanin(id, idx);
+        vGUpdates[fi] = true;
+      }
+      DecRef(x);
+    }
+  }
+
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::CspfNode(int id) {
+    if(!vGUpdates[id] && !vCUpdates[id]) {
+      return;
+    }
+    if(vGUpdates[id]) {
+      if(nVerbose) {
+        std::cout << "computing node " << id << " G " << std::endl;
+      }
+      if(ComputeG(id)) {
+        vCUpdates[id] = true;
+      }
+      vGUpdates[id] = false;
+    }
+    if(vCUpdates[id]) {
+      if(nVerbose) {
+        std::cout << "computing node " << id << " C " << std::endl;
+      }
+      ComputeC(id);
+      vCUpdates[id] = false;
+    }
+  }
+  
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::Cspf(int id, bool fC) {
+    if(id != -1) {
+      pNtk->ForEachTfoReverse(id, false, [&](int fo) {
+        CspfNode(fo);
+      });
+      bool fCUpdate = vCUpdates[id];
+      if(!fC) {
+        vCUpdates[id] = false;
+      }
+      CspfNode(id);
+      if(!fC) {
+        vCUpdates[id] = fCUpdate;
+      }
+    } else {
+      pNtk->ForEachIntReverse([&](int id) {
+        CspfNode(id);
+      });
+    }
+  }
+
+  /* }}} */
+
+  /* {{{ Save & load */
+
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::Save(int slot) {
+    if(slot >= int_size(vBackups)) {
+      vBackups.resize(slot + 1);
+    }
+    vBackups[slot].target = target;
+    CopyVec(vBackups[slot].vFs, vFs);
+    CopyVec(vBackups[slot].vGs, vGs);
+    CopyVecVec(vBackups[slot].vvCs, vvCs);
+    vBackups[slot].vUpdates = vUpdates;
+    vBackups[slot].vGUpdates = vGUpdates;
+    vBackups[slot].vCUpdates = vCUpdates;
+  }
+
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::Load(int slot) {
+    assert(slot < int_size(vBackups));
+    target = vBackups[slot].target;
+    CopyVec(vFs, vBackups[slot].vFs);
+    CopyVec(vGs, vBackups[slot].vGs);
+    CopyVecVec(vvCs, vBackups[slot].vvCs);
+    vUpdates = vBackups[slot].vUpdates;
+    vGUpdates = vBackups[slot].vGUpdates;
+    vCUpdates = vBackups[slot].vCUpdates;
+  }
+
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::PopBack() {
+    assert(!vBackups.empty());
+    DelVec(vBackups.back().vFs);
+    DelVec(vBackups.back().vGs);
+    DelVecVec(vBackups.back().vvCs);
+    vBackups.pop_back();
+  }
+
+  /* }}} Save & load end */
+  
+  /* {{{ Constructors */
+
+  template <typename Ntk>
+  BddAnalyzer<Ntk>::BddAnalyzer() :
+    pNtk(NULL),
+    nVerbose(0),
+    pBdd(NULL),
+    target(-1),
+    fResim(false) {
+  }
+  
+  template <typename Ntk>
+  BddAnalyzer<Ntk>::BddAnalyzer(Parameter const *pPar) :
+    pNtk(NULL),
+    nVerbose(pPar->nAnalyzerVerbose),
+    pBdd(NULL),
+    target(-1),
+    fResim(false) {
+  }
+
+  template <typename Ntk>
+  void BddAnalyzer<Ntk>::UpdateNetwork(Ntk *pNtk_, bool fSame) {
+    // clear
+    while(!vBackups.empty()) {
+      PopBack();
+    }
+    DelVec(vFs);
+    DelVec(vGs);
+    DelVecVec(vvCs);
+    pNtk = pNtk_;
+    target = -1;
+    fResim = false;
+    vUpdates.clear();
+    vGUpdates.clear();
+    vCUpdates.clear();
+    // alloc
+    bool fUseReo = false;
+    if(!pBdd || pBdd->GetNumVars() != pNtk->GetNumPis()) {
+      // need to reset manager
+      delete pBdd;
+      NewBdd::Param Par;
+      Par.nObjsMaxLog = 25;
+      Par.nCacheMaxLog = 20;
+      Par.fCountOnes = true;
+      Par.nGbc = 1;
+      Par.nReo = 4000;
+      pBdd = new NewBdd::Man(pNtk->GetNumPis(), Par);
+      fUseReo = true;
+    } else if(!fSame) {
+      // turning on reordering if network function changed
+      pBdd->TurnOnReo();
+      fUseReo = true;
+    }
+    Allocate();
+    // prepare
+    Assign(vFs[0], pBdd->Const0());
+    int idx = 0;
+    pNtk->ForEachPi([&](int id) {
+      Assign(vFs[id], pBdd->IthVar(idx));
+      idx++;
+    });
+    pNtk->ForEachInt([&](int id) {
+      vUpdates[id] = true;
+    });
+    Simulate();
+    if(fUseReo) {
+      pBdd->Reorder();
+      pBdd->TurnOffReo();
+    }
+    pNtk->ForEachInt([&](int id) {
+      vvCs[id].resize(pNtk->GetNumFanins(id), LitMax);
+    });
+    pNtk->ForEachPo([&](int id) {
+      vvCs[id].resize(1, LitMax);
+      Assign(vvCs[id][0], pBdd->Const0());
+      int fi = pNtk->GetFanin(id, 0);
+      vGUpdates[fi]  = true;
+    });
+    pNtk->AddCallback(std::bind(&BddAnalyzer<Ntk>::ActionCallback, this, std::placeholders::_1));
+  }
+  
+  template <typename Ntk>
+  BddAnalyzer<Ntk>::~BddAnalyzer() {
+    while(!vBackups.empty()) {
+      PopBack();
+    }
+    DelVec(vFs);
+    DelVec(vGs);
+    DelVecVec(vvCs);
+    if(pBdd) {
+      pBdd->PrintStats();
+    }
+    delete pBdd;
+  }
+
+  /* }}} */
+
+  /* {{{ Checks */
+  
+  template <typename Ntk>
+  bool BddAnalyzer<Ntk>::CheckRedundancy(int id, int idx) {
+    if(fResim) {
+      Simulate();
+    }
+    Cspf(id);
+    switch(pNtk->GetNodeType(id)) {
+    case AND: {
+      int fi = pNtk->GetFanin(id, idx);
+      bool c = pNtk->GetCompl(id, idx);
+      lit x = pBdd->Or(pBdd->LitNotCond(vFs[fi], c), vvCs[id][idx]);
+      if(pBdd->IsConst1(x)) {
+        if(nVerbose) {
+          std::cout << "node " << id << " fanin " << (pNtk->GetCompl(id, idx)? "!": "") << pNtk->GetFanin(id, idx) << " index " << idx << " is redundant" << std::endl;
+        }
+        return true;
+      }
+      break;
+    }
+    default:
+      assert(0);
+    }
+    if(nVerbose) {
+      std::cout << "node " << id << " fanin " << (pNtk->GetCompl(id, idx)? "!": "") << pNtk->GetFanin(id, idx) << " index " << idx << " is NOT redundant" << std::endl;
+    }
+    return false;
+  }
+  
+  template <typename Ntk>
+  bool BddAnalyzer<Ntk>::CheckFeasibility(int id, int fi, bool c) {
+    if(target != id) { // simualte if there has been update in non-tfo of this node
+      Simulate();
+      target = id;
+    }
+    Cspf(id, false);
+    switch(pNtk->GetNodeType(id)) {
+    case AND: {
+      lit x = pBdd->Or(pBdd->LitNot(vFs[id]), vGs[id]);
+      IncRef(x);
+      lit y = pBdd->Or(x, pBdd->LitNotCond(vFs[fi], c));
+      DecRef(x);
+      if(pBdd->IsConst1(y)) {
+        if(nVerbose) {
+          std::cout << "node " << id << " fanin " << (c? "!": "") << fi << " is feasible" << std::endl;
+        }
+        return true;
+      }
+      break;
+    }
+    default:
+      assert(0);
+    }
+    if(nVerbose) {
+      std::cout << "node " << id << " fanin " << (c? "!": "") << fi << " is NOT feasible" << std::endl;
+    }
+    return false;
+  }
+
+  /* }}} */
+  
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrBddManager.h b/src/opt/rrr/rrrBddManager.h
new file mode 100644
index 000000000..1227147c0
--- /dev/null
+++ b/src/opt/rrr/rrrBddManager.h
@@ -0,0 +1,848 @@
+#pragma once
+
+#include <cstdlib>
+#include <limits>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <cmath>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+namespace NewBdd {
+
+  typedef unsigned short     var;
+  typedef int                bvar;
+  typedef unsigned           lit;
+  typedef unsigned short     ref;
+  typedef unsigned long long size;
+  typedef unsigned           edge;
+  typedef unsigned           uniq;
+  typedef unsigned           cac;
+  static inline var  VarMax()                     { return std::numeric_limits<var>::max();  }
+  static inline bvar BvarMax()                    { return std::numeric_limits<bvar>::max(); }
+  static inline lit  LitMax()                     { return std::numeric_limits<lit>::max();  }
+  static inline ref  RefMax()                     { return std::numeric_limits<ref>::max();  }
+  static inline size SizeMax()                    { return std::numeric_limits<size>::max(); }
+  static inline uniq UniqHash(lit Arg0, lit Arg1) { return Arg0 + 4256249 * Arg1;            }
+  static inline cac  CacHash(lit Arg0, lit Arg1)  { return Arg0 + 4256249 * Arg1;            }
+
+  static inline void fatal_error(const char* message) {
+    std::cerr << message << std::endl;
+    std::abort();
+  }
+
+  class Cache {
+  private:
+    cac    nSize;
+    cac    nMax;
+    cac    Mask;
+    size   nLookups;
+    size   nHits;
+    size   nThold;
+    double HitRate;
+    int    nVerbose;
+    std::vector<lit> vCache;
+
+  public:
+    Cache(int nCacheSizeLog, int nCacheMaxLog, int nVerbose): nVerbose(nVerbose) {
+      if(nCacheMaxLog < nCacheSizeLog)
+        fatal_error("nCacheMax must not be smaller than nCacheSize");
+      nMax = (cac)1 << nCacheMaxLog;
+      if(!(nMax << 1))
+        fatal_error("Memout (nCacheMax) in init");
+      nSize = (cac)1 << nCacheSizeLog;
+      if(nVerbose)
+        std::cout << "Allocating " << nSize << " cache entries" << std::endl;
+      vCache.resize(nSize * 3);
+      Mask = nSize - 1;
+      nLookups = 0;
+      nHits = 0;
+      nThold = (nSize == nMax)? SizeMax(): nSize;
+      HitRate = 1;
+    }
+    ~Cache() {
+      if(nVerbose)
+        std::cout << "Free " << nSize << " cache entries" << std::endl;
+    }
+    inline lit Lookup(lit x, lit y) {
+      nLookups++;
+      if(nLookups > nThold) {
+        double NewHitRate = (double)nHits / nLookups;
+        if(nVerbose >= 2)
+          std::cout << "Cache Hits: " << std::setw(10) << nHits << ", "
+                    << "Lookups: " << std::setw(10) << nLookups << ", "
+                    << "Rate: " << std::setw(10) << NewHitRate
+                    << std::endl;
+        if(NewHitRate > HitRate)
+          Resize();
+        if(nSize == nMax)
+          nThold = SizeMax();
+        else {
+          nThold <<= 1;
+          if(!nThold)
+            nThold = SizeMax();
+        }
+        HitRate = NewHitRate;
+      }
+      cac i = (CacHash(x, y) & Mask) * 3;
+      if(vCache[i] == x && vCache[i + 1] == y) {
+        if(nVerbose >= 3)
+          std::cout << "Cache hit: "
+                    << "x = " << std::setw(10) << x << ", "
+                    << "y = " << std::setw(10) << y << ", "
+                    << "z = " << std::setw(10) << vCache[i + 2] << ", "
+                    << "hash = " << std::hex << (CacHash(x, y) & Mask) << std::dec
+                    << std::endl;
+        nHits++;
+        return vCache[i + 2];
+      }
+      return LitMax();
+    }
+    inline void Insert(lit x, lit y, lit z) {
+      cac i = (CacHash(x, y) & Mask) * 3;
+      vCache[i] = x;
+      vCache[i + 1] = y;
+      vCache[i + 2] = z;
+      if(nVerbose >= 3)
+        std::cout << "Cache ent: "
+                  << "x = " << std::setw(10) << x << ", "
+                  << "y = " << std::setw(10) << y << ", "
+                  << "z = " << std::setw(10) << z << ", "
+                  << "hash = " << std::hex << (CacHash(x, y) & Mask) << std::dec
+                  << std::endl;
+    }
+    inline void Clear() {
+      std::fill(vCache.begin(), vCache.end(), 0);
+    }
+    void Resize() {
+      cac nSizeOld = nSize;
+      nSize <<= 1;
+      if(nVerbose >= 2)
+        std::cout << "Reallocating " << nSize << " cache entries" << std::endl;
+      vCache.resize(nSize * 3);
+      Mask = nSize - 1;
+      for(cac j = 0; j < nSizeOld; j++) {
+        cac i = j * 3;
+        if(vCache[i] || vCache[i + 1]) {
+          cac hash = (CacHash(vCache[i], vCache[i + 1]) & Mask) * 3;
+          vCache[hash] = vCache[i];
+          vCache[hash + 1] = vCache[i + 1];
+          vCache[hash + 2] = vCache[i + 2];
+          if(nVerbose >= 3)
+            std::cout << "Cache mov: "
+                      << "x = " << std::setw(10) << vCache[i] << ", "
+                      << "y = " << std::setw(10) << vCache[i + 1] << ", "
+                      << "z = " << std::setw(10) << vCache[i + 2] << ", "
+                      << "hash = " << std::hex << (CacHash(vCache[i], vCache[i + 1]) & Mask) << std::dec
+                      << std::endl;
+        }
+      }
+    }
+  };
+
+  struct Param {
+    int    nObjsAllocLog;
+    int    nObjsMaxLog;
+    int    nUniqueSizeLog;
+    double UniqueDensity;
+    int    nCacheSizeLog;
+    int    nCacheMaxLog;
+    int    nCacheVerbose;
+    bool   fCountOnes;
+    int    nGbc;
+    bvar   nReo;
+    double MaxGrowth;
+    bool   fReoVerbose;
+    int    nVerbose;
+    std::vector<var> *pVar2Level;
+    Param() {
+      nObjsAllocLog  = 20;
+      nObjsMaxLog    = 25;
+      nUniqueSizeLog = 10;
+      UniqueDensity  = 4;
+      nCacheSizeLog  = 15;
+      nCacheMaxLog   = 20;
+      nCacheVerbose  = 0;
+      fCountOnes     = false;
+      nGbc           = 0;
+      nReo           = BvarMax();
+      MaxGrowth      = 1.2;
+      fReoVerbose    = false;
+      nVerbose       = 0;
+      pVar2Level     = NULL;
+    }
+  };
+
+  class Man {
+  private:
+    var    nVars;
+    bvar   nObjs;
+    bvar   nObjsAlloc;
+    bvar   nObjsMax;
+    bvar   RemovedHead;
+    int    nGbc;
+    bvar   nReo;
+    double MaxGrowth;
+    bool   fReoVerbose;
+    int    nVerbose;
+    std::vector<var>    vVars;
+    std::vector<var>    Var2Level;
+    std::vector<var>    Level2Var;
+    std::vector<lit>    vObjs;
+    std::vector<bvar>   vNexts;
+    std::vector<bool>   vMarks;
+    std::vector<ref>    vRefs;
+    std::vector<edge>   vEdges;
+    std::vector<double> vOneCounts;
+    std::vector<uniq>   vUniqueMasks;
+    std::vector<bvar>   vUniqueCounts;
+    std::vector<bvar>   vUniqueTholds;
+    std::vector<std::vector<bvar> > vvUnique;
+    Cache *cache;
+
+  public:
+    inline lit  Bvar2Lit(bvar a)          const { return (lit)a << 1;                                       }
+    inline lit  Bvar2Lit(bvar a, bool c)  const { return ((lit)a << 1) ^ (lit)c;                            }
+    inline bvar Lit2Bvar(lit x)           const { return (bvar)(x >> 1);                                    }
+    inline var  VarOfBvar(bvar a)         const { return vVars[a];                                          }
+    inline lit  ThenOfBvar(bvar a)        const { return vObjs[Bvar2Lit(a)];                                }
+    inline lit  ElseOfBvar(bvar a)        const { return vObjs[Bvar2Lit(a, true)];                          }
+    inline ref  RefOfBvar(bvar a)         const { return vRefs[a];                                          }
+    inline lit  Const0()                  const { return (lit)0;                                            }
+    inline lit  Const1()                  const { return (lit)1;                                            }
+    inline bool IsConst0(lit x)           const { return x == Const0();                                     }
+    inline bool IsConst1(lit x)           const { return x == Const1();                                     }
+    inline lit  IthVar(var v)             const { return Bvar2Lit((bvar)v + 1);                             }
+    inline lit  LitRegular(lit x)         const { return x & ~(lit)1;                                       }
+    inline lit  LitIrregular(lit x)       const { return x | (lit)1;                                        }
+    inline lit  LitNot(lit x)             const { return x ^ (lit)1;                                        }
+    inline lit  LitNotCond(lit x, bool c) const { return x ^ (lit)c;                                        }
+    inline bool LitIsCompl(lit x)         const { return x & (lit)1;                                        }
+    inline bool LitIsEq(lit x, lit y)     const { return x == y;                                            }
+    inline var  Var(lit x)                const { return vVars[Lit2Bvar(x)];                                }
+    inline var  Level(lit x)              const { return Var2Level[Var(x)];                                 }
+    inline lit  Then(lit x)               const { return LitNotCond(vObjs[LitRegular(x)], LitIsCompl(x));   }
+    inline lit  Else(lit x)               const { return LitNotCond(vObjs[LitIrregular(x)], LitIsCompl(x)); }
+    inline ref  Ref(lit x)                const { return vRefs[Lit2Bvar(x)];                                }
+    inline double OneCount(lit x)         const {
+      if(vOneCounts.empty())
+        fatal_error("fCountOnes was not set");
+      if(LitIsCompl(x))
+        return std::pow(2.0, nVars) - vOneCounts[Lit2Bvar(x)];
+      return vOneCounts[Lit2Bvar(x)];
+    }
+
+  public:
+    inline void IncRef(lit x)              { if(!vRefs.empty() && Ref(x) != RefMax()) vRefs[Lit2Bvar(x)]++; }
+    inline void DecRef(lit x)              { if(!vRefs.empty() && Ref(x) != RefMax()) vRefs[Lit2Bvar(x)]--; }
+
+  private:
+    inline bool Mark(lit x)               const { return vMarks[Lit2Bvar(x)];                               }
+    inline edge Edge(lit x)               const { return vEdges[Lit2Bvar(x)];                               }
+    inline void SetMark(lit x)                  { vMarks[Lit2Bvar(x)] = true;                               }
+    inline void ResetMark(lit x)                { vMarks[Lit2Bvar(x)] = false;                              }
+    inline void IncEdge(lit x)                  { vEdges[Lit2Bvar(x)]++;                                    }
+    inline void DecEdge(lit x)                  { vEdges[Lit2Bvar(x)]--;                                    }
+    inline bool MarkOfBvar(bvar a)        const { return vMarks[a];                                         }
+    inline edge EdgeOfBvar(bvar a)        const { return vEdges[a];                                         }
+    inline void SetVarOfBvar(bvar a, var v)     { vVars[a] = v;                                             }
+    inline void SetThenOfBvar(bvar a, lit x)    { vObjs[Bvar2Lit(a)] = x;                                   }
+    inline void SetElseOfBvar(bvar a, lit x)    { vObjs[Bvar2Lit(a, true)] = x;                             }
+    inline void SetMarkOfBvar(bvar a)           { vMarks[a] = true;                                         }
+    inline void ResetMarkOfBvar(bvar a)         { vMarks[a] = false;                                        }
+    inline void RemoveBvar(bvar a)              {
+      var v = VarOfBvar(a);
+      SetVarOfBvar(a, VarMax());
+      std::vector<bvar>::iterator q = vvUnique[v].begin() + (UniqHash(ThenOfBvar(a), ElseOfBvar(a)) & vUniqueMasks[v]);
+      for(; *q; q = vNexts.begin() + *q)
+        if(*q == a)
+          break;
+      bvar next = vNexts[*q];
+      vNexts[*q] = RemovedHead;
+      RemovedHead = *q;
+      *q = next;
+      vUniqueCounts[v]--;
+    }
+
+  private:
+    void SetMark_rec(lit x) {
+      if(x < 2 || Mark(x))
+        return;
+      SetMark(x);
+      SetMark_rec(Then(x));
+      SetMark_rec(Else(x));
+    }
+    void ResetMark_rec(lit x) {
+      if(x < 2 || !Mark(x))
+        return;
+      ResetMark(x);
+      ResetMark_rec(Then(x));
+      ResetMark_rec(Else(x));
+    }
+    bvar CountNodes_rec(lit x) {
+      if(x < 2 || Mark(x))
+        return 0;
+      SetMark(x);
+      return 1 + CountNodes_rec(Then(x)) + CountNodes_rec(Else(x));
+    }
+    void CountEdges_rec(lit x) {
+      if(x < 2)
+        return;
+      IncEdge(x);
+      if(Mark(x))
+        return;
+      SetMark(x);
+      CountEdges_rec(Then(x));
+      CountEdges_rec(Else(x));
+    }
+    void CountEdges() {
+      vEdges.resize(nObjsAlloc);
+      for(bvar a = (bvar)nVars + 1; a < nObjs; a++)
+        if(RefOfBvar(a))
+          CountEdges_rec(Bvar2Lit(a));
+      for(bvar a = 1; a <= (bvar)nVars; a++)
+        vEdges[a]++;
+      for(bvar a = (bvar)nVars + 1; a < nObjs; a++)
+        if(RefOfBvar(a))
+          ResetMark_rec(Bvar2Lit(a));
+    }
+
+  public:
+    bool Resize() {
+      if(nObjsAlloc == nObjsMax)
+        return false;
+      lit nObjsAllocLit = (lit)nObjsAlloc << 1;
+      if(nObjsAllocLit > (lit)BvarMax())
+        nObjsAlloc = BvarMax();
+      else
+        nObjsAlloc = (bvar)nObjsAllocLit;
+      if(nVerbose >= 2)
+        std::cout << "Reallocating " << nObjsAlloc << " nodes" << std::endl;
+      vVars.resize(nObjsAlloc);
+      vObjs.resize((lit)nObjsAlloc * 2);
+      vNexts.resize(nObjsAlloc);
+      vMarks.resize(nObjsAlloc);
+      if(!vRefs.empty())
+        vRefs.resize(nObjsAlloc);
+      if(!vEdges.empty())
+        vEdges.resize(nObjsAlloc);
+      if(!vOneCounts.empty())
+        vOneCounts.resize(nObjsAlloc);
+      return true;
+    }
+    void ResizeUnique(var v) {
+      uniq nUniqueSize, nUniqueSizeOld;
+      nUniqueSize = nUniqueSizeOld = vvUnique[v].size();
+      nUniqueSize <<= 1;
+      if(!nUniqueSize) {
+        vUniqueTholds[v] = BvarMax();
+        return;
+      }
+      if(nVerbose >= 2)
+        std::cout << "Reallocating " << nUniqueSize << " unique table entries for Var " << v << std::endl;
+      vvUnique[v].resize(nUniqueSize);
+      vUniqueMasks[v] = nUniqueSize - 1;
+      for(uniq i = 0; i < nUniqueSizeOld; i++) {
+        std::vector<bvar>::iterator q, tail, tail1, tail2;
+        q = tail1 = vvUnique[v].begin() + i;
+        tail2 = q + nUniqueSizeOld;
+        while(*q) {
+          uniq hash = UniqHash(ThenOfBvar(*q), ElseOfBvar(*q)) & vUniqueMasks[v];
+          if(hash == i)
+            tail = tail1;
+          else
+            tail = tail2;
+          if(tail != q)
+            *tail = *q, *q = 0;
+          q = vNexts.begin() + *tail;
+          if(tail == tail1)
+            tail1 = q;
+          else
+            tail2 = q;
+        }
+      }
+      vUniqueTholds[v] <<= 1;
+      if((lit)vUniqueTholds[v] > (lit)BvarMax())
+        vUniqueTholds[v] = BvarMax();
+    }
+    bool Gbc() {
+      if(nVerbose >= 2)
+        std::cout << "Garbage collect" << std::endl;
+      if(!vEdges.empty()) {
+        for(bvar a = (bvar)nVars + 1; a < nObjs; a++)
+          if(!EdgeOfBvar(a) && VarOfBvar(a) != VarMax())
+            RemoveBvar(a);
+      } else {
+        for(bvar a = (bvar)nVars + 1; a < nObjs; a++)
+          if(RefOfBvar(a))
+            SetMark_rec(Bvar2Lit(a));
+        for(bvar a = (bvar)nVars + 1; a < nObjs; a++)
+          if(!MarkOfBvar(a) && VarOfBvar(a) != VarMax())
+            RemoveBvar(a);
+        for(bvar a = (bvar)nVars + 1; a < nObjs; a++)
+          if(RefOfBvar(a))
+            ResetMark_rec(Bvar2Lit(a));
+      }
+      cache->Clear();
+      return RemovedHead;
+    }
+
+  private:
+    inline lit UniqueCreateInt(var v, lit x1, lit x0) {
+      std::vector<bvar>::iterator p, q;
+      p = q = vvUnique[v].begin() + (UniqHash(x1, x0) & vUniqueMasks[v]);
+      for(; *q; q = vNexts.begin() + *q)
+        if(VarOfBvar(*q) == v && ThenOfBvar(*q) == x1 && ElseOfBvar(*q) == x0)
+          return Bvar2Lit(*q);
+      bvar next = *p;
+      if(nObjs < nObjsAlloc)
+        *p = nObjs++;
+      else if(RemovedHead)
+        *p = RemovedHead, RemovedHead = vNexts[*p];
+      else
+        return LitMax();
+      SetVarOfBvar(*p, v);
+      SetThenOfBvar(*p, x1);
+      SetElseOfBvar(*p, x0);
+      vNexts[*p] = next;
+      if(!vOneCounts.empty())
+        vOneCounts[*p] = OneCount(x1) / 2 + OneCount(x0) / 2;
+      if(nVerbose >= 3) {
+        std::cout << "Create node " << std::setw(10) << *p << ": "
+                  << "Var = " << std::setw(6) << v << ", "
+                  << "Then = " << std::setw(10) << x1 << ", "
+                  << "Else = " << std::setw(10) << x0;
+        if(!vOneCounts.empty())
+          std::cout << ", Ones = " << std::setw(10) << vOneCounts[*q];
+        std::cout << std::endl;
+      }
+      vUniqueCounts[v]++;
+      if(vUniqueCounts[v] > vUniqueTholds[v]) {
+        bvar a = *p;
+        ResizeUnique(v);
+        return Bvar2Lit(a);
+      }
+      return Bvar2Lit(*p);
+    }
+    inline lit UniqueCreate(var v, lit x1, lit x0) {
+      if(x1 == x0)
+        return x1;
+      lit x;
+      while(true) {
+        if(!LitIsCompl(x0))
+          x = UniqueCreateInt(v, x1, x0);
+        else
+          x = UniqueCreateInt(v, LitNot(x1), LitNot(x0));
+        if(x == LitMax()) {
+          bool fRemoved = false;
+          if(nGbc > 1)
+            fRemoved = Gbc();
+          if(!Resize() && !fRemoved && (nGbc != 1 || !Gbc()))
+            fatal_error("Memout (node)");
+        } else
+          break;
+      }
+      return LitIsCompl(x0)? LitNot(x): x;
+    }
+    lit And_rec(lit x, lit y) {
+      if(x == 0 || y == 1)
+        return x;
+      if(x == 1 || y == 0)
+        return y;
+      if(Lit2Bvar(x) == Lit2Bvar(y))
+        return (x == y)? x: 0;
+      if(x > y)
+        std::swap(x, y);
+      lit z = cache->Lookup(x, y);
+      if(z != LitMax())
+        return z;
+      var v;
+      lit x0, x1, y0, y1;
+      if(Level(x) < Level(y))
+        v = Var(x), x1 = Then(x), x0 = Else(x), y0 = y1 = y;
+      else if(Level(x) > Level(y))
+        v = Var(y), x0 = x1 = x, y1 = Then(y), y0 = Else(y);
+      else
+        v = Var(x), x1 = Then(x), x0 = Else(x), y1 = Then(y), y0 = Else(y);
+      lit z1 = And_rec(x1, y1);
+      IncRef(z1);
+      lit z0 = And_rec(x0, y0);
+      IncRef(z0);
+      z = UniqueCreate(v, z1, z0);
+      DecRef(z1);
+      DecRef(z0);
+      cache->Insert(x, y, z);
+      return z;
+    }
+
+  private:
+    bvar Swap(var i) {
+      var v1 = Level2Var[i];
+      var v2 = Level2Var[i + 1];
+      bvar f = 0;
+      bvar diff = 0;
+      for(std::vector<bvar>::iterator p = vvUnique[v1].begin(); p != vvUnique[v1].end(); p++) {
+        std::vector<bvar>::iterator q = p;
+        while(*q) {
+          if(!EdgeOfBvar(*q)) {
+            SetVarOfBvar(*q, VarMax());
+            bvar next = vNexts[*q];
+            vNexts[*q] = RemovedHead;
+            RemovedHead = *q;
+            *q = next;
+            vUniqueCounts[v1]--;
+            continue;
+          }
+          lit f1 = ThenOfBvar(*q);
+          lit f0 = ElseOfBvar(*q);
+          if(Var(f1) == v2 || Var(f0) == v2) {
+            DecEdge(f1);
+            if(Var(f1) == v2 && !Edge(f1))
+              DecEdge(Then(f1)), DecEdge(Else(f1)), diff--;
+            DecEdge(f0);
+            if(Var(f0) == v2 && !Edge(f0))
+              DecEdge(Then(f0)), DecEdge(Else(f0)), diff--;
+            bvar next = vNexts[*q];
+            vNexts[*q] = f;
+            f = *q;
+            *q = next;
+            vUniqueCounts[v1]--;
+            continue;
+          }
+          q = vNexts.begin() + *q;
+        }
+      }
+      while(f) {
+        lit f1 = ThenOfBvar(f);
+        lit f0 = ElseOfBvar(f);
+        lit f00, f01, f10, f11;
+        if(Var(f1) == v2)
+          f11 = Then(f1), f10 = Else(f1);
+        else
+          f10 = f11 = f1;
+        if(Var(f0) == v2)
+          f01 = Then(f0), f00 = Else(f0);
+        else
+          f00 = f01 = f0;
+        if(f11 == f01)
+          f1 = f11;
+        else {
+          f1 = UniqueCreate(v1, f11, f01);
+          if(!Edge(f1))
+            IncEdge(f11), IncEdge(f01), diff++;
+        }
+        IncEdge(f1);
+        IncRef(f1);
+        if(f10 == f00)
+          f0 = f10;
+        else {
+          f0 = UniqueCreate(v1, f10, f00);
+          if(!Edge(f0))
+            IncEdge(f10), IncEdge(f00), diff++;
+        }
+        IncEdge(f0);
+        DecRef(f1);
+        SetVarOfBvar(f, v2);
+        SetThenOfBvar(f, f1);
+        SetElseOfBvar(f, f0);
+        std::vector<bvar>::iterator q = vvUnique[v2].begin() + (UniqHash(f1, f0) & vUniqueMasks[v2]);
+        lit next = vNexts[f];
+        vNexts[f] = *q;
+        *q = f;
+        vUniqueCounts[v2]++;
+        f = next;
+      }
+      Var2Level[v1] = i + 1;
+      Var2Level[v2] = i;
+      Level2Var[i] = v2;
+      Level2Var[i + 1] = v1;
+      return diff;
+    }
+    void Sift() {
+      bvar count = CountNodes();
+      std::vector<var> sift_order(nVars);
+      for(var v = 0; v < nVars; v++)
+        sift_order[v] = v;
+      for(var i = 0; i < nVars; i++) {
+        var max_j = i;
+        for(var j = i + 1; j < nVars; j++)
+          if(vUniqueCounts[sift_order[j]] > vUniqueCounts[sift_order[max_j]])
+            max_j = j;
+        if(max_j != i)
+          std::swap(sift_order[max_j], sift_order[i]);
+      }
+      for(var v = 0; v < nVars; v++) {
+        bvar lev = Var2Level[sift_order[v]];
+        bool UpFirst = lev < (bvar)(nVars / 2);
+        bvar min_lev = lev;
+        bvar min_diff = 0;
+        bvar diff = 0;
+        bvar thold = count * (MaxGrowth - 1);
+        if(fReoVerbose)
+          std::cout << "Sift " << sift_order[v] << " : Level = " << lev << " Count = " << count << " Thold = " << thold << std::endl;
+        if(UpFirst) {
+          lev--;
+          for(; lev >= 0; lev--) {
+            diff += Swap(lev);
+            if(fReoVerbose)
+              std::cout << "\tSwap " << lev << " : Diff = " << diff << " Thold = " << thold << std::endl;
+            if(diff < min_diff)
+              min_lev = lev, min_diff = diff, thold = (count + diff) * (MaxGrowth - 1);
+            else if(diff > thold) {
+              lev--;
+              break;
+            }
+          }
+          lev++;
+        }
+        for(; lev < (bvar)nVars - 1; lev++) {
+          diff += Swap(lev);
+          if(fReoVerbose)
+            std::cout << "\tSwap " << lev << " : Diff = " << diff << " Thold = " << thold << std::endl;
+          if(diff <= min_diff)
+            min_lev = lev + 1, min_diff = diff, thold = (count + diff) * (MaxGrowth - 1);
+          else if(diff > thold) {
+            lev++;
+            break;
+          }
+        }
+        lev--;
+        if(UpFirst) {
+          for(; lev >= min_lev; lev--) {
+            diff += Swap(lev);
+            if(fReoVerbose)
+              std::cout << "\tSwap " << lev << " : Diff = " << diff << " Thold = " << thold << std::endl;
+          }
+        } else {
+          for(; lev >= 0; lev--) {
+            diff += Swap(lev);
+            if(fReoVerbose)
+              std::cout << "\tSwap " << lev << " : Diff = " << diff << " Thold = " << thold << std::endl;
+            if(diff <= min_diff)
+              min_lev = lev, min_diff = diff, thold = (count + diff) * (MaxGrowth - 1);
+            else if(diff > thold) {
+              lev--;
+              break;
+            }
+          }
+          lev++;
+          for(; lev < min_lev; lev++) {
+            diff += Swap(lev);
+            if(fReoVerbose)
+              std::cout << "\tSwap " << lev << " : Diff = " << diff << " Thold = " << thold << std::endl;
+          }
+        }
+        count += min_diff;
+        if(fReoVerbose)
+          std::cout << "Sifted " << sift_order[v] << " : Level = " << min_lev << " Count = " << count << " Thold = " << thold << std::endl;
+      }
+    }
+
+  public:
+    Man(int nVars_, Param p) {
+      nVerbose = p.nVerbose;
+      // parameter sanity check
+      if(p.nObjsMaxLog < p.nObjsAllocLog)
+        fatal_error("nObjsMax must not be smaller than nObjsAlloc");
+      if(nVars_ >= (int)VarMax())
+        fatal_error("Memout (nVars) in init");
+      nVars = nVars_;
+      lit nObjsMaxLit = (lit)1 << p.nObjsMaxLog;
+      if(!nObjsMaxLit)
+        fatal_error("Memout (nObjsMax) in init");
+      if(nObjsMaxLit > (lit)BvarMax())
+        nObjsMax = BvarMax();
+      else
+        nObjsMax = (bvar)nObjsMaxLit;
+      lit nObjsAllocLit = (lit)1 << p.nObjsAllocLog;
+      if(!nObjsAllocLit)
+        fatal_error("Memout (nObjsAlloc) in init");
+      if(nObjsAllocLit > (lit)BvarMax())
+        nObjsAlloc = BvarMax();
+      else
+        nObjsAlloc = (bvar)nObjsAllocLit;
+      if(nObjsAlloc <= (bvar)nVars)
+        fatal_error("nObjsAlloc must be larger than nVars");
+      uniq nUniqueSize = (uniq)1 << p.nUniqueSizeLog;
+      if(!nUniqueSize)
+        fatal_error("Memout (nUniqueSize) in init");
+      // allocation
+      if(nVerbose)
+        std::cout << "Allocating " << nObjsAlloc << " nodes and " << nVars << " x " << nUniqueSize << " unique table entries" << std::endl;
+      vVars.resize(nObjsAlloc);
+      vObjs.resize((lit)nObjsAlloc * 2);
+      vNexts.resize(nObjsAlloc);
+      vMarks.resize(nObjsAlloc);
+      vvUnique.resize(nVars);
+      vUniqueMasks.resize(nVars);
+      vUniqueCounts.resize(nVars);
+      vUniqueTholds.resize(nVars);
+      for(var v = 0; v < nVars; v++) {
+        vvUnique[v].resize(nUniqueSize);
+        vUniqueMasks[v] = nUniqueSize - 1;
+        if((lit)(nUniqueSize * p.UniqueDensity) > (lit)BvarMax())
+          vUniqueTholds[v] = BvarMax();
+        else
+          vUniqueTholds[v] = (bvar)(nUniqueSize * p.UniqueDensity);
+      }
+      if(p.fCountOnes) {
+        if(nVars > 1023)
+          fatal_error("nVars must be less than 1024 to count ones");
+        vOneCounts.resize(nObjsAlloc);
+      }
+      // set up cache
+      cache = new Cache(p.nCacheSizeLog, p.nCacheMaxLog, p.nCacheVerbose);
+      // create nodes for variables
+      nObjs = 1;
+      vVars[0] = VarMax();
+      for(var v = 0; v < nVars; v++)
+        UniqueCreateInt(v, 1, 0);
+      // set up variable order
+      Var2Level.resize(nVars);
+      Level2Var.resize(nVars);
+      for(var v = 0; v < nVars; v++) {
+        if(p.pVar2Level)
+          Var2Level[v] = (*p.pVar2Level)[v];
+        else
+          Var2Level[v] = v;
+        Level2Var[Var2Level[v]] = v;
+      }
+      // set other parameters
+      RemovedHead = 0;
+      nGbc = p.nGbc;
+      nReo = p.nReo;
+      MaxGrowth = p.MaxGrowth;
+      fReoVerbose = p.fReoVerbose;
+      if(nGbc || nReo != BvarMax())
+        vRefs.resize(nObjsAlloc);
+    }
+    ~Man() {
+      if(nVerbose) {
+        std::cout << "Free " << nObjsAlloc << " nodes (" << nObjs << " live nodes)" << std::endl;
+        std::cout << "Free {";
+        std::string delim;
+        for(var v = 0; v < nVars; v++) {
+          std::cout << delim << vvUnique[v].size();
+          delim = ", ";
+        }
+        std::cout << "} unique table entries" << std::endl;
+        if(!vRefs.empty())
+          std::cout << "Free " << vRefs.size() << " refs" << std::endl;
+      }
+      delete cache;
+    }
+    void Reorder() {
+      if(nVerbose >= 2)
+        std::cout << "Reorder" << std::endl;
+      int nGbc_ = nGbc;
+      nGbc = 0;
+      CountEdges();
+      Sift();
+      vEdges.clear();
+      cache->Clear();
+      nGbc = nGbc_;
+    }
+    inline lit And(lit x, lit y) {
+      if(nObjs > nReo) {
+        Reorder();
+        while(nReo < nObjs) {
+          nReo <<= 1;
+          if((lit)nReo > (lit)BvarMax())
+            nReo = BvarMax();
+        }
+      }
+      return And_rec(x, y);
+    }
+    inline lit Or(lit x, lit y) {
+      return LitNot(And(LitNot(x), LitNot(y)));
+    }
+
+  public:
+    void SetRef(std::vector<lit> const &vLits) {
+      vRefs.clear();
+      vRefs.resize(nObjsAlloc);
+      for(size_t i = 0; i < vLits.size(); i++)
+        IncRef(vLits[i]);
+    }
+    void RemoveRefIfUnused() {
+      if(!nGbc && nReo == BvarMax())
+        vRefs.clear();
+    }
+    void TurnOnReo(int nReo_ = 0, std::vector<lit> const *vLits = NULL) {
+      if(nReo_)
+        nReo = nReo_;
+      else
+        nReo = nObjs << 1;
+      if((lit)nReo > (lit)BvarMax())
+        nReo = BvarMax();
+      if(vRefs.empty()) {
+        if(vLits)
+          SetRef(*vLits);
+        else
+          vRefs.resize(nObjsAlloc);
+      }
+    }
+    void TurnOffReo() {
+      nReo = BvarMax();
+    }
+    var GetNumVars() const {
+      return nVars;
+    }
+    void GetOrdering(std::vector<int> &Var2Level_) {
+      Var2Level_.resize(nVars);
+      for(var v = 0; v < nVars; v++)
+        Var2Level_[v] = Var2Level[v];
+    }
+    bvar CountNodes() {
+      bvar count = 1;
+      if(!vEdges.empty()) {
+        for(bvar a = 1; a < nObjs; a++)
+          if(EdgeOfBvar(a))
+            count++;
+        return count;
+      }
+      for(bvar a = 1; a <= (bvar)nVars; a++) {
+        count++;
+        SetMarkOfBvar(a);
+      }
+      for(bvar a = (bvar)nVars + 1; a < nObjs; a++)
+        if(RefOfBvar(a))
+          count += CountNodes_rec(Bvar2Lit(a));
+      for(bvar a = 1; a <= (bvar)nVars; a++)
+        ResetMarkOfBvar(a);
+      for(bvar a = (bvar)nVars + 1; a < nObjs; a++)
+        if(RefOfBvar(a))
+          ResetMark_rec(Bvar2Lit(a));
+      return count;
+    }
+    bvar CountNodes(std::vector<lit> const &vLits) {
+      bvar count = 1;
+      for(size_t i = 0; i < vLits.size(); i++)
+        count += CountNodes_rec(vLits[i]);
+      for(size_t i = 0; i < vLits.size(); i++)
+        ResetMark_rec(vLits[i]);
+      return count;
+    }
+    void PrintStats() {
+      bvar nRemoved = 0;
+      bvar a = RemovedHead;
+      while(a)
+        a = vNexts[a], nRemoved++;
+      bvar nLive = 1;
+      for(var v = 0; v < nVars; v++)
+        nLive += vUniqueCounts[v];
+      std::cout << "ref: " << std::setw(10) << (vRefs.empty()? 0: CountNodes()) << ", "
+                << "used: " << std::setw(10) << nObjs << ", "
+                << "live: " << std::setw(10) << nLive << ", "
+                << "dead: " << std::setw(10) << nRemoved << ", "
+                << "alloc: " << std::setw(10) << nObjsAlloc
+                << std::endl;
+    }
+  };
+
+}
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrBddMspfAnalyzer.h b/src/opt/rrr/rrrBddMspfAnalyzer.h
new file mode 100644
index 000000000..1634a5fd6
--- /dev/null
+++ b/src/opt/rrr/rrrBddMspfAnalyzer.h
@@ -0,0 +1,731 @@
+#pragma once
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+#include "rrrBddManager.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk>
+  class BddMspfAnalyzer {
+  private:
+    // aliases
+    using lit = int;
+    static constexpr lit LitMax = 0xffffffff;
+
+    // pointer to network
+    Ntk *pNtk;
+    
+    // parameters
+    int nVerbose;
+    
+    // data
+    NewBdd::Man *pBdd;
+    std::vector<lit> vFs;
+    std::vector<lit> vGs;
+    std::vector<std::vector<lit>> vvCs;
+    bool fUpdate;
+    std::vector<bool> vUpdates;
+    std::vector<bool> vGUpdates;
+    std::vector<bool> vCUpdates;
+    std::vector<bool> vVisits;
+    
+    // backups
+    std::vector<BddMspfAnalyzer> vBackups;
+
+    // BDD utils
+    void IncRef(lit x) const;
+    void DecRef(lit x) const;
+    void Assign(lit &x, lit y) const;
+    void CopyVec(std::vector<lit> &x, std::vector<lit> const &y) const;
+    void DelVec(std::vector<lit> &v) const;
+    void CopyVecVec(std::vector<std::vector<lit>> &x, std::vector<std::vector<lit>> const &y) const;
+    void DelVecVec(std::vector<std::vector<lit>> &v) const;
+    lit  Xor(lit x, lit y) const;
+
+    // callback
+    void ActionCallback(Action const &action);
+
+    // allocation
+    void Allocate();
+
+    // simulation
+    bool SimulateNode(int id, std::vector<lit> &v) const;
+    void Simulate();
+
+    // PF computation
+    bool ComputeReconvergentG(int id);
+    bool ComputeG(int id);
+    void ComputeC(int id);
+    bool ComputeCDebug(int id);
+    void MspfNode(int id);
+    void Mspf(int id = -1, bool fC = true);
+
+    // save & load
+    void Save(int slot);
+    void Load(int slot);
+    void PopBack();
+    
+  public:
+    // constructors
+    BddMspfAnalyzer();
+    BddMspfAnalyzer(Parameter const *pPar);
+    ~BddMspfAnalyzer();
+    void UpdateNetwork(Ntk *pNtk_, bool fSame);
+
+    // checks
+    bool CheckRedundancy(int id, int idx);
+    bool CheckFeasibility(int id, int fi, bool c);
+  };
+  
+  /* {{{ BDD utils */
+  
+  template <typename Ntk>
+  inline void BddMspfAnalyzer<Ntk>::IncRef(lit x) const {
+    if(x != LitMax) {
+      pBdd->IncRef(x);
+    }
+  }
+  
+  template <typename Ntk>
+  inline void BddMspfAnalyzer<Ntk>::DecRef(lit x) const {
+    if(x != LitMax) {
+      pBdd->DecRef(x);
+    }
+  }
+  
+  template <typename Ntk>
+  inline void BddMspfAnalyzer<Ntk>::Assign(lit &x, lit y) const {
+    DecRef(x);
+    x = y;
+    IncRef(x);
+  }
+
+  template <typename Ntk>
+  inline void BddMspfAnalyzer<Ntk>::CopyVec(std::vector<lit> &x, std::vector<lit> const &y) const {
+    for(size_t i = y.size(); i < x.size(); i++) {
+      DecRef(x[i]);
+    }
+    x.resize(y.size(), LitMax);
+    for(size_t i = 0; i < y.size(); i++) {
+      if(x[i] != y[i]) {
+        DecRef(x[i]);
+        x[i] = y[i];
+        IncRef(x[i]);
+      }
+    }
+  }
+
+  template <typename Ntk>
+  inline void BddMspfAnalyzer<Ntk>::DelVec(std::vector<lit> &v) const {
+    for(lit x: v) {
+      DecRef(x);
+    }
+    v.clear();
+  }
+
+  template <typename Ntk>
+  inline void BddMspfAnalyzer<Ntk>::CopyVecVec(std::vector<std::vector<lit>> &x, std::vector<std::vector<lit>> const &y) const {
+    for(size_t i = y.size(); i < x.size(); i++) {
+      DelVec(x[i]);
+    }
+    x.resize(y.size());
+    for(size_t i = 0; i < y.size(); i++) {
+      CopyVec(x[i], y[i]);
+    }
+  }
+
+  template <typename Ntk>
+  inline void BddMspfAnalyzer<Ntk>::DelVecVec(std::vector<std::vector<lit>> &v) const {
+    for(size_t i = 0; i < v.size(); i++) {
+      DelVec(v[i]);
+    }
+    v.clear();
+  }
+  
+  template <typename Ntk>
+  inline typename BddMspfAnalyzer<Ntk>::lit BddMspfAnalyzer<Ntk>::Xor(lit x, lit y) const {
+    lit f = pBdd->And(x, pBdd->LitNot(y));
+    pBdd->IncRef(f);
+    lit g = pBdd->And(pBdd->LitNot(x), y);
+    pBdd->IncRef(g);
+    lit r = pBdd->Or(f, g);
+    pBdd->DecRef(f);
+    pBdd->DecRef(g);
+    return r;
+  }
+  
+  /* }}} */
+
+  /* {{{ Callback */
+
+  template <typename Ntk>
+  void BddMspfAnalyzer<Ntk>::ActionCallback(Action const &action) {
+    switch(action.type) {
+    case REMOVE_FANIN:
+      fUpdate = true;
+      std::fill(vVisits.begin(), vVisits.end(), false);
+      vUpdates[action.id] = true;
+      vCUpdates[action.id] = true;
+      vGUpdates[action.fi] = true;
+      DecRef(vvCs[action.id][action.idx]);
+      vvCs[action.id].erase(vvCs[action.id].begin() + action.idx);
+      break;
+    case REMOVE_UNUSED:
+      if(vGUpdates[action.id] || vCUpdates[action.id]) {
+        for(int fi: action.vFanins) {
+          vGUpdates[fi] = true;
+        }
+      }
+      Assign(vGs[action.id], LitMax);
+      DelVec(vvCs[action.id]);
+      break;
+    case REMOVE_BUFFER:
+      if(vUpdates[action.id]) {
+        fUpdate = true;
+        for(int fo: action.vFanouts) {
+          vUpdates[fo] = true;
+          vCUpdates[fo] = true;
+        }
+      }
+      if(vGUpdates[action.id] || vCUpdates[action.id]) {
+        vGUpdates[action.fi] = true;
+      }
+      Assign(vGs[action.id], LitMax);
+      DelVec(vvCs[action.id]);
+      break;
+    case REMOVE_CONST:
+      if(vUpdates[action.id]) {
+        fUpdate = true;
+        for(int fo: action.vFanouts) {
+          vUpdates[fo] = true;
+          vCUpdates[fo] = true;
+        }
+      }
+      for(int fi: action.vFanins) {
+        vGUpdates[fi] = true;
+      }
+      break;
+    case ADD_FANIN:
+      fUpdate = true;
+      std::fill(vVisits.begin(), vVisits.end(), false);
+      vUpdates[action.id] = true;
+      vCUpdates[action.id] = true;
+      vvCs[action.id].insert(vvCs[action.id].begin() + action.idx, LitMax);
+      break;
+    case TRIVIAL_COLLAPSE: {
+      if(vGUpdates[action.fi] || vCUpdates[action.fi]) {
+        vCUpdates[action.id] = true;
+      }
+      std::vector<lit>::iterator it = vvCs[action.id].begin() + action.idx;
+      DecRef(*it);
+      it = vvCs[action.id].erase(it);
+      vvCs[action.id].insert(it,  vvCs[action.fi].begin(), vvCs[action.fi].end());
+      vvCs[action.fi].clear();
+      Assign(vFs[action.fi], LitMax);
+      Assign(vGs[action.fi], LitMax);
+      break;
+    }
+    case TRIVIAL_DECOMPOSE: {
+      Allocate();
+      SimulateNode(action.fi, vFs);
+      assert(vGs[action.fi] == LitMax);
+      std::vector<lit>::iterator it = vvCs[action.id].begin() + action.idx;
+      assert(vvCs[action.fi].empty());
+      vvCs[action.fi].insert(vvCs[action.fi].begin(), it, vvCs[action.id].end());
+      vvCs[action.id].erase(it, vvCs[action.id].end());
+      assert(vvCs[action.id].size() == action.idx);
+      if(!vGUpdates[action.id] && !vCUpdates[action.id]) {
+        // recompute here only when updates are unlikely to happen
+        if(pBdd->IsConst1(vGs[action.id])) {
+          Assign(vGs[action.fi], pBdd->Const1());
+        } else {
+          lit x = pBdd->Const1();
+          IncRef(x);
+          for(int idx2 = 0; idx2 < action.idx; idx2++) {
+            int fi = pNtk->GetFanin(action.id, idx2);
+            bool c = pNtk->GetCompl(action.id, idx2);
+            Assign(x, pBdd->And(x, pBdd->LitNotCond(vFs[fi], c)));
+          }
+          Assign(vGs[action.fi], pBdd->Or(pBdd->LitNot(x), vGs[action.id]));
+          DecRef(x);
+        }
+      } else {
+        // otherwise mark the node for future update
+        vCUpdates[action.id] = true;
+      }
+      vvCs[action.id].resize(action.idx + 1, LitMax);
+      Assign(vvCs[action.id][action.idx], vGs[action.fi]);
+      vUpdates[action.fi] = false;
+      vGUpdates[action.fi] = false;
+      vCUpdates[action.fi] = false;
+      break;
+    }
+    case SORT_FANINS: {
+      std::vector<lit> vCs = vvCs[action.id];
+      vvCs[action.id].clear();
+      for(int index: action.vIndices) {
+        vvCs[action.id].push_back(vCs[index]);
+      }
+      break;
+    }
+    case SAVE:
+      Save(action.idx);
+      break;
+    case LOAD:
+      Load(action.idx);
+      break;
+    case POP_BACK:
+      PopBack();
+      break;
+    default:
+      assert(0);
+    }
+  }
+  
+  /* }}} */
+
+  /* {{{ Allocation */
+
+  template <typename Ntk>
+  void BddMspfAnalyzer<Ntk>::Allocate() {
+    int nNodes = pNtk->GetNumNodes();
+    vFs.resize(nNodes, LitMax);
+    vGs.resize(nNodes, LitMax);
+    vvCs.resize(nNodes);
+    vUpdates.resize(nNodes);
+    vGUpdates.resize(nNodes);
+    vCUpdates.resize(nNodes);
+    vVisits.resize(nNodes);
+  }
+
+  /* }}} */
+  
+  /* {{{ Simulation */
+  
+  template <typename Ntk>
+  inline bool BddMspfAnalyzer<Ntk>::SimulateNode(int id, std::vector<lit> &v) const {
+    if(nVerbose) {
+      std::cout << "simulating node " << id << std::endl;
+    }
+    lit x = pBdd->Const1();
+    IncRef(x);
+    pNtk->ForEachFanin(id, [&](int fi, bool c) {
+      Assign(x, pBdd->And(x, pBdd->LitNotCond(v[fi], c)));
+    });
+    if(pBdd->LitIsEq(x, v[id])) {
+      DecRef(x);
+      return false;
+    }
+    Assign(v[id], x);
+    DecRef(x);
+    return true;
+  }
+  
+  template <typename Ntk>
+  void BddMspfAnalyzer<Ntk>::Simulate() {
+    if(nVerbose) {
+      std::cout << "symbolic simulation with BDD" << std::endl;
+    }
+    pNtk->ForEachInt([&](int id) {
+      if(vUpdates[id]) {
+        if(SimulateNode(id, vFs)) {
+          pNtk->ForEachFanout(id, false, [&](int fo) {
+            vUpdates[fo] = true;
+            vCUpdates[fo] = true;
+          });
+        }
+        vUpdates[id] = false;
+      }
+    });
+  }
+
+  /* }}} */
+
+  /* {{{ MSPF computation */
+
+  template <typename pNtk>
+  inline bool BddMspfAnalyzer<pNtk>::ComputeReconvergentG(int id) {
+    std::vector<lit> v;
+    CopyVec(v, vFs);
+    v[id] = pBdd->LitNot(v[id]);
+    pNtk->ForEachTfoUpdate(id, false, [&](int fo) {
+      return SimulateNode(fo, v);
+    });
+    lit x = pBdd->Const1();
+    IncRef(x);
+    pNtk->ForEachPoDriver([&](int fi) {
+      lit y = Xor(vFs[fi], v[fi]);
+      IncRef(y);
+      Assign(x, pBdd->And(x, pBdd->LitNot(y)));
+      DecRef(y);
+    });
+    if(pBdd->LitIsEq(vGs[id], x)) {
+      DecRef(x);
+      DelVec(v);
+      return false;
+    }
+    Assign(vGs[id], x);
+    DecRef(x);
+    DelVec(v);
+    return true;
+  }
+  
+  template <typename pNtk>
+  inline bool BddMspfAnalyzer<pNtk>::ComputeG(int id) {
+    if(pNtk->GetNumFanouts(id) == 0) {
+      if(pBdd->IsConst1(vGs[id])) {
+        return false;
+      }
+      Assign(vGs[id], pBdd->Const1());
+      return true;
+    }
+    lit x = pBdd->Const1();
+    IncRef(x);
+    pNtk->ForEachFanoutRidx(id, true, [&](int fo, int idx) {
+      Assign(x, pBdd->And(x, vvCs[fo][idx]));
+    });
+    if(pBdd->LitIsEq(vGs[id], x)) {
+      DecRef(x);
+      return false;
+    }
+    Assign(vGs[id], x);
+    DecRef(x);
+    return true;
+  }
+
+  template <typename pNtk>
+  inline void BddMspfAnalyzer<pNtk>::ComputeC(int id) {
+    int nFanins = pNtk->GetNumFanins(id);
+    assert(vvCs[id].size() == nFanins);
+    if(pBdd->IsConst1(vGs[id])) {
+      for(int idx = 0; idx < nFanins; idx++) {
+        if(!pBdd->IsConst1(vvCs[id][idx])) {
+          Assign(vvCs[id][idx], pBdd->Const1());
+          int fi = pNtk->GetFanin(id, idx);
+          vGUpdates[fi] = true;
+        }
+      }
+      return;
+    }
+    for(int idx = 0; idx < nFanins; idx++) {
+      lit x = pBdd->Const1();
+      IncRef(x);
+      for(int idx2 = 0; idx2 < nFanins; idx2++) {
+        if(idx2 != idx) {
+          int fi = pNtk->GetFanin(id, idx2);
+          bool c = pNtk->GetCompl(id, idx2);
+          Assign(x, pBdd->And(x, pBdd->LitNotCond(vFs[fi], c)));
+        }
+      }
+      Assign(x, pBdd->Or(pBdd->LitNot(x), vGs[id]));
+      if(!pBdd->LitIsEq(vvCs[id][idx], x)) {
+        Assign(vvCs[id][idx], x);
+        int fi = pNtk->GetFanin(id, idx);
+        vGUpdates[fi] = true;
+      }
+      DecRef(x);
+    }
+  }
+  
+  template <typename pNtk>
+  inline bool BddMspfAnalyzer<pNtk>::ComputeCDebug(int id) {
+    bool fUpdated = false;
+    int nFanins = pNtk->GetNumFanins(id);
+    assert(vvCs[id].size() == nFanins);
+    if(pBdd->IsConst1(vGs[id])) {
+      for(int idx = 0; idx < nFanins; idx++) {
+        if(!pBdd->IsConst1(vvCs[id][idx])) {
+          Assign(vvCs[id][idx], pBdd->Const1());
+          int fi = pNtk->GetFanin(id, idx);
+          vGUpdates[fi] = true;
+          fUpdated = true;
+        }
+      }
+      return fUpdated;
+    }
+    for(int idx = 0; idx < nFanins; idx++) {
+      lit x = pBdd->Const1();
+      IncRef(x);
+      for(int idx2 = 0; idx2 < nFanins; idx2++) {
+        if(idx2 != idx) {
+          int fi = pNtk->GetFanin(id, idx2);
+          bool c = pNtk->GetCompl(id, idx2);
+          Assign(x, pBdd->And(x, pBdd->LitNotCond(vFs[fi], c)));
+        }
+      }
+      Assign(x, pBdd->Or(pBdd->LitNot(x), vGs[id]));
+      if(!pBdd->LitIsEq(vvCs[id][idx], x)) {
+        Assign(vvCs[id][idx], x);
+        int fi = pNtk->GetFanin(id, idx);
+        vGUpdates[fi] = true;
+        fUpdated = true;
+      }
+      DecRef(x);
+    }
+    return fUpdated;
+  }
+
+  template <typename pNtk>
+  void BddMspfAnalyzer<pNtk>::MspfNode(int id) {
+    if(vGUpdates[id]) {
+      if(pNtk->IsReconvergent(id)) {
+        if(nVerbose) {
+          std::cout << "computing reconvergent node " << id << " G " << std::endl;
+        }
+        if(ComputeReconvergentG(id)) {
+          vCUpdates[id] = true;
+        }
+      } else {
+        if(nVerbose) {
+          std::cout << "computing node " << id << " G " << std::endl;
+        }
+        if(ComputeG(id)) {
+          vCUpdates[id] = true;
+        }
+      }
+      vGUpdates[id] = false;
+    } else if(!vVisits[id] && pNtk->IsReconvergent(id)) {
+      if(nVerbose) {
+        std::cout << "computing unvisited reconvergent node " << id << " G " << std::endl;
+      }
+      if(ComputeReconvergentG(id)) {
+        vCUpdates[id] = true;
+      }
+    }
+    if(vCUpdates[id]) {
+      if(nVerbose) {
+        std::cout << "computing node " << id << " C " << std::endl;
+      }
+      ComputeC(id);
+      vCUpdates[id] = false;
+    }
+    vVisits[id] = true;
+  }
+
+  template <typename pNtk>
+  void BddMspfAnalyzer<pNtk>::Mspf(int id, bool fC) {
+    if(id != -1) {
+      pNtk->ForEachTfoReverse(id, false, [&](int fo) {
+        MspfNode(fo);
+      });
+      bool fCUpdate = vCUpdates[id];
+      if(!fC) {
+        vCUpdates[id] = false;
+      }
+      MspfNode(id);
+      if(!fC) {
+        vCUpdates[id] = fCUpdate;
+      }
+    } else {
+      pNtk->ForEachIntReverse([&](int id) {
+        MspfNode(id);
+      });
+    }
+  }
+
+  /* }}} */
+
+  /* {{{ Save & load */
+
+  template <typename Ntk>
+  void BddMspfAnalyzer<Ntk>::Save(int slot) {
+    if(slot >= int_size(vBackups)) {
+      vBackups.resize(slot + 1);
+    }
+    CopyVec(vBackups[slot].vFs, vFs);
+    CopyVec(vBackups[slot].vGs, vGs);
+    CopyVecVec(vBackups[slot].vvCs, vvCs);
+    vBackups[slot].fUpdate = fUpdate;
+    vBackups[slot].vUpdates = vUpdates;
+    vBackups[slot].vGUpdates = vGUpdates;
+    vBackups[slot].vCUpdates = vCUpdates;
+    vBackups[slot].vVisits = vVisits;
+  }
+
+  template <typename Ntk>
+  void BddMspfAnalyzer<Ntk>::Load(int slot) {
+    assert(slot < int_size(vBackups));
+    CopyVec(vFs, vBackups[slot].vFs);
+    CopyVec(vGs, vBackups[slot].vGs);
+    CopyVecVec(vvCs, vBackups[slot].vvCs);
+    fUpdate = vBackups[slot].fUpdate;
+    vUpdates = vBackups[slot].vUpdates;
+    vGUpdates = vBackups[slot].vGUpdates;
+    vCUpdates = vBackups[slot].vCUpdates;
+    vVisits = vBackups[slot].vVisits;
+  }
+
+  template <typename Ntk>
+  void BddMspfAnalyzer<Ntk>::PopBack() {
+    assert(!vBackups.empty());
+    DelVec(vBackups.back().vFs);
+    DelVec(vBackups.back().vGs);
+    DelVecVec(vBackups.back().vvCs);
+    vBackups.pop_back();
+  }
+
+  /* }}} */
+  
+  /* {{{ Constructor */
+
+  template <typename Ntk>
+  BddMspfAnalyzer<Ntk>::BddMspfAnalyzer() :
+    pNtk(NULL),
+    nVerbose(0),
+    pBdd(NULL) {
+  }
+  
+  template <typename Ntk>
+  BddMspfAnalyzer<Ntk>::BddMspfAnalyzer(Parameter const *pPar) :
+    pNtk(NULL),
+    nVerbose(pPar->nAnalyzerVerbose),
+    pBdd(NULL),
+    fUpdate(false) {
+  }
+
+  template <typename Ntk>
+  void BddMspfAnalyzer<Ntk>::UpdateNetwork(Ntk *pNtk_, bool fSame) {
+    // clear
+    while(!vBackups.empty()) {
+      PopBack();
+    }
+    DelVec(vFs);
+    DelVec(vGs);
+    DelVecVec(vvCs);
+    pNtk = pNtk_;
+    fUpdate = false;
+    vUpdates.clear();
+    vGUpdates.clear();
+    vCUpdates.clear();
+    vVisits.clear();
+    // alloc
+    bool fUseReo = false;
+    if(!pBdd || pBdd->GetNumVars() != pNtk->GetNumPis()) {
+      // need to reset manager
+      delete pBdd;
+      NewBdd::Param Par;
+      Par.nObjsMaxLog = 25;
+      Par.nCacheMaxLog = 20;
+      Par.fCountOnes = true;
+      Par.nGbc = 1;
+      Par.nReo = 4000;
+      pBdd = new NewBdd::Man(pNtk->GetNumPis(), Par);
+      fUseReo = true;
+    } else if(!fSame) {
+      // turning on reordering if network function changed
+      pBdd->TurnOnReo();
+      fUseReo = true;
+    }
+    Allocate();
+    // prepare
+    Assign(vFs[0], pBdd->Const0());
+    int idx = 0;
+    pNtk->ForEachPi([&](int id) {
+      Assign(vFs[id], pBdd->IthVar(idx));
+      idx++;
+    });
+    pNtk->ForEachInt([&](int id) {
+      vUpdates[id] = true;
+    });
+    Simulate();
+    if(fUseReo) {
+      pBdd->Reorder();
+      pBdd->TurnOffReo();
+    }
+    pNtk->ForEachInt([&](int id) {
+      vvCs[id].resize(pNtk->GetNumFanins(id), LitMax);
+    });
+    pNtk->ForEachPo([&](int id) {
+      vvCs[id].resize(1, LitMax);
+      Assign(vvCs[id][0], pBdd->Const0());
+      int fi = pNtk->GetFanin(id, 0);
+      vGUpdates[fi]  = true;
+    });
+    pNtk->AddCallback(std::bind(&BddMspfAnalyzer<Ntk>::ActionCallback, this, std::placeholders::_1));
+  }
+  
+  template <typename Ntk>
+  BddMspfAnalyzer<Ntk>::~BddMspfAnalyzer() {
+    while(!vBackups.empty()) {
+      PopBack();
+    }
+    DelVec(vFs);
+    DelVec(vGs);
+    DelVecVec(vvCs);
+    if(pBdd) {
+      pBdd->PrintStats();
+    }
+    delete pBdd;
+  }
+
+  /* }}} */
+
+  /* {{{ Checks */
+  
+  template <typename Ntk>
+  bool BddMspfAnalyzer<Ntk>::CheckRedundancy(int id, int idx) {
+    if(fUpdate) {
+      Simulate();
+      fUpdate = false;
+    }
+    Mspf(id);
+    switch(pNtk->GetNodeType(id)) {
+    case AND: {
+      int fi = pNtk->GetFanin(id, idx);
+      bool c = pNtk->GetCompl(id, idx);
+      lit x = pBdd->Or(pBdd->LitNotCond(vFs[fi], c), vvCs[id][idx]);
+      if(pBdd->IsConst1(x)) {
+        if(nVerbose) {
+          std::cout << "node " << id << " fanin " << (pNtk->GetCompl(id, idx)? "!": "") << pNtk->GetFanin(id, idx) << " index " << idx << " is redundant" << std::endl;
+        }
+        return true;
+      }
+      break;
+    }
+    default:
+      assert(0);
+    }
+    if(nVerbose) {
+      std::cout << "node " << id << " fanin " << (pNtk->GetCompl(id, idx)? "!": "") << pNtk->GetFanin(id, idx) << " index " << idx << " is NOT redundant" << std::endl;
+    }
+    return false;
+  }
+  
+  template <typename Ntk>
+  bool BddMspfAnalyzer<Ntk>::CheckFeasibility(int id, int fi, bool c) {
+    if(fUpdate) {
+      Simulate();
+      fUpdate = false;
+    }
+    Mspf(id, false);
+    switch(pNtk->GetNodeType(id)) {
+    case AND: {
+      lit x = pBdd->Or(pBdd->LitNot(vFs[id]), vGs[id]);
+      IncRef(x);
+      lit y = pBdd->Or(x, pBdd->LitNotCond(vFs[fi], c));
+      DecRef(x);
+      if(pBdd->IsConst1(y)) {
+        if(nVerbose) {
+          std::cout << "node " << id << " fanin " << (c? "!": "") << fi << " is feasible" << std::endl;
+        }
+        return true;
+      }
+      break;
+    }
+    default:
+      assert(0);
+    }
+    if(nVerbose) {
+      std::cout << "node " << id << " fanin " << (c? "!": "") << fi << " is NOT feasible" << std::endl;
+    }
+    return false;
+  }
+
+  /* }}} */
+  
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrOptimizer.h b/src/opt/rrr/rrrOptimizer.h
new file mode 100644
index 000000000..8d30368f1
--- /dev/null
+++ b/src/opt/rrr/rrrOptimizer.h
@@ -0,0 +1,907 @@
+#pragma once
+
+#include <map>
+#include <iterator>
+#include <random>
+#include <numeric>
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk, typename Ana>
+  class Optimizer {
+  private:
+    // aliases
+    using itr = std::vector<int>::iterator;
+    using citr = std::vector<int>::const_iterator;
+    using ritr = std::vector<int>::reverse_iterator;
+    using critr = std::vector<int>::const_reverse_iterator;
+
+    // pointer to network
+    Ntk *pNtk;
+    
+    // parameters
+    int nVerbose;
+    std::function<double(Ntk *)> CostFunction;
+    int nSortType;
+    int nFlow;
+    int nDistance;
+    bool fCompatible;
+    seconds nTimeout; // assigned upon Run
+
+    // data
+    Ana ana;
+    std::mt19937 rng;
+    std::vector<int> vTmp;
+    std::map<int, std::set<int>> mapNewFanins;
+    time_point start;
+
+    // fanin sorting data
+    std::vector<int> vRandPiOrder;
+    std::vector<double> vRandCosts;
+
+    // marks
+    int target;
+    std::vector<bool> vTfoMarks;
+    
+    // callback
+    void ActionCallback(Action const &action);
+
+    // topology
+    void MarkTfo(int id);
+
+    // time
+    bool Timeout();
+
+    // sort fanins
+    void SetRandPiOrder();
+    void SetRandCosts();
+    void SortFanins(int id);
+    void SortFanins();
+
+    // reduce fanins
+    bool ReduceFanins(int id, bool fRemoveUnused = false);
+    bool ReduceFaninsOneRandom(int id, bool fRemoveUnused = false);
+
+    // reduce
+    bool Reduce();
+    void ReduceRandom();
+
+    // remove redundancy
+    void RemoveRedundancy();
+    void RemoveRedundancyRandom();
+
+    // addition
+    template <typename T>
+    T SingleAdd(int id, T begin, T end);
+    int  MultiAdd(int id, std::vector<int> const &vCands, int nMax = 0);
+
+    // resub
+    void SingleResub(int id, std::vector<int> const &vCands, bool fGreedy = true);
+    void MultiResub(int id, std::vector<int> const &vCands, bool fGreedy = true, int nMax = 0);
+    
+    // apply
+    void ApplyReverseTopologically(std::function<void(int)> const &func);
+    
+  public:
+    // constructors
+    Optimizer(Parameter const *pPar, std::function<double(Ntk *)> CostFunction);
+    void UpdateNetwork(Ntk *pNtk_, bool fSame = false);
+
+    // run
+    void Run(seconds nTimeout_ = 0);
+    void ResetSeed(int iSeed);
+    void Randomize(int iSeed);
+    
+  };
+
+  /* {{{ Callback */
+  
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::ActionCallback(Action const &action) {
+    if(nVerbose) {
+      PrintAction(action);
+    }
+    switch(action.type) {
+    case REMOVE_FANIN:
+      if(action.id != target) {
+        target = -1;
+      }
+      break;
+    case REMOVE_UNUSED:
+      break;
+    case REMOVE_BUFFER:
+    case REMOVE_CONST:
+      if(action.id == target) {
+        target = -1;
+      }
+      break;
+    case ADD_FANIN:
+      if(action.id != target) {
+        target = -1;
+      }
+      break;
+    case TRIVIAL_COLLAPSE:
+      break;
+    case TRIVIAL_DECOMPOSE:
+      target = -1;
+      break;
+    case SORT_FANINS:
+      break;
+    case SAVE:
+      break;
+    case LOAD:
+      //target = -1; // this is not always needed, so do it manually
+      break;
+    case POP_BACK:
+      break;
+    default:
+      assert(0);
+    }
+  }
+
+  /* }}} */
+
+  /* {{{ Topology */
+  
+  template <typename Ntk, typename Ana>
+  inline void Optimizer<Ntk, Ana>::MarkTfo(int id) {
+    // includes id itself
+    if(id == target) {
+      return;
+    }
+    target = id;
+    vTfoMarks.clear();
+    vTfoMarks.resize(pNtk->GetNumNodes());
+    vTfoMarks[id] = true;
+    pNtk->ForEachTfo(id, false, [&](int fo) {
+      vTfoMarks[fo] = true;
+    });
+  }
+
+  /* }}} */
+
+  /* {{{ Time */
+  
+  template <typename Ntk, typename Ana>
+  inline bool Optimizer<Ntk, Ana>::Timeout() {
+    if(nTimeout) {
+      time_point current = GetCurrentTime();
+      if(DurationInSeconds(start, current) > nTimeout) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /* }}} */
+
+  /* {{{ Sort fanins */
+
+  template <typename Ntk, typename Ana>
+  inline void Optimizer<Ntk, Ana>::SetRandPiOrder() {
+    if(int_size(vRandPiOrder) != pNtk->GetNumPis()) {
+      vRandPiOrder.clear();
+      vRandPiOrder.resize(pNtk->GetNumPis());
+      std::iota(vRandPiOrder.begin(), vRandPiOrder.end(), 0);
+      std::shuffle(vRandPiOrder.begin(), vRandPiOrder.end(), rng);      
+    }    
+  }
+
+  template <typename Ntk, typename Ana>
+  inline void Optimizer<Ntk, Ana>::SetRandCosts() {
+    std::uniform_real_distribution<> dis(std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max());
+    while(int_size(vRandCosts) < pNtk->GetNumNodes()) {
+      vRandCosts.push_back(dis(rng));
+    }
+  }
+
+  template <typename Ntk, typename Ana>
+  inline void Optimizer<Ntk, Ana>::SortFanins(int id) {
+    switch(nSortType) {
+    case 0: // no sorting
+      break;
+    case 1: // prioritize internals
+      pNtk->SortFanins(id, [&](int i, int j) {
+        return !pNtk->IsPi(i) && pNtk->IsPi(j);
+      });
+      break;
+    case 2: // prioritize internals with (reversely) sorted PIs
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return pNtk->GetPiIndex(i) > pNtk->GetPiIndex(j);
+        }
+        return pNtk->IsPi(j);
+      });
+      break;
+    case 3: // prioritize internals with random PI order
+      SetRandPiOrder();
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return vRandPiOrder[pNtk->GetPiIndex(i)] > vRandPiOrder[pNtk->GetPiIndex(j)];
+        }
+        return pNtk->IsPi(j);
+      });
+      break;
+    case 4: // smaller fanout takes larger cost
+      pNtk->SortFanins(id, [&](int i, int j) {
+        return pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j);
+      });
+      break;
+    case 5: // fanout + PI
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && !pNtk->IsPi(j)) {
+          return false;
+        }
+        if(!pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return true;
+        }
+        return pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j);
+      });
+      break;
+    case 6: // fanout + sorted PI
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return pNtk->GetPiIndex(i) > pNtk->GetPiIndex(j);
+        }
+        if(pNtk->IsPi(i)) {
+          return false;
+        }
+        if(pNtk->IsPi(j)) {
+          return true;
+        }
+        return pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j);
+      });
+      break;
+    case 7: // fanout + random PI
+      SetRandPiOrder();
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return vRandPiOrder[pNtk->GetPiIndex(i)] > vRandPiOrder[pNtk->GetPiIndex(j)];
+        }
+        if(pNtk->IsPi(i)) {
+          return false;
+        }
+        if(pNtk->IsPi(j)) {
+          return true;
+        }
+        return pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j);
+      });
+      break;
+    case 8: // reverse topological order + PI
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return false;
+        }
+        if(pNtk->IsPi(i)) {
+          return false;
+        }
+        if(pNtk->IsPi(j)) {
+          return true;
+        }
+        return pNtk->GetIntIndex(i) > pNtk->GetIntIndex(j);
+      });
+      break;
+    case 9: // reverse topological order + sorted PI
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return pNtk->GetPiIndex(i) > pNtk->GetPiIndex(j);
+        }
+        if(pNtk->IsPi(i)) {
+          return false;
+        }
+        if(pNtk->IsPi(j)) {
+          return true;
+        }
+        return pNtk->GetIntIndex(i) > pNtk->GetIntIndex(j);
+      });
+      break;
+    case 10: // reverse topological order + random PI
+      SetRandPiOrder();
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return vRandPiOrder[pNtk->GetPiIndex(i)] > vRandPiOrder[pNtk->GetPiIndex(j)];
+        }
+        if(pNtk->IsPi(i)) {
+          return false;
+        }
+        if(pNtk->IsPi(j)) {
+          return true;
+        }
+        return pNtk->GetIntIndex(i) > pNtk->GetIntIndex(j);
+      });
+      break;
+    case 11: // topo + fanout + PI
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && !pNtk->IsPi(j)) {
+          return false;
+        }
+        if(!pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return true;
+        }
+        if(pNtk->GetNumFanouts(i) > pNtk->GetNumFanouts(j)) {
+          return false;
+        }
+        if(pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j)) {
+          return true;
+        }
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return false;
+        }
+        return pNtk->GetIntIndex(i) > pNtk->GetIntIndex(j);
+      });
+      break;
+    case 12: // topo + fanout + sorted PI
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return pNtk->GetPiIndex(i) > pNtk->GetPiIndex(j);
+        }
+        if(pNtk->IsPi(i)) {
+          return false;
+        }
+        if(pNtk->IsPi(j)) {
+          return true;
+        }
+        if(pNtk->GetNumFanouts(i) > pNtk->GetNumFanouts(j)) {
+          return false;
+        }
+        if(pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j)) {
+          return true;
+        }
+        return pNtk->GetIntIndex(i) > pNtk->GetIntIndex(j);
+      });
+      break;
+    case 13: // topo + fanout + random PI
+      SetRandPiOrder();
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return vRandPiOrder[pNtk->GetPiIndex(i)] > vRandPiOrder[pNtk->GetPiIndex(j)];
+        }
+        if(pNtk->IsPi(i)) {
+          return false;
+        }
+        if(pNtk->IsPi(j)) {
+          return true;
+        }
+        if(pNtk->GetNumFanouts(i) > pNtk->GetNumFanouts(j)) {
+          return false;
+        }
+        if(pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j)) {
+          return true;
+        }
+        return pNtk->GetIntIndex(i) > pNtk->GetIntIndex(j);
+      });
+      break;
+    case 14: // random order
+      SetRandCosts();
+      pNtk->SortFanins(id, [&](int i, int j) {
+        return vRandCosts[i] > vRandCosts[j];
+      });
+      break;
+    case 15: // random + PI
+      SetRandCosts();
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && !pNtk->IsPi(j)) {
+          return false;
+        }
+        if(!pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return true;
+        }
+        return vRandCosts[i] > vRandCosts[j];
+      });
+      break;
+    case 16: // random + fanout
+      SetRandCosts();
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->GetNumFanouts(i) > pNtk->GetNumFanouts(j)) {
+          return false;
+        }
+        if(pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j)) {
+          return true;
+        }
+        return vRandCosts[i] > vRandCosts[j];
+      });
+      break;
+    case 17: // random + fanout + PI
+      SetRandCosts();
+      pNtk->SortFanins(id, [&](int i, int j) {
+        if(pNtk->IsPi(i) && !pNtk->IsPi(j)) {
+          return false;
+        }
+        if(!pNtk->IsPi(i) && pNtk->IsPi(j)) {
+          return true;
+        }
+        if(pNtk->GetNumFanouts(i) > pNtk->GetNumFanouts(j)) {
+          return false;
+        }
+        if(pNtk->GetNumFanouts(i) < pNtk->GetNumFanouts(j)) {
+          return true;
+        }
+        return vRandCosts[i] > vRandCosts[j];
+      });
+      break;
+    default:
+      assert(0);
+    }
+  }
+  
+  template <typename Ntk, typename Ana>
+  inline void Optimizer<Ntk, Ana>::SortFanins() {
+    pNtk->ForEachInt([&](int id) {
+      SortFanins(id);
+    });
+  }
+  
+  /* }}} */
+  
+  /* {{{ Reduce fanins */
+  
+  template <typename Ntk, typename Ana>
+  inline bool Optimizer<Ntk, Ana>::ReduceFanins(int id, bool fRemoveUnused) {
+    assert(pNtk->GetNumFanouts(id) > 0);
+    bool fRemoved = false;
+    for(int idx = 0; idx < pNtk->GetNumFanins(id); idx++) {
+      // skip fanins that were just added
+      if(mapNewFanins.count(id)) {
+        int fi = pNtk->GetFanin(id, idx);
+        if(mapNewFanins[id].count(fi)) {
+          continue;
+        }
+      }
+      // reduce
+      if(ana.CheckRedundancy(id, idx)) {
+        int fi = pNtk->GetFanin(id, idx);
+        pNtk->RemoveFanin(id, idx);
+        fRemoved = true;
+        idx--;
+        if(fRemoveUnused && pNtk->GetNumFanouts(fi) == 0) {
+          pNtk->RemoveUnused(fi, true);
+        }
+      }
+    }
+    return fRemoved;
+  }
+
+  /*
+  template <typename Ntk, typename Ana>
+  inline bool Optimizer<Ntk, Ana>::ReduceFaninsOneRandom(int id, bool fRemoveUnused) {
+    assert(pNtk->GetNumFanouts(id) > 0);
+    // generate random order
+    vTmp.resize(pNtk->GetNumFanins(id));
+    std::iota(vTmp.begin(), vTmp.end(), 0);
+    std::shuffle(vTmp.begin(), vTmp.end(), rng);
+    for(int idx: vTmp) {
+      // skip fanins that were just added
+      if(mapNewFanins.count(id)) {
+        int fi = pNtk->GetFanin(id, idx);
+        if(mapNewFanins[id].count(fi)) {
+          continue;
+        }
+      }
+      // reduce
+      if(ana.CheckRedundancy(id, idx)) {
+        int fi = pNtk->GetFanin(id, idx);
+        pNtk->RemoveFanin(id, idx);
+        if(fRemoveUnused && pNtk->GetNumFanouts(fi) == 0) {
+          pNtk->RemoveUnused(fi, true);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  */
+  
+  // TODO: add a method to minimize the size of fanins (check singles, pairs, trios, and so on)?
+  
+  /* }}} */
+  
+  /* {{{ Reduce */
+
+  template <typename Ntk, typename Ana>
+  bool Optimizer<Ntk, Ana>::Reduce() {
+    bool fReduced = false;
+    std::vector<int> vInts = pNtk->GetInts();
+    for(critr it = vInts.rbegin(); it != vInts.rend(); it++) {
+      if(!pNtk->IsInt(*it)) {
+        continue;
+      }
+      if(pNtk->GetNumFanouts(*it) == 0) {
+        pNtk->RemoveUnused(*it);
+        continue;
+      }
+      fReduced |= ReduceFanins(*it);
+      if(pNtk->GetNumFanins(*it) <= 1) {
+        pNtk->Propagate(*it);
+      }
+    }
+    return fReduced;
+  }
+
+  /*
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::ReduceRandom() {
+    pNtk->Sweep(false);
+    std::vector<int> vInts = pNtk->GetInts();
+    std::shuffle(vInts.begin(), vInts.end(), rng);
+    for(citr it = vInts.begin(); it != vInts.end(); it++) {
+      if(!pNtk->IsInt(*it)) {
+        continue;
+      }
+      if(pNtk->GetNumFanouts(*it) == 0) {
+        pNtk->RemoveUnused(*it);
+        continue;
+      }
+      ReduceFanins(*it, true);
+      if(pNtk->GetNumFanins(*it) <= 1) {
+        pNtk->Propagate(*it);
+      }
+    }
+  }
+  */
+
+  /* }}} */
+
+  /* {{{ Redundancy removal */
+  
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::RemoveRedundancy() {
+    if(fCompatible) {
+      while(Reduce()) {
+        SortFanins();
+      }
+      return;
+    }
+    std::vector<int> vInts = pNtk->GetInts();
+    for(critr it = vInts.rbegin(); it != vInts.rend();) {
+      if(!pNtk->IsInt(*it)) {
+        it++;
+        continue;
+      }
+      if(pNtk->GetNumFanouts(*it) == 0) {
+        pNtk->RemoveUnused(*it);
+        it++;
+        continue;
+      }
+      SortFanins(*it);
+      bool fReduced = ReduceFanins(*it);
+      if(pNtk->GetNumFanins(*it) <= 1) {
+        pNtk->Propagate(*it);
+      }
+      if(fReduced) {
+        it = vInts.rbegin();
+      } else {
+        it++;
+      }
+    }
+  }
+
+  /*
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::RemoveRedundancyRandom() {
+    pNtk->Sweep(false);
+    std::vector<int> vInts = pNtk->GetInts();
+    std::shuffle(vInts.begin(), vInts.end(), rng);
+    for(citr it = vInts.begin(); it != vInts.end();) {
+      if(!pNtk->IsInt(*it)) {
+        it++;
+        continue;
+      }
+      if(pNtk->GetNumFanouts(*it) == 0) {
+        pNtk->RemoveUnused(*it);
+        it++;
+        continue;
+      }
+      bool fReduced = ReduceFaninsOneRandom(*it, true);
+      if(pNtk->GetNumFanins(*it) <= 1) {
+        pNtk->Propagate(*it);
+      }
+      if(fReduced) {
+        std::shuffle(vInts.begin(), vInts.end(), rng);
+        it = vInts.begin();
+      } else {
+        it++;
+      }
+    }
+  }
+  */
+
+  /* }}} */
+
+  /* {{{ Addition */
+
+  template <typename Ntk, typename Ana>
+  template <typename T>
+  T Optimizer<Ntk, Ana>::SingleAdd(int id, T begin, T end) {
+    MarkTfo(id);
+    pNtk->ForEachFanin(id, [&](int fi) {
+      vTfoMarks[fi] = true;
+    });
+    T it = begin;
+    for(; it != end; it++) {
+      if(!pNtk->IsInt(*it) && !pNtk->IsPi(*it)) {
+        continue;
+      }
+      if(vTfoMarks[*it]) {
+        continue;
+      }
+      if(ana.CheckFeasibility(id, *it, false)) {
+        pNtk->AddFanin(id, *it, false);
+      } else if(pNtk->UseComplementedEdges() && ana.CheckFeasibility(id, *it, true)) {
+        pNtk->AddFanin(id, *it, true);
+      } else {
+        continue;
+      }
+      mapNewFanins[id].insert(*it);
+      break;
+    }
+    pNtk->ForEachFanin(id, [&](int fi) {
+      vTfoMarks[fi] = false;
+    });
+    return it;
+  }
+
+  template <typename Ntk, typename Ana>
+  int Optimizer<Ntk, Ana>::MultiAdd(int id, std::vector<int> const &vCands, int nMax) {
+    MarkTfo(id);
+    pNtk->ForEachFanin(id, [&](int fi) {
+      vTfoMarks[fi] = true;
+    });
+    int nAdded = 0;
+    for(int cand: vCands) {
+      if(!pNtk->IsInt(cand) && !pNtk->IsPi(cand)) {
+        continue;
+      }
+      if(vTfoMarks[cand]) {
+        continue;
+      }
+      if(ana.CheckFeasibility(id, cand, false)) {
+        pNtk->AddFanin(id, cand, false);
+      } else if(pNtk->UseComplementedEdges() && ana.CheckFeasibility(id, cand, true)) {
+        pNtk->AddFanin(id, cand, true);
+      } else {
+        continue;
+      }
+      mapNewFanins[id].insert(cand);
+      nAdded++;
+      if(nAdded == nMax) {
+        break;
+      }
+    }
+    pNtk->ForEachFanin(id, [&](int fi) {
+      vTfoMarks[fi] = false;
+    });
+    return nAdded;
+  }
+
+  /* }}} */
+  
+  /* {{{ Resub */
+
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::SingleResub(int id, std::vector<int> const &vCands, bool fGreedy) {
+    // NOTE: this assumes trivial collapse/decompose does not change cost
+    // let us assume the node is not trivially redundant for now
+    assert(pNtk->GetNumFanouts(id) != 0);
+    assert(pNtk->GetNumFanins(id) > 1);
+    // collapse
+    pNtk->TrivialCollapse(id);
+    // save if wanted
+    int slot;
+    if(fGreedy) {
+      slot = pNtk->Save();
+    }
+    double dCost = CostFunction(pNtk);
+    // main loop
+    for(citr it = vCands.begin(); it != vCands.end(); it++) {
+      if(Timeout()) {
+        break;
+      }
+      if(!pNtk->IsInt(id)) {
+        break;
+      }
+      it = SingleAdd<citr>(id, it, vCands.end());
+      if(it == vCands.end()) {
+        break;
+      }
+      RemoveRedundancy();
+      mapNewFanins.clear();
+      double dNewCost = CostFunction(pNtk);
+      if(nVerbose) {
+        std::cout << "cost: " << dCost << " -> " << dNewCost << std::endl;
+      }
+      if(fGreedy) {
+        if(dNewCost <= dCost) {
+          pNtk->Save(slot);
+          dCost = dNewCost;
+        } else {
+          pNtk->Load(slot);
+        }
+      } else {
+        dCost = dNewCost;
+      }
+    }
+    if(pNtk->IsInt(id)) {
+      pNtk->TrivialDecompose(id);
+      SortFanins();
+      if(fCompatible) {
+        RemoveRedundancy();
+      }
+    }
+    if(fGreedy) {
+      pNtk->PopBack();
+    }
+  }
+
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::MultiResub(int id, std::vector<int> const &vCands, bool fGreedy, int nMax) {
+    // NOTE: this assumes trivial collapse/decompose does not change cost
+    // let us assume the node is not trivially redundant for now
+    assert(pNtk->GetNumFanouts(id) != 0);
+    assert(pNtk->GetNumFanins(id) > 1);
+    // save if wanted
+    int slot;
+    if(fGreedy) {
+      slot = pNtk->Save();
+    }
+    double dCost = CostFunction(pNtk);
+    // collapse
+    pNtk->TrivialCollapse(id);
+    // resub
+    MultiAdd(id, vCands, nMax);
+    RemoveRedundancy();
+    mapNewFanins.clear();
+    RemoveRedundancy();
+    double dNewCost = CostFunction(pNtk);
+    if(nVerbose) {
+      std::cout << "cost: " << dCost << " -> " << dNewCost << std::endl;
+    }
+    if(fGreedy && dNewCost > dCost) {
+      pNtk->Load(slot);
+    }
+    if(pNtk->IsInt(id)) {
+      pNtk->TrivialDecompose(id);
+    }
+    if(fGreedy) {
+      pNtk->PopBack();
+    }
+  }
+  
+  /* }}} */
+
+  /* {{{ Apply */
+
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::ApplyReverseTopologically(std::function<void(int)> const &func) {
+    std::vector<int> vInts = pNtk->GetInts();
+    for(critr it = vInts.rbegin(); it != vInts.rend(); it++) {
+      if(Timeout()) {
+        break;
+      }
+      if(!pNtk->IsInt(*it)) {
+        continue;
+      }
+      if(nVerbose) {
+        std::cout << "node " << *it << " (" << std::distance(vInts.crbegin(), it) + 1 << "/" << vInts.size() << ")" << std::endl;
+      }
+      func(*it);
+    }
+  }
+  
+  /* }}} */
+  
+  /* {{{ Constructors */
+  
+  template <typename Ntk, typename Ana>
+  Optimizer<Ntk, Ana>::Optimizer(Parameter const *pPar, std::function<double(Ntk *)> CostFunction) :
+    pNtk(NULL),
+    nVerbose(pPar->nOptimizerVerbose),
+    CostFunction(CostFunction),
+    nSortType(pPar->nSortType),
+    nFlow(pPar->nOptimizerFlow),
+    nDistance(pPar->nDistance),
+    fCompatible(pPar->fUseBddCspf),
+    ana(pPar),
+    target(-1) {
+  }
+  
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::UpdateNetwork(Ntk *pNtk_, bool fSame) {
+    pNtk = pNtk_;
+    target = -1;
+    pNtk->AddCallback(std::bind(&Optimizer<Ntk, Ana>::ActionCallback, this, std::placeholders::_1));
+    ana.UpdateNetwork(pNtk, fSame);
+  }
+  
+  /* }}} */
+
+  /* {{{ Run */
+
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::Run(seconds nTimeout_) {
+    nTimeout = nTimeout_;
+    start = GetCurrentTime();
+    switch(nFlow) {
+    case 0:
+      RemoveRedundancy();
+      ApplyReverseTopologically([&](int id) {
+        std::vector<int> vCands;
+        if(nDistance) {
+          vCands = pNtk->GetNeighbors(id, true, nDistance);
+        } else {
+          vCands = pNtk->GetPisInts();
+        }
+        SingleResub(id, vCands);
+      });
+      break;
+    case 1:
+      RemoveRedundancy();
+      ApplyReverseTopologically([&](int id) {
+        std::vector<int> vCands;
+        if(nDistance) {
+          vCands = pNtk->GetNeighbors(id, true, nDistance);
+        } else {
+          vCands = pNtk->GetPisInts();
+        }
+        MultiResub(id, vCands);
+      });
+      break;
+    case 2: {
+      RemoveRedundancy();
+      double dCost = CostFunction(pNtk);
+      while(true) {
+        ApplyReverseTopologically([&](int id) {
+          std::vector<int> vCands;
+          if(nDistance) {
+            vCands = pNtk->GetNeighbors(id, true, nDistance);
+          } else {
+            vCands = pNtk->GetPisInts();
+          }
+          SingleResub(id, vCands);
+        });
+        ApplyReverseTopologically([&](int id) {
+          std::vector<int> vCands;
+          if(nDistance) {
+            vCands = pNtk->GetNeighbors(id, true, nDistance);
+          } else {
+            vCands = pNtk->GetPisInts();
+            // vCands = pNtk->GetInts();
+          }
+          MultiResub(id, vCands);
+        });
+        double dNewCost = CostFunction(pNtk);
+        if(dNewCost < dCost) {
+          dCost = dNewCost;
+        } else {
+          break;
+        }
+      }
+      break;
+    }
+    default:
+      assert(0);
+    }
+  }
+
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::ResetSeed(int iSeed) {
+    rng.seed(iSeed);
+    vRandPiOrder.clear();
+    vRandCosts.clear();
+  }
+  
+  template <typename Ntk, typename Ana>
+  void Optimizer<Ntk, Ana>::Randomize(int iSeed) {
+    ResetSeed(iSeed);
+    nSortType = rng() % 18;
+  }
+  
+  /* }}} */
+  
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrParameter.h b/src/opt/rrr/rrrParameter.h
new file mode 100644
index 000000000..22429511b
--- /dev/null
+++ b/src/opt/rrr/rrrParameter.h
@@ -0,0 +1,32 @@
+#pragma once
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  struct Parameter {
+    int iSeed = 0;
+    int nWords = 10;
+    int nTimeout = 0;
+    int nSchedulerVerbose = 1;
+    int nPartitionerVerbose = 0;
+    int nOptimizerVerbose = 0;
+    int nAnalyzerVerbose = 0;
+    int nSimulatorVerbose = 0;
+    int nSatSolverVerbose = 0;
+    bool fUseBddCspf = false;
+    bool fUseBddMspf = false;
+    int nConflictLimit = 0;
+    int nSortType = 12;
+    int nOptimizerFlow = 0;
+    int nSchedulerFlow = 0;
+    int nDistance = 0;
+    int nRestarts = 0;
+    int nThreads = 1;
+    int nWindowSize = 0;
+    bool fDeterministic = true;
+  };
+  
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrPartitioner.h b/src/opt/rrr/rrrPartitioner.h
new file mode 100644
index 000000000..a2993e8e8
--- /dev/null
+++ b/src/opt/rrr/rrrPartitioner.h
@@ -0,0 +1,323 @@
+#pragma once
+
+#include <utility>
+#include <map>
+#include <tuple>
+#include <random>
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk>
+  class Partitioner {
+  private:
+    // pointer to network
+    Ntk *pNtk;
+
+    // parameters
+    int nVerbose;
+    int nWindowSize;
+
+    // data
+    std::map<Ntk *, std::tuple<std::set<int>, std::vector<int>, std::vector<bool>, std::vector<int>>> mSubNtk2Io;
+    std::set<int> sBlocked;
+
+    // subroutines
+    Ntk *ExtractDisjoint(int id);
+    
+  public:
+    // constructors
+    Partitioner(Parameter const *pPar);
+    void UpdateNetwork(Ntk *pNtk);
+
+    // APIs
+    Ntk *Extract(int iSeed);
+    void Insert(Ntk *pSubNtk);
+  };
+
+  /* {{{ Subroutines */
+
+  template <typename Ntk>
+  Ntk *Partitioner<Ntk>::ExtractDisjoint(int id) {
+    // collect neighbor
+    assert(!sBlocked.count(id));
+    if(nVerbose) {
+      std::cout << "extracting with a center node " << id << std::endl;
+    }
+    int nRadius = 2;
+    std::vector<int> vNodes = pNtk->GetNeighbors(id, false, nRadius);
+    std::vector<int> vNodesNew = pNtk->GetNeighbors(id, false, nRadius + 1);
+    // gradually increase radius until it hits window size limit
+    while(int_size(vNodesNew) < nWindowSize) {
+      if(int_size(vNodes) == int_size(vNodesNew)) { // already maximum
+        break;
+      }
+      vNodes = vNodesNew;
+      nRadius++;
+      vNodesNew = pNtk->GetNeighbors(id, false, nRadius + 1);
+    }
+    std::set<int> sNodes(vNodes.begin(), vNodes.end());
+    sNodes.insert(id);
+    if(nVerbose) {
+      std::cout << "neighbors: " << sNodes << std::endl;
+    }
+    // remove nodes that are already blocked
+    for(std::set<int>::iterator it = sNodes.begin(); it != sNodes.end();) {
+      if(sBlocked.count(*it)) {
+        it = sNodes.erase(it);
+      } else {
+        it++;
+      }
+    }
+    if(nVerbose) {
+      std::cout << "disjoint neighbors: " << sNodes << std::endl;
+    }
+    // get tentative window IO
+    std::set<int> sInputs, sOutputs;
+    for(int id: sNodes) {
+      pNtk->ForEachFanin(id, [&](int fi) {
+        if(!sNodes.count(fi)) {
+          sInputs.insert(fi);
+        }
+      });
+      bool fOutput = false;
+      pNtk->ForEachFanout(id, true, [&](int fo) {
+        if(!sNodes.count(fo)) {
+          fOutput = true;
+        }
+      });
+      if(fOutput) {
+        sOutputs.insert(id);
+      }
+    }
+    if(nVerbose) {
+      std::cout << "\tinputs: " << sInputs << std::endl;
+      std::cout << "\toutputs: " << sOutputs << std::endl;
+    }
+    // prevent potential loops while ensuring disjointness
+    // first by including inner nodes
+    std::set<int> sFanouts;
+    for(int id: sOutputs) {
+      pNtk->ForEachFanout(id, false, [&](int fo) {
+        if(!sNodes.count(fo)) {
+          sFanouts.insert(fo);
+        }
+      });
+    }
+    std::vector<int> vInners = pNtk->GetInners(sFanouts, sInputs);
+    while(!vInners.empty()) {
+      if(nVerbose) {
+        std::cout << "inners: " << vInners << std::endl;
+      }
+      if(int_size(sNodes) + int_size(vInners) > 2 * nWindowSize) {
+        // TODO: parametrize
+        break;
+      }
+      bool fOverlap = false;
+      for(int i: vInners) {
+        if(sBlocked.count(i)) {
+          fOverlap = true;
+          break;
+        }
+      }
+      if(fOverlap) {
+        break;
+      }
+      sNodes.insert(vInners.begin(), vInners.end());
+      if(nVerbose) {
+        std::cout << "new neighbors: " << sNodes << std::endl;
+      }
+      sInputs.clear();
+      sOutputs.clear();
+      for(int id: sNodes) {
+        pNtk->ForEachFanin(id, [&](int fi) {
+          if(!sNodes.count(fi)) {
+            sInputs.insert(fi);
+          }
+        });
+        bool fOutput = false;
+        pNtk->ForEachFanout(id, true, [&](int fo) {
+          if(!sNodes.count(fo)) {
+            fOutput = true;
+          }
+        });
+        if(fOutput) {
+          sOutputs.insert(id);
+        }
+      }
+      if(nVerbose) {
+        std::cout << "\tnew inputs: " << sInputs << std::endl;
+        std::cout << "\tnew outputs: " << sOutputs << std::endl;
+      }
+      sFanouts.clear();
+      for(int id: sOutputs) {
+        pNtk->ForEachFanout(id, false, [&](int fo) {
+          if(!sNodes.count(fo)) {
+            sFanouts.insert(fo);
+          }
+        });
+      }
+      vInners = pNtk->GetInners(sFanouts, sInputs);
+    }
+    if(!vInners.empty()) {
+      // fall back method by removing TFI of outputs reachable to inputs
+      for(int id: sOutputs) {
+        if(!sNodes.count(id)) { // already removed
+          continue;
+        }
+        sFanouts.clear();
+        pNtk->ForEachFanout(id, false, [&](int fo) {
+          if(!sNodes.count(fo)) {
+            sFanouts.insert(fo);
+          }
+        });
+        if(pNtk->IsReachable(sFanouts, sInputs)) {
+          if(nVerbose) {
+            std::cout << id << " is reachable to inputs" << std::endl;
+          }
+          sNodes.erase(id);
+          pNtk->ForEachTfiEnd(id, sInputs, [&](int fi) {
+            int r = sNodes.erase(fi);
+            assert(r);
+          });
+          if(nVerbose) {
+            std::cout << "new neighbors: " << sNodes << std::endl;
+          }
+          if(sNodes.empty()) {
+            if(nVerbose) {
+              std::cout << "IS EMPTY" << std::endl;
+            }
+            return NULL;
+          }
+          // recompute inputs
+          sInputs.clear();
+          for(int id: sNodes) {
+            pNtk->ForEachFanin(id, [&](int fi) {
+              if(!sNodes.count(fi)) {
+                sInputs.insert(fi);
+              }
+            });
+          }
+          if(nVerbose) {
+            std::cout << "\tnew inputs: " << sInputs << std::endl;
+          }
+        }
+      }
+      // recompute outputs
+      for(std::set<int>::iterator it = sOutputs.begin(); it != sOutputs.end();) {
+        if(!sNodes.count(*it)) {
+          it = sOutputs.erase(it);
+        } else {
+          it++;
+        }
+      }
+      if(nVerbose) {
+        std::cout << "\tnew outputs: " << sOutputs << std::endl;
+      }
+    }
+    // ensure outputs of both windows do not reach each other's inputs at the same time
+    for(auto const &entry: mSubNtk2Io) {
+      if(!pNtk->IsReachable(sOutputs, std::get<1>(entry.second))) {
+        continue;
+      }
+      if(!pNtk->IsReachable(std::get<3>(entry.second), sInputs)) {
+        continue;
+      }
+      if(nVerbose) {
+        std::cout << "POTENTIAL LOOPS" << std::endl;
+      }
+      return NULL;
+    }
+    if(int_size(sNodes) < nWindowSize / 2) {
+      // too small
+      // TODO: fix this parameterized
+      return NULL;
+    }
+    // extract by inputs, internals, and outputs (no checks needed in ntk side)
+    std::vector<int> vInputs(sInputs.begin(), sInputs.end());
+    std::vector<int> vOutputs(sOutputs.begin(), sOutputs.end());
+    Ntk *pSubNtk = pNtk->Extract(sNodes, vInputs, vOutputs);
+    // return subntk to be modified, while remember IOs
+    for(int i: sNodes) {
+      sBlocked.insert(i);
+    }
+    mSubNtk2Io.emplace(pSubNtk, std::make_tuple(std::move(sNodes), std::move(vInputs), std::vector<bool>(vInputs.size()), std::move(vOutputs)));
+    return pSubNtk;
+  }
+  
+  /* }}} */
+
+  /* {{{ Constructors */
+  
+  template <typename Ntk>
+  Partitioner<Ntk>::Partitioner(Parameter const *pPar) :
+    nVerbose(pPar->nPartitionerVerbose),
+    nWindowSize(pPar->nWindowSize) {
+  }
+
+  template <typename Ntk>
+  void Partitioner<Ntk>::UpdateNetwork(Ntk *pNtk_) {
+    pNtk = pNtk_;
+  }
+
+  /* }}} */
+
+  /* {{{ APIs */
+  
+  template <typename Ntk>
+  Ntk *Partitioner<Ntk>::Extract(int iSeed) {
+    // pick a center node from candidates that do not belong to any other ongoing windows
+    std::mt19937 rng(iSeed);
+    std::vector<int> vInts = pNtk->GetInts();
+    std::shuffle(vInts.begin(), vInts.end(), rng);
+    for(int id: vInts) {
+      if(!sBlocked.count(id)) {
+        Ntk *pSubNtk = ExtractDisjoint(id);
+        if(pSubNtk) {
+          return pSubNtk;
+        }
+      }
+    }
+    return NULL;
+  }
+
+  template <typename Ntk>
+  void Partitioner<Ntk>::Insert(Ntk *pSubNtk) {
+    for(int i: std::get<0>(mSubNtk2Io[pSubNtk])) {
+      sBlocked.erase(i);
+    }
+    std::pair<std::vector<int>, std::vector<bool>> vNewSignals = pNtk->Insert(pSubNtk, std::get<1>(mSubNtk2Io[pSubNtk]), std::get<2>(mSubNtk2Io[pSubNtk]), std::get<3>(mSubNtk2Io[pSubNtk]));
+    std::vector<int> &vOldOutputs = std::get<3>(mSubNtk2Io[pSubNtk]);
+    std::vector<int> &vNewOutputs = vNewSignals.first;
+    std::vector<bool> &vNewCompls = vNewSignals.second;
+    // need to remap updated outputs that are used as inputs in other windows
+    std::map<int, int> mOutput2Idx;
+    for(int idx = 0; idx < int_size(vOldOutputs); idx++) {
+      mOutput2Idx[vOldOutputs[idx]] = idx;
+    }
+    for(auto &entry: mSubNtk2Io) {
+      if(entry.first != pSubNtk) {
+        std::vector<int> &vInputs = std::get<1>(entry.second);
+        std::vector<bool> &vCompls = std::get<2>(entry.second);
+        for(int i = 0; i < int_size(vInputs); i++) {
+          if(mOutput2Idx.count(vInputs[i])) {
+            int idx = mOutput2Idx[vInputs[i]];
+            vInputs[i] = vNewOutputs[idx];
+            vCompls[i] = vCompls[i] ^ vNewCompls[idx];
+          }
+        }
+      }
+    }
+    delete pSubNtk;
+    mSubNtk2Io.erase(pSubNtk);
+  }
+
+  /* }}} */
+  
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrSatSolver.h b/src/opt/rrr/rrrSatSolver.h
new file mode 100644
index 000000000..ac9fa4c45
--- /dev/null
+++ b/src/opt/rrr/rrrSatSolver.h
@@ -0,0 +1,542 @@
+#pragma once
+
+#include <sat/bsat/satSolver.h>
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk>
+  class SatSolver {
+  private:
+    // pointer to network
+    Ntk *pNtk;
+
+    // parameters
+    int nVerbose;
+    int nConflictLimit;
+
+    // data
+    sat_solver *pSat;
+    bool status; // false indicates trivial UNSAT
+    int  target; // node for which miter has been encoded
+    std::vector<int> vVars; // SAT variable for each node
+    std::vector<int> vLits; // temporary storage
+    std::vector<VarValue> vValues; // values in satisfied problem
+    bool fUpdate;
+
+    // statistics
+    int nCalls;
+    int nSats;
+    int nUnsats;
+
+    // callback
+    void ActionCallback(Action const &action);
+
+    // encode
+    void EncodeNode(sat_solver *p, std::vector<int> const &v, int id, int to_negate = -1) const;
+    void EncodeMiter(sat_solver *p, std::vector<int> &v, int id); // create a careset miter where the counterpart has the output of target negated
+    void SetTarget(int id);
+    
+  public:
+    // constructors
+    SatSolver(Parameter const *pPar);
+    ~SatSolver();
+    void UpdateNetwork(Ntk *pNtk_, bool fSame);
+    
+    // checks
+    SatResult CheckRedundancy(int id, int idx);
+    SatResult CheckFeasibility(int id, int fi, bool c);
+
+    // cex
+    std::vector<VarValue> GetCex();
+  };
+
+  /* {{{ Callback */
+
+  template <typename Ntk>
+  void SatSolver<Ntk>::ActionCallback(Action const &action) {
+    if(target == -1) {
+      return;
+    }
+    switch(action.type) {
+    case REMOVE_FANIN:
+      if(action.id != target) {
+        fUpdate = true;
+      }
+      break;
+    case REMOVE_UNUSED:
+      break;
+    case REMOVE_BUFFER:
+    case REMOVE_CONST:
+      if(action.id == target) {
+        target = -1;
+      }
+      break;
+    case ADD_FANIN:
+      if(action.id != target) {
+        fUpdate = true;
+      }
+      break;
+    case TRIVIAL_COLLAPSE:
+      break;
+    case TRIVIAL_DECOMPOSE:
+      fUpdate = true;
+      break;
+    case SORT_FANINS:
+      break;
+    case SAVE:
+      break;
+    case LOAD:
+      target = -1;
+      break;
+    case POP_BACK:
+      break;
+    default:
+      assert(0);
+    }
+  }
+
+  /* }}} */
+  
+  /* {{{ Encode */
+
+  template <typename Ntk>
+  void SatSolver<Ntk>::EncodeNode(sat_solver *p, std::vector<int> const &v, int id, int to_negate) const {
+    int RetValue;
+    int x = -1, y = -1;
+    bool cx, cy;
+    assert(pNtk->GetNodeType(id) == AND);
+    std::string delim;
+    if(nVerbose) {
+      std::cout << "node " << std::setw(3) << id << ": ";
+    }
+    pNtk->ForEachFanin(id, [&](int fi, bool c) {
+      if(x == -1) {
+        x = v[fi];
+        cx = c ^ (fi == to_negate);
+      } else if(y == -1) {
+        y = v[fi];
+        cy = c ^ (fi == to_negate);
+      } else {
+        int z = sat_solver_addvar(p);
+        if(nVerbose) {
+          std::cout << delim << z << " = " << (cx? "!": "") << x << " & " << (cy? "!": "") << y << std::endl;
+          delim = std::string(10, ' ');
+        }
+        RetValue = sat_solver_add_and(p, z, x, y, cx, cy, 0);
+        assert(RetValue);
+        x = z;
+        cx = false;
+        y = v[fi];
+        cy = c ^ (fi == to_negate);
+      }
+    });
+    if(x == -1) {
+      if(nVerbose) {
+        std::cout << delim << v[id] << " = !0" << std::endl;
+      }
+      RetValue = sat_solver_add_const(p, v[id], 0);
+      assert(RetValue);
+    } else if(y == -1) {
+      if(nVerbose) {
+        std::cout << delim << v[id] << " = " << (cx? "!": "") << x << std::endl;
+      }
+      RetValue = sat_solver_add_buffer(p, v[id], x, cx);
+      assert(RetValue);
+    } else {
+      if(nVerbose) {
+        std::cout << delim << v[id] << " = " << (cx? "!": "") << x << " & " << (cy? "!": "") << y << std::endl;
+      }
+      RetValue = sat_solver_add_and(p, v[id], x, y, cx, cy, 0);
+      assert(RetValue);
+    }
+  }
+  
+  template <typename Ntk>
+  void SatSolver<Ntk>::EncodeMiter(sat_solver *p, std::vector<int> &v, int id) {
+    int RetValue;
+    // reset
+    v.clear();
+    sat_solver_restart(p);
+    status = true;
+    // assign vars for the base
+    int nNodes = pNtk->GetNumNodes();
+    sat_solver_setnvars(p, nNodes);
+    v.resize(nNodes);
+    for(int i = 0; i < nNodes; i++) {
+      v[i] = i;
+    }
+    // constrain const-0
+    RetValue = sat_solver_add_const(p, v[0], 1);
+    assert(RetValue);
+    // encode first circuit
+    if(nVerbose) {
+      std::cout << "encoding network" << std::endl;
+    }
+    pNtk->ForEachInt([&](int id) {
+      EncodeNode(p, v, id);
+    });
+    // always care if it is po
+    if(pNtk->IsPoDriver(id)) {
+      return;
+    }
+    // store po vars (NOTE: it's not a lit)
+    vLits.clear();
+    pNtk->ForEachPoDriver([&](int fi) {
+      vLits.push_back(v[fi]);
+    });
+    // encode an inverted copy
+    if(nVerbose) {
+      std::cout << "encoding an inverted copy" << std::endl;
+    }
+    pNtk->ForEachTfo(id, false, [&](int fo) {
+      v[fo] = sat_solver_addvar(p);
+      EncodeNode(p, v, fo, id);
+    });
+    // encode miter xors
+    if(nVerbose) {
+      std::cout << "encoding miter xors" << std::endl;
+    }
+    int idx = 0;
+    int n = 0;
+    pNtk->ForEachPoDriver([&](int fi) {
+      assert(fi != id);
+      if(v[fi] != vLits[idx]) {
+        int x = sat_solver_addvar(p);
+        if(nVerbose) {
+          std::cout << x << " = " << v[fi] << " ^ " << vLits[idx] << std::endl;
+        }
+        RetValue = sat_solver_add_xor(p, x, v[fi], vLits[idx], 0);
+        assert(RetValue);
+        vLits[n] = toLitCond(x, 0);
+        n++;
+      }
+      idx++;
+    });
+    vLits.resize(n);
+    // assign or of xors to 1
+    if(nVerbose) {
+      std::cout << "adding miter output clause" << std::endl;
+      std::cout << "(";
+      std::string delim = "";
+      for(int iLit: vLits) {
+        std::cout << delim << (lit_sign(iLit)? "!": "") << lit_var(iLit);
+        delim = ", ";
+      }
+      std::cout << ")" << std::endl;
+    }
+    if(n == 0) {
+      status = false;
+      return;
+    }
+    RetValue = sat_solver_addclause(p, vLits.data(), vLits.data() + n);
+    assert(RetValue);
+  }
+
+  template <typename Ntk>
+  void SatSolver<Ntk>::SetTarget(int id) {
+    if(!fUpdate && id == target) {
+      return;
+    }
+    fUpdate = false;
+    target = id;
+    EncodeMiter(pSat, vVars, target);
+  }
+
+  /* }}} */
+
+  /* {{{ Constructors */
+
+  template <typename Ntk>
+  SatSolver<Ntk>::SatSolver(Parameter const *pPar) :
+    pNtk(NULL),
+    nVerbose(pPar->nSatSolverVerbose),
+    nConflictLimit(pPar->nConflictLimit),
+    pSat(sat_solver_new()),
+    status(false),
+    target(-1),
+    fUpdate(false),
+    nCalls(0),
+    nSats(0),
+    nUnsats(0) {
+  }
+
+  template <typename Ntk>
+  SatSolver<Ntk>::~SatSolver() {
+    sat_solver_delete(pSat);
+    std::cout << "SAT solver stats: calls = " << nCalls << " (SAT = " << nSats << ", UNSAT = " << nUnsats << ", UNDET = " << nCalls - nSats - nUnsats << ")" << std::endl;
+  }
+
+  template <typename Ntk>
+  void SatSolver<Ntk>::UpdateNetwork(Ntk *pNtk_, bool fSame) {
+    (void)fSame;
+    pNtk = pNtk_;
+    status = false;
+    target = -1;
+    fUpdate = false;
+    pNtk->AddCallback(std::bind(&SatSolver<Ntk>::ActionCallback, this, std::placeholders::_1));
+  }
+
+  /* }}} */
+
+  /* {{{ Checks */
+  
+  template <typename Ntk>
+  SatResult SatSolver<Ntk>::CheckRedundancy(int id, int idx) {
+    SetTarget(id);
+    if(!status) {
+      if(nVerbose) {
+        std::cout << "trivially UNSATISFIABLE" << std::endl;
+      }
+      return UNSAT;
+    }
+    vLits.clear();
+    assert(pNtk->GetNodeType(id) == AND);    
+    pNtk->ForEachFaninIdx(id, [&](int idx2, int fi, bool c) {
+      if(idx == idx2) {
+        vLits.push_back(toLitCond(vVars[fi], !c));
+      } else {
+        vLits.push_back(toLitCond(vVars[fi], c));
+      }
+    });
+    if(nVerbose) {
+      std::cout << "solving with assumptions: ";
+      std::string delim = "";
+      for(int iLit: vLits) {
+        std::cout << delim << (lit_sign(iLit)? "!": "") << lit_var(iLit);
+        delim = ", ";
+      }
+      std::cout << std::endl;
+    }
+    nCalls++;
+    int res = sat_solver_solve(pSat, vLits.data(), vLits.data() + vLits.size(), nConflictLimit, 0 /*nInsLimit*/, 0 /*nConfLimitGlobal*/, 0 /*nInsLimitGlobal*/);
+    if(res == l_False) {
+      if(nVerbose) {
+        std::cout << "UNSATISFIABLE" << std::endl;
+      }
+      nUnsats++;
+      return UNSAT;
+    }
+    if(res == l_Undef) {
+      if(nVerbose) {
+        std::cout << "UNDETERMINED" << std::endl;
+      }
+      return UNDET;
+    }
+    assert(res == l_True);
+    if(nVerbose) {
+      std::cout << "SATISFIABLE" << std::endl;
+    }
+    nSats++;
+    vValues.clear();
+    vValues.resize(pNtk->GetNumNodes());
+    pNtk->ForEachPi([&](int id) {
+      if(sat_solver_var_value(pSat, vVars[id])) {
+        vValues[id] = TEMP_TRUE;
+      } else {
+        vValues[id] = TEMP_FALSE;
+      }
+    });
+    pNtk->ForEachInt([&](int id) {
+      if(sat_solver_var_value(pSat, vVars[id])) {
+        vValues[id] = TEMP_TRUE;
+      } else {
+        vValues[id] = TEMP_FALSE;
+      }
+    });
+    // required values
+    pNtk->ForEachFaninIdx(id, [&](int idx2, int fi, bool c) {
+      assert((vValues[fi] == TEMP_TRUE) ^ (idx == idx2) ^ c);
+      vValues[fi] = DecideVarValue(vValues[fi]);
+    });
+    return SAT;
+  }
+
+  template <typename Ntk>
+  SatResult SatSolver<Ntk>::CheckFeasibility(int id, int fi, bool c) {
+    SetTarget(id);
+    if(!status) {
+      if(nVerbose) {
+        std::cout << "trivially UNSATISFIABLE" << std::endl;
+      }
+      return UNSAT;
+    }
+    vLits.clear();
+    assert(pNtk->GetNodeType(id) == AND);
+    vLits.push_back(toLit(vVars[id]));
+    vLits.push_back(toLitCond(vVars[fi], !c));
+    if(nVerbose) {
+      std::cout << "solving with assumptions: ";
+      std::string delim = "";
+      for(int iLit: vLits) {
+        std::cout << delim << (lit_sign(iLit)? "!": "") << lit_var(iLit);
+        delim = ", ";
+      }
+      std::cout << std::endl;
+    }
+    nCalls++;
+    int res = sat_solver_solve(pSat, vLits.data(), vLits.data() + vLits.size(), nConflictLimit, 0 /*nInsLimit*/, 0 /*nConfLimitGlobal*/, 0 /*nInsLimitGlobal*/);
+    if(res == l_False) {
+      if(nVerbose) {
+        std::cout << "UNSATISFIABLE" << std::endl;
+      }
+      nUnsats++;
+      return UNSAT;
+    }
+    if(res == l_Undef) {
+      if(nVerbose) {
+        std::cout << "UNDETERMINED" << std::endl;
+      }
+      return UNDET;
+    }
+    assert(res == l_True);
+    if(nVerbose) {
+      std::cout << "SATISFIABLE" << std::endl;
+    }
+    nSats++;
+    vValues.clear();
+    vValues.resize(pNtk->GetNumNodes());
+    pNtk->ForEachPi([&](int id) {
+      if(sat_solver_var_value(pSat, vVars[id])) {
+        vValues[id] = TEMP_TRUE;
+      } else {
+        vValues[id] = TEMP_FALSE;
+      }
+    });
+    pNtk->ForEachInt([&](int id) {
+      if(sat_solver_var_value(pSat, vVars[id])) {
+        vValues[id] = TEMP_TRUE;
+      } else {
+        vValues[id] = TEMP_FALSE;
+      }
+    });
+    // required values
+    assert(vValues[id] == TEMP_TRUE);
+    vValues[id] = DecideVarValue(vValues[id]);
+    assert((vValues[fi] == TEMP_TRUE) ^ !c);
+    vValues[fi] = DecideVarValue(vValues[fi]);
+    return SAT;
+  }
+  
+  /* }}} */
+
+  /* {{{ Cex */
+
+  template <typename Ntk>
+  std::vector<VarValue> SatSolver<Ntk>::GetCex() {
+    if(nVerbose) {
+      std::cout << "cex: ";
+      pNtk->ForEachPi([&](int id) {
+        std::cout << GetVarValueChar(vValues[id]);
+      });
+      std::cout << std::endl;
+    }
+    // reverse simulation
+    pNtk->ForEachIntReverse([&](int id) {
+      switch(pNtk->GetNodeType(id)) {
+      case AND:
+        if(vValues[id] == TRUE) {
+          pNtk->ForEachFanin(id, [&](int fi, bool c) {
+            assert((vValues[fi] == TEMP_TRUE || vValues[fi] == TRUE) ^ c);
+            vValues[fi] = DecideVarValue(vValues[fi]);
+          });
+        } else if(vValues[id] == FALSE) {
+          bool fFound =  false;
+          pNtk->ForEachFanin(id, [&](int fi, bool c) {
+            if(fFound) {
+              return;
+            }
+            if(c) {
+              if(vValues[fi] == TRUE) {
+                fFound = true;
+              }
+            } else {
+              if(vValues[fi] == FALSE) {
+                fFound = true;
+              }
+            }
+          });
+          if(!fFound) {
+            pNtk->ForEachFanin(id, [&](int fi, bool c) {
+              if(fFound) {
+                return;
+              }
+              if(c) {
+                if(vValues[fi] == TEMP_TRUE) {
+                  fFound = true;
+                  vValues[fi] = DecideVarValue(vValues[fi]);
+                }
+              } else {
+                if(vValues[fi] == TEMP_FALSE) {
+                  fFound = true;
+                  vValues[fi] = DecideVarValue(vValues[fi]);
+                }
+              }
+            });
+          }
+        }
+        break;
+      default:
+        assert(0);
+      }
+    });
+    if(nVerbose) {
+      std::cout << "pex: ";
+      pNtk->ForEachPi([&](int id) {
+        std::cout << GetVarValueChar(vValues[id]);
+      });
+      std::cout << std::endl;
+    }
+    // debug
+    pNtk->ForEachInt([&](int id) {
+      switch(pNtk->GetNodeType(id)) {
+      case AND:
+        if(vValues[id] == TRUE) {
+          pNtk->ForEachFanin(id, [&](int fi, bool c) {
+            assert(c || vValues[fi] == TRUE);
+            assert(!c || vValues[fi] == FALSE);
+          });
+        } else if(vValues[id] == FALSE) {
+          bool fFound =  false;
+          pNtk->ForEachFanin(id, [&](int fi, bool c) {
+            if(fFound) {
+              return;
+            }
+            if(c) {
+              if(vValues[fi] == TRUE) {
+                fFound = true;
+              }
+            } else {
+              if(vValues[fi] == FALSE) {
+                fFound = true;
+              }
+            }
+          });
+          assert(fFound);
+        }
+        break;
+      default:
+        assert(0);
+      }
+      });
+    // retrieve partial cex
+    std::vector<VarValue> vPartialCex;
+    pNtk->ForEachPi([&](int id) {
+      if(vValues[id] == TRUE || vValues[id] == FALSE) {
+        vPartialCex.push_back(vValues[id]);
+      } else {
+        vPartialCex.push_back(UNDEF);
+      }
+    });
+    return vPartialCex;
+  }
+
+  /* }}} */
+
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrScheduler.h b/src/opt/rrr/rrrScheduler.h
new file mode 100644
index 000000000..c8b5a16a0
--- /dev/null
+++ b/src/opt/rrr/rrrScheduler.h
@@ -0,0 +1,499 @@
+#pragma once
+
+#include <queue>
+#include <random>
+
+#ifdef ABC_USE_PTHREADS
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#endif
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+#include "rrrPartitioner.h"
+#include "rrrAbc.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk, typename Opt>
+  class Scheduler {
+  private:
+    // job
+    struct Job;
+    struct CompareJobPointers;
+    
+    // pointer to network
+    Ntk *pNtk;
+
+    // parameters
+    int nVerbose;
+    int iSeed;
+    int nFlow;
+    int nRestarts;
+    bool fMultiThreading;
+    bool fPartitioning;
+    bool fDeterministic;
+    seconds nTimeout;
+    std::function<double(Ntk *)> CostFunction;
+    
+    // data
+    int nJobs;
+    int nFinishedJobs;
+    time_point start;
+    Partitioner<Ntk> par;
+    std::queue<Job *> qPendingJobs;
+    Opt *pOpt; // used only in case of single thread execution
+#ifdef ABC_USE_PTHREADS
+    bool fTerminate;
+    std::vector<std::thread> vThreads;
+    std::priority_queue<Job *, std::vector<Job *>, CompareJobPointers> qFinishedJobs;
+    std::mutex mutexAbc;
+    std::mutex mutexPendingJobs;
+    std::mutex mutexFinishedJobs;
+    std::condition_variable condPendingJobs;
+    std::condition_variable condFinishedJobs;
+#endif
+
+    // time
+    seconds GetRemainingTime() const;
+
+    // abc
+    void CallAbc(Ntk *pNtk_, std::string Command);
+
+    // run jobs
+    void RunJob(Opt &opt, Job const *pJob);
+
+    // manage jobs
+    void CreateJob(Ntk *pNtk_, int iSeed_);
+    void OnJobEnd(std::function<void(Job *pJob)> const &func);
+
+    // thread
+#ifdef ABC_USE_PTHREADS
+    void Thread(Parameter const *pPar);
+#endif
+    
+  public:
+    // constructors
+    Scheduler(Ntk *pNtk, Parameter const *pPar);
+    ~Scheduler();
+    
+    // run
+    void Run();
+  };
+
+  /* {{{ Job */
+  
+  template <typename Ntk, typename Opt>
+  struct Scheduler<Ntk, Opt>::Job {
+    // data
+    int id;
+    Ntk *pNtk;
+    int iSeed;
+    
+    // constructor
+    Job(int id, Ntk *pNtk, int iSeed) :
+      id(id),
+      pNtk(pNtk),
+      iSeed(iSeed) {
+    }
+  };
+
+  template <typename Ntk, typename Opt>
+  struct Scheduler<Ntk, Opt>::CompareJobPointers {
+    // smaller id comes first in priority_queue
+    bool operator()(Job const *lhs, Job const *rhs) const {
+      return lhs->id > rhs->id;
+    }
+  };
+  
+  /* }}} */
+
+  /* {{{ Time */
+
+  template <typename Ntk, typename Opt>
+  seconds Scheduler<Ntk, Opt>::GetRemainingTime() const {
+    if(nTimeout == 0) {
+      return 0;
+    }
+    time_point current = GetCurrentTime();
+    seconds nRemainingTime = nTimeout - DurationInSeconds(start, current);
+    if(nRemainingTime == 0) { // avoid glitch
+      return -1;
+    }
+    return nRemainingTime;
+  }
+
+  /* }}} */
+
+  /* {{{ Abc */
+
+  template <typename Ntk, typename Opt>
+  inline void Scheduler<Ntk, Opt>::CallAbc(Ntk *pNtk_, std::string Command) {
+#ifdef ABC_USE_PTHREADS
+    if(fMultiThreading) {
+      {
+        std::unique_lock<std::mutex> l(mutexAbc);
+        Abc9Execute(pNtk_, Command);
+      }
+      return;
+    }
+#endif
+    Abc9Execute(pNtk_, Command);
+  }
+
+  /* }}} */
+  
+  /* {{{ Run jobs */
+
+  template <typename Ntk, typename Opt>
+  void Scheduler<Ntk, Opt>::RunJob(Opt &opt, Job const *pJob) {
+    opt.UpdateNetwork(pJob->pNtk);
+    // start flow
+    switch(nFlow) {
+    case 0:
+      opt.ResetSeed(pJob->iSeed);
+      opt.Run(GetRemainingTime());
+      break;
+    case 1: { // transtoch
+      std::mt19937 rng(pJob->iSeed);
+      double dCost = CostFunction(pJob->pNtk);
+      double dBestCost = dCost;
+      Ntk best(*(pJob->pNtk));
+      if(nVerbose) {
+        std::cout << "start: cost = " << dCost << std::endl;
+      }
+      for(int i = 0; i < 10; i++) {
+        if(GetRemainingTime() < 0) {
+          break;
+        }
+        if(i != 0) {
+          CallAbc(pJob->pNtk, "&if -K 6; &mfs; &st");
+          dCost = CostFunction(pJob->pNtk);
+          opt.UpdateNetwork(pJob->pNtk, true);
+          if(nVerbose) {
+            std::cout << "hop " << std::setw(3) << i << ": cost = " << dCost << std::endl;
+          }
+        }
+        for(int j = 0; true; j++) {
+          if(GetRemainingTime() < 0) {
+            break;
+          }
+          opt.Randomize(rng());
+          opt.Run(GetRemainingTime());
+          CallAbc(pJob->pNtk, "&dc2");
+          double dNewCost = CostFunction(pJob->pNtk);
+          if(nVerbose) {
+            std::cout << "\tite " << std::setw(3) << j << ": cost = " << dNewCost << std::endl;
+          }
+          if(dNewCost < dCost) {
+            dCost = dNewCost;
+            opt.UpdateNetwork(pJob->pNtk, true);
+          } else {
+            break;
+          }
+        }
+        if(dCost < dBestCost) {
+          dBestCost = dCost;
+          best = *(pJob->pNtk);
+          i = 0;
+        }
+      }
+      *(pJob->pNtk) = best;
+      if(nVerbose) {
+        std::cout << "end: cost = " << dBestCost << std::endl;
+      }
+      break;
+    }
+    case 2: { // deep
+      std::mt19937 rng(pJob->iSeed);
+      int n = 0;
+      double dCost = CostFunction(pJob->pNtk);
+      Ntk best(*(pJob->pNtk));
+      if(nVerbose) {
+        std::cout << "start: cost = " << dCost << std::endl;
+      }
+      for(int i = 0; i < 1000000; i++) {
+        if(GetRemainingTime() < 0) {
+          break;
+        }
+        // deepsyn
+        int fUseTwo = 0;
+        std::string pCompress2rs = "balance -l; resub -K 6 -l; rewrite -l; resub -K 6 -N 2 -l; refactor -l; resub -K 8 -l; balance -l; resub -K 8 -N 2 -l; rewrite -l; resub -K 10 -l; rewrite -z -l; resub -K 10 -N 2 -l; balance -l; resub -K 12 -l; refactor -z -l; resub -K 12 -N 2 -l; rewrite -z -l; balance -l";
+        unsigned Rand = rng();
+        int fDch = Rand & 1;
+        //int fCom = (Rand >> 1) & 3;
+        int fCom = (Rand >> 1) & 1;
+        int fFx  = (Rand >> 2) & 1;
+        int KLut = fUseTwo ? 2 + (i % 5) : 3 + (i % 4);
+        std::string pComp;
+        if ( fCom == 3 )
+          pComp = "; &put; " + pCompress2rs + "; " + pCompress2rs + "; " + pCompress2rs + "; &get";
+        else if ( fCom == 2 )
+          pComp = "; &put; " + pCompress2rs + "; " + pCompress2rs + "; &get";
+        else if ( fCom == 1 )
+          pComp = "; &put; " + pCompress2rs + "; &get";
+        else if ( fCom == 0 )
+          pComp = "; &dc2";
+        std::string Command = "&dch";
+        if(fDch)
+          Command += " -f";
+        Command += "; &if -a -K " + std::to_string(KLut) + "; &mfs -e -W 20 -L 20";
+        if(fFx)
+          Command += "; &fx; &st";
+        Command += pComp;
+        CallAbc(pJob->pNtk, Command);
+        if(nVerbose) {
+          std::cout << "ite " << std::setw(6) << i << ": cost = " << CostFunction(pJob->pNtk) << std::endl;
+        }
+        // rrr
+        for(int j = 0; j < n; j++) {
+          if(GetRemainingTime() < 0) {
+            break;
+          }
+          opt.UpdateNetwork(pJob->pNtk, true);
+          opt.Randomize(rng());
+          opt.Run(GetRemainingTime());
+          if(rng() & 1) {
+            CallAbc(pJob->pNtk, "&dc2");
+          } else {
+            CallAbc(pJob->pNtk, "&put; " + pCompress2rs + "; &get");
+          }
+          if(nVerbose) {
+            std::cout << "\trrr " << std::setw(6) << j << ": cost = " << CostFunction(pJob->pNtk) << std::endl;
+          }
+        }
+        // eval
+        double dNewCost = CostFunction(pJob->pNtk);
+        if(dNewCost < dCost) {
+          dCost = dNewCost;
+          best = *(pJob->pNtk);
+        } else {
+          n++;
+        }
+      }
+      *(pJob->pNtk) = best;
+      if(nVerbose) {
+        std::cout << "end: cost = " << dCost << std::endl;
+      }
+      break;
+    }
+    default:
+      assert(0);
+    }
+  }
+
+  /* }}} */
+
+  /* {{{ Manage jobs */
+
+  template <typename Ntk, typename Opt>
+  void Scheduler<Ntk, Opt>::CreateJob(Ntk *pNtk_, int iSeed_) {
+    Job *pJob = new Job(nJobs++, pNtk_, iSeed_);
+#ifdef ABC_USE_PTHREADS
+    if(fMultiThreading) {
+      {
+        std::unique_lock<std::mutex> l(mutexPendingJobs);
+        qPendingJobs.push(pJob);
+        condPendingJobs.notify_one();
+      }
+      return;
+    }
+#endif
+    qPendingJobs.push(pJob);
+  }
+  
+  template <typename Ntk, typename Opt>
+  void Scheduler<Ntk, Opt>::OnJobEnd(std::function<void(Job *pJob)> const &func) {
+#ifdef ABC_USE_PTHREADS
+    if(fMultiThreading) {
+      Job *pJob = NULL;
+      {
+        std::unique_lock<std::mutex> l(mutexFinishedJobs);
+        while(qFinishedJobs.empty() || (fDeterministic && qFinishedJobs.top()->id != nFinishedJobs)) {
+          condFinishedJobs.wait(l);
+        }
+        pJob = qFinishedJobs.top();
+        qFinishedJobs.pop();
+      }
+      assert(pJob != NULL);
+      func(pJob);
+      delete pJob;
+      nFinishedJobs++;
+      return;
+    }
+#endif
+    // if single thread
+    assert(!qPendingJobs.empty());
+    Job *pJob = qPendingJobs.front();
+    qPendingJobs.pop();
+    RunJob(*pOpt, pJob);
+    func(pJob);
+    delete pJob;
+    nFinishedJobs++;
+  }
+  
+  /* }}} */
+
+  /* {{{ Thread */
+
+#ifdef ABC_USE_PTHREADS
+  template <typename Ntk, typename Opt>
+  void Scheduler<Ntk, Opt>::Thread(Parameter const *pPar) {
+    Opt opt(pPar, CostFunction);
+    while(true) {
+      Job *pJob = NULL;
+      {
+        std::unique_lock<std::mutex> l(mutexPendingJobs);
+        while(!fTerminate && qPendingJobs.empty()) {
+          condPendingJobs.wait(l);
+        }
+        if(fTerminate) {
+          assert(qPendingJobs.empty());
+          return;
+        }
+        pJob = qPendingJobs.front();
+        qPendingJobs.pop();
+      }
+      assert(pJob != NULL);
+      RunJob(opt, pJob);
+      {
+        std::unique_lock<std::mutex> l(mutexFinishedJobs);
+        qFinishedJobs.push(pJob);
+        condFinishedJobs.notify_one();
+      }
+    }
+  }
+#endif
+
+  /* }}} */
+  
+  /* {{{ Constructors */
+  
+  template <typename Ntk, typename Opt>
+  Scheduler<Ntk, Opt>::Scheduler(Ntk *pNtk, Parameter const *pPar) :
+    pNtk(pNtk),
+    nVerbose(pPar->nSchedulerVerbose),
+    iSeed(pPar->iSeed),
+    nFlow(pPar->nSchedulerFlow),
+    nRestarts(pPar->nRestarts),
+    fMultiThreading(pPar->nThreads > 1),
+    fPartitioning(pPar->nWindowSize > 0),
+    fDeterministic(pPar->fDeterministic),
+    nTimeout(pPar->nTimeout),
+    nJobs(0),
+    nFinishedJobs(0),
+    par(pPar),
+    pOpt(NULL) {
+    // prepare cost function
+    CostFunction = [](Ntk *pNtk) {
+      int nTwoInputSize = 0;
+      pNtk->ForEachInt([&](int id) {
+        nTwoInputSize += pNtk->GetNumFanins(id) - 1;
+      });
+      return nTwoInputSize;
+    };
+#ifdef ABC_USE_PTHREADS
+    fTerminate = false;
+    if(fMultiThreading) {
+      vThreads.reserve(pPar->nThreads);
+      for(int i = 0; i < pPar->nThreads; i++) {
+        vThreads.emplace_back(std::bind(&Scheduler::Thread, this, pPar));
+      }
+      return;
+    }
+#endif
+    assert(!fMultiThreading);
+    pOpt = new Opt(pPar, CostFunction);
+  }
+
+  template <typename Ntk, typename Opt>
+  Scheduler<Ntk, Opt>::~Scheduler() {
+#ifdef ABC_USE_PTHREADS
+    if(fMultiThreading) {
+      {
+        std::unique_lock<std::mutex> l(mutexPendingJobs);
+        fTerminate = true;
+        condPendingJobs.notify_all();
+      }
+      for(std::thread &t: vThreads) {
+        t.join();
+      }
+      return;
+    }
+#endif
+    delete pOpt;
+  }
+
+  /* }}} */
+
+  /* {{{ Run */
+  
+  template <typename Ntk, typename Opt>
+  void Scheduler<Ntk, Opt>::Run() {
+    start = GetCurrentTime();
+    if(fPartitioning) {
+      pNtk->Sweep();
+      par.UpdateNetwork(pNtk);
+      while(nJobs < nRestarts) {
+        Ntk *pSubNtk = par.Extract(iSeed + nJobs);
+        if(pSubNtk == NULL) {
+          if(nJobs == nFinishedJobs) {
+            std::cout << "failed to extract a window" << std::endl;
+            break;
+          }
+          while(nFinishedJobs < nJobs) {
+            OnJobEnd([&](Job *pJob) {
+              std::cout << "job " << pJob->id << " finished (size = " << pJob->pNtk->GetNumInts() << ")" << std::endl;
+              par.Insert(pJob->pNtk);
+            });
+          }
+        } else {
+          CreateJob(pSubNtk, iSeed + nJobs);
+          std::cout << "job " << nJobs - 1 << " created (size = " << pSubNtk->GetNumInts() << ")" << std::endl;
+        }
+      }
+      while(nFinishedJobs < nJobs) {
+        OnJobEnd([&](Job *pJob) {
+          std::cout << "job " << pJob->id << " finished (size = " << pJob->pNtk->GetNumInts() << ")" << std::endl;
+          par.Insert(pJob->pNtk);
+        });
+      }
+    } else if(nRestarts > 0) {
+      fDeterministic = false; // it is deterministic anyways
+      double dCost = CostFunction(pNtk);
+      for(int i = 0; i < 1 + nRestarts; i++) {
+        Ntk *pCopy = new Ntk(*pNtk);
+        CreateJob(pCopy, iSeed + i);
+      }
+      for(int i = 0; i < 1 + nRestarts; i++) {
+        OnJobEnd([&](Job *pJob) {
+          double dNewCost = CostFunction(pJob->pNtk);
+          if(nVerbose) {
+            std::cout << "run " << pJob->id << ": cost = " << dNewCost << std::endl;
+          }
+          if(dNewCost < dCost) {
+            dCost = dNewCost;
+            *pNtk = *(pJob->pNtk);
+          }
+          delete pJob->pNtk;
+        });
+      }
+    } else {
+      CreateJob(pNtk, iSeed);
+      OnJobEnd([&](Job *pJob) { (void)pJob; });
+    }
+    time_point end = GetCurrentTime();
+    double elapsed_seconds = Duration(start, end);
+    if(nVerbose) {
+      std::cout << "elapsed: " << std::fixed << std::setprecision(3) << elapsed_seconds << "s" << std::endl;
+    }
+  }
+
+  /* }}} */
+
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrSimulator.h b/src/opt/rrr/rrrSimulator.h
new file mode 100644
index 000000000..8d5c80c87
--- /dev/null
+++ b/src/opt/rrr/rrrSimulator.h
@@ -0,0 +1,806 @@
+#pragma once
+
+#include <algorithm>
+#include <random>
+#include <bitset>
+
+#include "rrrParameter.h"
+#include "rrrUtils.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  template <typename Ntk>
+  class Simulator {
+  private:
+    // aliases
+    using word = unsigned long long;
+    using itr = std::vector<word>::iterator;
+    using citr = std::vector<word>::const_iterator;
+    static constexpr word one = 0xffffffffffffffff;
+
+    // pointer to network
+    Ntk *pNtk;
+    
+    // parameters
+    int nVerbose;
+    int nWords;
+
+    // data
+    int target; // node for which the careset has been computed
+    std::vector<word> vValues;
+    std::vector<word> vValues2; // simulation with an inverter
+    std::vector<word> care; // careset
+    std::vector<word> tmp;
+
+    // partial cex
+    int iPivot;
+    std::vector<word> vAssignedStimuli;
+
+    // updates
+    bool fUpdate;
+    std::set<int> sUpdates;
+
+    // backups
+    std::vector<Simulator> vBackups;
+
+    // statistics
+    int nAdds;
+    int nResets;
+    
+    // vector computations
+    void Clear(int n, itr x) const;
+    void Fill(int n, itr x) const;
+    void Copy(int n, itr dst, citr src, bool c) const;
+    void And(int n, itr dst, citr src0, citr src1, bool c0, bool c1) const;
+    void Xor(int n, itr dst, citr src0, citr src1, bool c) const;
+    bool IsZero(int n, citr x) const;
+    bool IsEq(int n, citr x, citr y) const;
+    void Print(int n, citr x) const;
+
+    // callback
+    void ActionCallback(Action const &action);
+
+    // simulation
+    void SimulateNode(std::vector<word> &v, int id, int to_negate = -1);
+    bool ResimulateNode(std::vector<word> &v, int id, int to_negate = -1);
+    void SimulateOneWordNode(std::vector<word> &v, int id, int offset, int to_negate = -1);
+    void Simulate();
+    void Resimulate();
+    void SimulateOneWord(int offset);
+
+    // generate stimuli
+    void GenerateRandomStimuli();
+
+    // careset computation
+    void ComputeCare(int id);
+
+    // save & load
+    void Save(int slot);
+    void Load(int slot);
+
+  public:
+    // constructors
+    Simulator();
+    Simulator(Parameter const *pPar);
+    ~Simulator();
+    void UpdateNetwork(Ntk *pNtk_, bool fSame);
+
+    // checks
+    bool CheckRedundancy(int id, int idx);
+    bool CheckFeasibility(int id, int fi, bool c);
+
+    // cex
+    void AddCex(std::vector<VarValue> const &vCex);
+  };
+
+
+  /* {{{ Vector computations */
+  
+  template <typename Ntk>
+  inline void Simulator<Ntk>::Clear(int n, itr x) const {
+    std::fill(x, x + n, 0);
+  }
+
+  template <typename Ntk>
+  inline void Simulator<Ntk>::Fill(int n, itr x) const {
+    std::fill(x, x + n, one);
+  }
+  
+  template <typename Ntk>
+  inline void Simulator<Ntk>::Copy(int n, itr dst, citr src, bool c) const {
+    if(!c) {
+      for(int i = 0; i < n; i++, dst++, src++) {
+        *dst = *src;
+      }
+    } else {
+      for(int i = 0; i < n; i++, dst++, src++) {
+        *dst = ~*src;
+      }
+    }
+  }
+  
+  template <typename Ntk>
+  inline void Simulator<Ntk>::And(int n, itr dst, citr src0, citr src1, bool c0, bool c1) const {
+    if(!c0) {
+      if(!c1) {
+        for(int i = 0; i < n; i++, dst++, src0++, src1++) {
+          *dst = *src0 & *src1;
+        }
+      } else {
+        for(int i = 0; i < n; i++, dst++, src0++, src1++) {
+          *dst = *src0 & ~*src1;
+        }
+      }
+    } else {
+      if(!c1) {
+        for(int i = 0; i < n; i++, dst++, src0++, src1++) {
+          *dst = ~*src0 & *src1;
+        }
+      } else {
+        for(int i = 0; i < n; i++, dst++, src0++, src1++) {
+          *dst = ~*src0 & ~*src1;
+        }
+      }
+    }
+  }
+
+  template <typename Ntk>
+  inline void Simulator<Ntk>::Xor(int n, itr dst, citr src0, citr src1, bool c) const {
+    if(!c) {
+      for(int i = 0; i < n; i++, dst++, src0++, src1++) {
+        *dst = *src0 ^ *src1;
+      }
+    } else {
+      for(int i = 0; i < n; i++, dst++, src0++, src1++) {
+        *dst = *src0 ^ ~*src1;
+      }
+    }
+  }
+
+  template <typename Ntk>
+  inline bool Simulator<Ntk>::IsZero(int n, citr x) const {
+    for(int i = 0; i < n; i++, x++) {
+      if(*x) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  template <typename Ntk>
+  inline bool Simulator<Ntk>::IsEq(int n, citr x, citr y) const {
+    for(int i = 0; i < n; i++, x++, y++) {
+      if(*x != *y) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  template <typename Ntk>
+  inline void Simulator<Ntk>::Print(int n, citr x) const {
+    std::cout << std::bitset<64>(*x);
+    x++;
+    for(int i = 1; i < n; i++, x++) {
+      std::cout << std::endl << std::string(10, ' ') << std::bitset<64>(*x);
+    }
+  }
+  
+  /* }}} */
+
+  /* {{{ Callback */
+  
+  template <typename Ntk>
+  void Simulator<Ntk>::ActionCallback(Action const &action) {
+    if(target == -1) {
+      return;
+    }
+    switch(action.type) {
+    case REMOVE_FANIN:
+      if(action.id == target) {
+        fUpdate = true;
+      } else {
+        sUpdates.insert(action.id);
+      }
+      break;
+    case REMOVE_UNUSED:
+      break;
+    case REMOVE_BUFFER:
+    case REMOVE_CONST:
+      if(action.id == target) {
+        if(fUpdate) {
+          for(int fo: action.vFanouts) {
+            sUpdates.insert(fo);
+          }
+          fUpdate = false;
+        }
+        target = -1;
+      } else {
+        if(sUpdates.count(action.id)) {
+          sUpdates.erase(action.id);
+          for(int fo: action.vFanouts) {
+            sUpdates.insert(fo);
+          }
+        }
+      }
+      break;
+    case ADD_FANIN:
+      if(action.id == target) {
+        fUpdate = true;
+      } else {
+        sUpdates.insert(action.id);
+      }
+      break;
+    case TRIVIAL_COLLAPSE:
+      break;
+    case TRIVIAL_DECOMPOSE:
+      vValues.resize(nWords * pNtk->GetNumNodes());
+      SimulateNode(vValues, action.fi);
+      break;
+    case SORT_FANINS:
+      break;
+    case SAVE:
+      Save(action.idx);
+      break;
+    case LOAD:
+      Load(action.idx);
+      break;
+    case POP_BACK:
+      // Do nothing: it may be good to keep the word vector allocated
+      break;
+    default:
+      assert(0);
+    }
+  }
+  
+  /* }}} */
+
+  /* {{{ Simulation */
+  
+  template <typename Ntk>
+  void Simulator<Ntk>::SimulateNode(std::vector<word> &v, int id, int to_negate) {
+    itr x = v.end();
+    itr y = v.begin() + id * nWords;
+    bool cx = false;
+    switch(pNtk->GetNodeType(id)) {
+    case AND:
+      pNtk->ForEachFanin(id, [&](int fi, bool c) {
+        if(x == v.end()) {
+          x = v.begin() + fi * nWords;
+          cx = c ^ (fi == to_negate);
+        } else {
+          And(nWords, y, x, v.begin() + fi * nWords, cx, c ^ (fi == to_negate));
+          x = y;
+          cx = false;
+        }
+      });
+      if(x == v.end()) {
+        Fill(nWords, y);
+      }
+      break;
+    default:
+      assert(0);
+    }
+  }
+      
+  template <typename Ntk>
+  bool Simulator<Ntk>::ResimulateNode(std::vector<word> &v, int id, int to_negate) {
+    itr x = v.end();
+    bool cx = false;
+    switch(pNtk->GetNodeType(id)) {
+    case AND:
+      pNtk->ForEachFanin(id, [&](int fi, bool c) {
+        if(x == v.end()) {
+          x = v.begin() + fi * nWords;
+          cx = c ^ (fi == to_negate);
+        } else {
+          And(nWords, tmp.begin(), x, v.begin() + fi * nWords, cx, c ^ (fi == to_negate));
+          x = tmp.begin();
+          cx = false;
+        }
+      });
+      if(x == v.end()) {
+        Fill(nWords, tmp.begin());
+      }
+      break;
+    default:
+      assert(0);
+    }
+    itr y = v.begin() + id * nWords;
+    if(IsEq(nWords, y, tmp.begin())) {
+      return false;
+    }
+    Copy(nWords, y, tmp.begin(), false);
+    return true;
+  }
+  
+  template <typename Ntk>
+  void Simulator<Ntk>::SimulateOneWordNode(std::vector<word> &v, int id, int offset, int to_negate) {
+    itr x = v.end();
+    itr y = v.begin() + id * nWords + offset;
+    bool cx = false;
+    switch(pNtk->GetNodeType(id)) {
+    case AND:
+      pNtk->ForEachFanin(id, [&](int fi, bool c) {
+        if(x == v.end()) {
+          x = v.begin() + fi * nWords + offset;
+          cx = c ^ (fi == to_negate);
+        } else {
+          And(1, y, x, v.begin() + fi * nWords + offset, cx, c ^ (fi == to_negate));
+          x = y;
+          cx = false;
+        }
+      });
+      if(x == v.end()) {
+        Fill(1, y);
+      }
+      break;
+    default:
+      assert(0);
+    }
+  }
+  
+  template <typename Ntk>
+  void Simulator<Ntk>::Simulate() {
+    if(nVerbose) {
+      std::cout << "simulating" << std::endl;
+    }
+    pNtk->ForEachInt([&](int id) {
+      SimulateNode(vValues, id);
+      if(nVerbose) {
+        std::cout << "node " << std::setw(3) << id << ": ";
+        Print(nWords, vValues.begin() + id * nWords);
+        std::cout << std::endl;
+      }
+    });
+  }
+  
+  template <typename Ntk>
+  void Simulator<Ntk>::Resimulate() {
+    if(nVerbose) {
+      std::cout << "resimulating" << std::endl;
+    }
+    pNtk->ForEachTfosUpdate(sUpdates, false, [&](int fo) {
+      bool fUpdated = ResimulateNode(vValues, fo);
+      if(nVerbose) {
+        std::cout << "node " << std::setw(3) << fo << ": ";
+        Print(nWords, vValues.begin() + fo * nWords);
+        std::cout << std::endl;
+      }
+      return fUpdated;
+    });
+    /* alternative version that updates entire TFO
+    pNtk->ForEachTfos(sUpdates, false, [&](int fo) {
+      SimulateNode(vValues, fo);
+      if(nVerbose) {
+        std::cout << "node " << std::setw(3) << fo << ": ";
+        Print(nWords, vValues.begin() + fo * nWords);
+        std::cout << std::endl;
+      }
+    });
+    */
+  }
+
+  template <typename Ntk>
+  void Simulator<Ntk>::SimulateOneWord(int offset) {
+    if(nVerbose) {
+      std::cout << "simulating word " << offset << std::endl;
+    }
+    pNtk->ForEachInt([&](int id) {
+      SimulateOneWordNode(vValues, id, offset);
+      if(nVerbose) {
+        std::cout << "node " << std::setw(3) << id << ": ";
+        Print(1, vValues.begin() + id * nWords + offset);
+        std::cout << std::endl;
+      }
+    });
+  }
+
+  /* }}} */
+
+  /* {{{ Generate stimuli */
+
+  template <typename Ntk>
+  void Simulator<Ntk>::GenerateRandomStimuli() {
+    if(nVerbose) {
+      std::cout << "generating random stimuli" << std::endl;
+    }
+    std::mt19937_64 rng;
+    pNtk->ForEachPi([&](int id) {
+      for(int i = 0; i < nWords; i++) {
+        vValues[id * nWords + i] = rng();
+      }
+      if(nVerbose) {
+        std::cout << "node " << std::setw(3) << id << ": ";
+        Print(nWords, vValues.begin() + id * nWords);
+        std::cout << std::endl;
+      }
+    });
+    Clear(nWords * pNtk->GetNumPis(), vAssignedStimuli.begin());
+  }
+
+  /* }}} */
+
+  /* {{{ Careset computation */
+  
+  template <typename Ntk>
+  void Simulator<Ntk>::ComputeCare(int id) {
+    if(sUpdates.empty() && id == target) {
+      return;
+    }
+    if(fUpdate) {
+      sUpdates.insert(target);
+      fUpdate = false;
+    }
+    if(!sUpdates.empty()) {
+      Resimulate();
+      sUpdates.clear();
+    }
+    target = id;
+    if(nVerbose) {
+      std::cout << "computing careset of " << target << std::endl;
+    }
+    if(pNtk->IsPoDriver(target)) {
+      Fill(nWords, care.begin());
+      if(nVerbose) {
+        std::cout << "care " << std::setw(3) << target << ": ";
+        Print(nWords, care.begin());
+        std::cout << std::endl;
+      }
+      return;
+    }
+    vValues2 = vValues;
+    pNtk->ForEachTfo(target, false, [&](int id) {
+      SimulateNode(vValues2, id, target);
+      if(nVerbose) {
+        std::cout << "node " << std::setw(3) << id << ": ";
+        Print(nWords, vValues2.begin() + id * nWords);
+        std::cout << std::endl;
+      }
+    });
+    /* alternative version that updates only affected TFO
+    pNtk->ForEachTfoUpdate(target, false, [&](int id) {
+      bool fUpdated = ResimulateNode(vValues2, id, target);
+      if(nVerbose) {
+        std::cout << "node " << std::setw(3) << id << ": ";
+        Print(nWords, vValues2.begin() + id * nWords);
+        std::cout << std::endl;
+      }
+      return fUpdated;
+    });
+    */
+    Clear(nWords, care.begin());
+    pNtk->ForEachPoDriver([&](int fi) {
+      assert(fi != target);
+      for(int i = 0; i < nWords; i++) {
+        care[i] = care[i] | (vValues[fi * nWords + i] ^ vValues2[fi * nWords + i]);
+      }
+    });
+    if(nVerbose) {
+      std::cout << "care " << std::setw(3) << target << ": ";
+      Print(nWords, care.begin());
+      std::cout << std::endl;
+    }
+  }
+  
+  /* }}} */
+
+  /* {{{ Save & load */
+
+  template <typename Ntk>
+  void Simulator<Ntk>::Save(int slot) {
+    assert(slot >= 0);
+    assert(!check_int_max(slot));
+    if(slot >= int_size(vBackups)) {
+      vBackups.resize(slot + 1);
+    }
+    vBackups[slot].nWords = nWords;
+    if(sUpdates.empty()) {
+      vBackups[slot].target = target;
+      vBackups[slot].care = care;
+    } else {
+      vBackups[slot].target = -1;
+      vBackups[slot].care = care;
+    }
+    if(fUpdate) {
+      sUpdates.insert(target);
+      fUpdate = false;
+    }
+    if(!sUpdates.empty()) {
+      Resimulate();
+      sUpdates.clear();
+    }
+    vBackups[slot].vValues = vValues;
+    vBackups[slot].iPivot = iPivot;
+    vBackups[slot].vAssignedStimuli = vAssignedStimuli;
+    target = vBackups[slot].target; // assigned to -1 when careset needs updating
+  }
+
+  template <typename Ntk>
+  void Simulator<Ntk>::Load(int slot) {
+    assert(slot >= 0);
+    assert(slot < int_size(vBackups));
+    nWords  = vBackups[slot].nWords;
+    target  = vBackups[slot].target;
+    vValues = vBackups[slot].vValues;
+    care    = vBackups[slot].care;
+    iPivot  = vBackups[slot].iPivot;
+    vAssignedStimuli = vBackups[slot].vAssignedStimuli;
+    fUpdate = false;
+    sUpdates.clear();
+    tmp.resize(nWords);
+  }
+  
+  /* }}} */
+  
+  /* {{{ Constructors */
+  
+  template <typename Ntk>
+  Simulator<Ntk>::Simulator() :
+    pNtk(NULL),
+    nVerbose(0),
+    nWords(0),
+    target(-1),
+    iPivot(0),
+    fUpdate(false),
+    nAdds(0),
+    nResets(0) {
+  }
+  
+  template <typename Ntk>
+  Simulator<Ntk>::Simulator(Parameter const *pPar) :
+    pNtk(NULL),
+    nVerbose(pPar->nSimulatorVerbose),
+    nWords(pPar->nWords),
+    target(-1),
+    iPivot(0),
+    fUpdate(false),
+    nAdds(0),
+    nResets(0) {
+    care.resize(nWords);
+    tmp.resize(nWords);
+  }
+
+  template <typename Ntk>
+  Simulator<Ntk>::~Simulator() {
+    if(pNtk) {
+      std::cout << "simulator stats: added CEXs = " << nAdds << ", resets = " << nResets << std::endl;
+    }
+  }
+
+  template <typename Ntk>
+  void Simulator<Ntk>::UpdateNetwork(Ntk *pNtk_, bool fSame) {
+    pNtk = pNtk_;
+    pNtk->AddCallback(std::bind(&Simulator<Ntk>::ActionCallback, this, std::placeholders::_1));
+    vValues.resize(nWords * pNtk->GetNumNodes());
+    target = -1;
+    iPivot = 0;
+    fUpdate = false;
+    sUpdates.clear();
+    if(!fSame) { // reset stimuli if network function changed
+      vAssignedStimuli.clear();
+      vAssignedStimuli.resize(nWords * pNtk->GetNumPis());
+      GenerateRandomStimuli();
+    }
+    Simulate();
+  }
+
+  /* }}} */
+
+  /* {{{ Checks */
+  
+  template <typename Ntk>
+  bool Simulator<Ntk>::CheckRedundancy(int id, int idx) {
+    ComputeCare(id);
+    switch(pNtk->GetNodeType(id)) {
+    case AND: {
+      itr x = vValues.end();
+      bool cx = false;
+      pNtk->ForEachFaninIdx(id, [&](int idx2, int fi, bool c) {
+        if(idx == idx2) {
+          return;
+        }
+        if(x == vValues.end()) {
+          x = vValues.begin() + fi * nWords;
+          cx = c;
+        } else {
+          And(nWords, tmp.begin(), x, vValues.begin() + fi * nWords, cx, c);
+          x = tmp.begin();
+          cx = false;
+        }
+      });
+      if(x == vValues.end()) {
+        x = care.begin();
+      } else {
+        And(nWords, tmp.begin(), x, care.begin(), cx, false);
+        x = tmp.begin();
+      }
+      int fi = pNtk->GetFanin(id, idx);
+      bool c = pNtk->GetCompl(id, idx);
+      And(nWords, tmp.begin(), x, vValues.begin() + fi * nWords, false, !c);
+      return IsZero(nWords, tmp.begin());
+    }
+    default:
+      assert(0);
+    }
+    return false;
+  }
+
+  template <typename Ntk>
+  bool Simulator<Ntk>::CheckFeasibility(int id, int fi, bool c) {
+    ComputeCare(id);
+    switch(pNtk->GetNodeType(id)) {
+    case AND: {
+      itr x = vValues.end();
+      bool cx = false;
+      pNtk->ForEachFanin(id, [&](int fi, bool c) {
+        if(x == vValues.end()) {
+          x = vValues.begin() + fi * nWords;
+          cx = c;
+        } else {
+          And(nWords, tmp.begin(), x, vValues.begin() + fi * nWords, cx, c);
+          x = tmp.begin();
+          cx = false;
+        }
+      });
+      if(x == vValues.end()) {
+        x = care.begin();
+      } else {
+        And(nWords, tmp.begin(), x, care.begin(), cx, false);
+        x = tmp.begin();
+      }
+      And(nWords, tmp.begin(), x, vValues.begin() + fi * nWords, false, !c);
+      return IsZero(nWords, tmp.begin());
+    }
+    default:
+      assert(0);
+    }
+    return false;
+  }
+
+  /* }}} */
+
+  /* {{{ Cex */
+
+  template <typename Ntk>
+  void Simulator<Ntk>::AddCex(std::vector<VarValue> const &vCex) {
+    if(nVerbose) {
+      std::cout << "cex: ";
+      for(VarValue c: vCex) {
+        std::cout << GetVarValueChar(c);
+      }
+      std::cout << std::endl;
+    }
+    // record care pi indices
+    assert(int_size(vCex) == pNtk->GetNumPis());
+    std::vector<int> vCarePiIdxs;
+    for(int idx = 0; idx < pNtk->GetNumPis(); idx++) {
+      switch(vCex[idx]) {
+      case TRUE:
+        vCarePiIdxs.push_back(idx);
+        break;
+      case FALSE:
+        vCarePiIdxs.push_back(idx);
+        break;
+      default:
+        break;
+      }
+    }
+    assert(!vCarePiIdxs.empty());
+    // find compatible word
+    int iWord = 0;
+    std::vector<word> vCompatibleBits(1);
+    itr it = vCompatibleBits.begin();
+    for(; iWord < nWords; iWord++) {
+      Fill(1, it);
+      for(int idx: vCarePiIdxs) {
+        int id = pNtk->GetPi(idx);
+        bool c;
+        if(vCex[idx] == TRUE) {
+          c = false;
+        } else {
+          assert(vCex[idx] == FALSE);
+          c = true;
+        }
+        itr x = vValues.begin() + id * nWords + iWord;
+        itr y = vAssignedStimuli.begin() + idx * nWords + iWord;
+        And(1, tmp.begin(), x, y, !c, false);
+        And(1, it, it, tmp.begin(), false, true);
+        if(IsZero(1, it)) {
+          break;
+        }
+      }
+      if(!IsZero(1, it)) {
+        break;
+      }
+    }
+    // find compatible bit
+    int iBit;
+    if(iWord < nWords) {
+      assert(!IsZero(1, it));
+      iBit = 0;
+      while(!((*it >> iBit) & 1)) {
+        iBit++;
+      }
+      if(nVerbose) {
+        std::cout << "fusing into stimulus word " << iWord << " bit " << iBit << std::endl;
+      }
+    } else {
+      // no bits are compatible, so reset at pivot
+      iWord = iPivot / 64;
+      iBit = iPivot % 64;
+      if(nVerbose) {
+        std::cout << "resetting stimulus word " << iWord << " bit " << iBit << std::endl;
+      }
+      word mask = 1ull << iBit;
+      for(int idx = 0; idx < pNtk->GetNumPis(); idx++) {
+        vAssignedStimuli[idx * nWords + iWord] &= ~mask;
+      }
+      iPivot++;
+      if(iPivot == 64 * nWords) {
+        iPivot = 0;
+      }
+      nResets++;
+    }
+    // update stimulus
+    for(int idx: vCarePiIdxs) {
+      int id = pNtk->GetPi(idx);
+      word mask = 1ull << iBit;
+      if(vCex[idx] == TRUE) {
+        vValues[id * nWords + iWord] |= mask;
+      } else {
+        assert(vCex[idx] == FALSE);
+        vValues[id * nWords + iWord] &= ~mask;
+      }
+      vAssignedStimuli[idx * nWords + iWord] |= mask;
+      if(nVerbose) {
+        std::cout << "node " << std::setw(3) << id << ": ";
+        Print(1, vValues.begin() + id * nWords + iWord);
+        std::cout << std::endl;
+        std::cout << "asgn " << std::setw(3) << id << ": ";
+        Print(1, vAssignedStimuli.begin() + idx * nWords + iWord);
+        std::cout << std::endl;
+      }
+    }
+    // simulate
+    SimulateOneWord(iWord);
+    // recompute care with new stimulus
+    if(target != -1 && !pNtk->IsPoDriver(target)) {
+      if(nVerbose) {
+        std::cout << "recomputing careset of " << target << std::endl;
+      }
+      pNtk->ForEachPi([&](int id) {
+        vValues2[id * nWords + iWord] = vValues[id * nWords + iWord];
+      });
+      pNtk->ForEachInt([&](int id) {
+        vValues2[id * nWords + iWord] = vValues[id * nWords + iWord];
+      });
+      pNtk->ForEachTfo(target, false, [&](int id) {
+        SimulateOneWordNode(vValues2, id, iWord, target);
+        if(nVerbose) {
+          std::cout << "node " << std::setw(3) << id << ": ";
+          Print(1, vValues2.begin() + id * nWords + iWord);
+          std::cout << std::endl;
+        }
+      });
+      Clear(1, care.begin() + iWord);
+      pNtk->ForEachPoDriver([&](int fi) {
+        assert(fi != target);
+        care[iWord] = care[iWord] | (vValues[fi * nWords + iWord] ^ vValues2[fi * nWords + iWord]);
+      });
+      if(nVerbose) {
+        std::cout << "care " << std::setw(3) << target << ": ";
+        Print(1, care.begin() + iWord);
+        std::cout << std::endl;
+      }
+    }
+    nAdds++;
+  }
+  
+  /* }}} */
+  
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrTypes.h b/src/opt/rrr/rrrTypes.h
new file mode 100644
index 000000000..858b65a5f
--- /dev/null
+++ b/src/opt/rrr/rrrTypes.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include <vector>
+#include <chrono>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  enum NodeType {
+    PI,
+    PO,
+    AND,
+    XOR,
+    LUT
+  };
+
+  enum SatResult {
+    SAT,
+    UNSAT,
+    UNDET
+  };
+
+  enum VarValue: char {
+    UNDEF,
+    TRUE,
+    FALSE,
+    TEMP_TRUE,
+    TEMP_FALSE
+  };
+
+  enum ActionType {
+    NONE,
+    REMOVE_FANIN,
+    REMOVE_UNUSED,
+    REMOVE_BUFFER,
+    REMOVE_CONST,
+    ADD_FANIN,
+    TRIVIAL_COLLAPSE,
+    TRIVIAL_DECOMPOSE,
+    SORT_FANINS,
+    SAVE,
+    LOAD,
+    POP_BACK,
+    INSERT
+  };
+
+  struct Action {
+    ActionType type = NONE;
+    int id = -1;
+    int idx = -1;
+    int fi = -1;
+    bool c = false;
+    std::vector<int> vFanins;
+    std::vector<int> vIndices;
+    std::vector<int> vFanouts;
+  };
+
+  using seconds = int64_t;
+  using clock_type = std::chrono::steady_clock;
+  using time_point = std::chrono::time_point<clock_type>;
+
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/rrr/rrrUtils.h b/src/opt/rrr/rrrUtils.h
new file mode 100644
index 000000000..f41593d52
--- /dev/null
+++ b/src/opt/rrr/rrrUtils.h
@@ -0,0 +1,215 @@
+#pragma once
+
+#include <iostream>
+#include <iomanip>
+#include <vector>
+#include <set>
+#include <string>
+#include <functional>
+#include <limits>
+#include <type_traits>
+#include <cassert>
+
+#include "rrrTypes.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace rrr {
+
+  /* {{{ Invocable */
+
+#if defined(__cpp_lib_is_invocable)
+  template <typename Fn, typename... Args>
+  using is_invokable = std::is_invocable<Fn, Args...>;
+#else
+  template <typename Fn, typename... Args>
+  struct is_invokable: std::is_constructible<std::function<void(Args...)>, std::reference_wrapper<typename std::remove_reference<Fn>::type>> {};
+#endif
+
+  /* }}} */
+
+  /* {{{ Int size */
+  
+  template <template <typename...> typename Container, typename ... Ts>
+  static inline int int_size(Container<Ts...> const &c) {
+    assert(c.size() <= (typename Container<Ts...>::size_type)std::numeric_limits<int>::max());
+    return c.size();
+  }
+
+  template <template <typename...> typename Container, typename ... Ts>
+  static inline bool check_int_size(Container<Ts...> const &c) {
+    return c.size() <= (typename Container<Ts...>::size_type)std::numeric_limits<int>::max();
+  }
+
+  static inline bool check_int_max(int i) {
+    return i == std::numeric_limits<int>::max();
+  }
+  
+  /* }}} */
+  
+  /* {{{ Print helpers */
+
+  template <typename T>
+  std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
+    std::string delim;
+    os << "[";
+    for(T const &e: v) {
+      os << delim << e;
+      delim = ", ";
+    }
+    os << "]";
+    return os;
+  }
+  
+  template <typename T>
+  std::ostream& operator<<(std::ostream& os, const std::set<T>& s) {
+    std::string delim;
+    os << "{";
+    for(T const &e: s) {
+      os << delim << e;
+      delim = ", ";
+    }
+    os << "}";
+    return os;
+  }
+
+  void PrintComplementedEdges(std::function<void(std::function<void(int, bool)> const &)> const &ForEachEdge) {
+    std::string delim;
+    std::cout << "[";
+    ForEachEdge([&] (int id, bool c) {
+      std::cout << delim << (c? "!": "") << id;
+      delim = ", ";
+    });
+    std::cout << "]";
+  }
+
+  /* }}} */
+  
+  /* {{{ VarValue functions */
+  
+  static inline VarValue DecideVarValue(VarValue x) {
+    switch(x) {
+    case UNDEF:
+      assert(0);
+    case TRUE:
+      return TRUE;
+    case FALSE:
+      return FALSE;
+    case TEMP_TRUE:
+      return TRUE;
+    case TEMP_FALSE:
+      return FALSE;
+    default:
+      assert(0);
+    }
+  }
+
+  static inline char GetVarValueChar(VarValue x) {
+    switch(x) {
+    case UNDEF:
+      return 'x';
+    case TRUE:
+      return '1';
+    case FALSE:
+      return '0';
+    case TEMP_TRUE:
+      return 't';
+    case TEMP_FALSE:
+      return 'f';
+    default:
+      assert(0);
+    }
+  }
+
+  /* }}} */
+
+  /* {{{ Action functions */
+
+  static inline void PrintAction(Action action) {
+    switch(action.type) {
+    case REMOVE_FANIN:
+      std::cout << "remove fanin";
+      break;
+    case REMOVE_UNUSED:
+      std::cout << "remove unused";
+      break;
+    case REMOVE_BUFFER:
+      std::cout << "remove buffer";
+      break;
+    case REMOVE_CONST:
+      std::cout << "remove const";
+      break;
+    case ADD_FANIN:
+      std::cout << "add fanin";
+      break;
+    case TRIVIAL_COLLAPSE:
+      std::cout << "trivial collapse";
+      break;
+    case TRIVIAL_DECOMPOSE:
+      std::cout << "trivial decompose";
+      break;
+    case SORT_FANINS:
+      std::cout << "sort fanins";
+      break;
+    case SAVE:
+      std::cout << "save";
+      break;
+    case LOAD:
+      std::cout << "load";
+      break;
+    case POP_BACK:
+      std::cout << "pop back";
+      break;
+    case INSERT:
+      std::cout << "insert";
+      break;
+    default:
+      assert(0);
+    }
+    std::cout << ":";
+    if(action.id != -1) {
+      std::cout << " node " << action.id;
+    }
+    if(action.fi != -1) {
+      std::cout << " fanin " << (action.c? "!": "") << action.fi;
+    }
+    if(action.idx != -1) {
+      std::cout << " index " << action.idx;
+    }
+    std::cout << std::endl;
+    if(!action.vFanins.empty()) {
+      std::cout << "\t" << "fanins: " << action.vFanins << std::endl;
+    }
+    if(!action.vIndices.empty()) {
+      std::cout << "\t" << "indices: " << action.vIndices << std::endl;
+    }
+    if(!action.vFanouts.empty()) {
+      std::cout << "\t" << "fanouts: " << action.vFanouts << std::endl;
+    }
+  }
+
+  /* }}} */
+  
+  /* {{{ Time functions */
+  
+  static inline time_point GetCurrentTime() {
+    return clock_type::now();
+  }
+
+  static inline seconds DurationInSeconds(time_point start, time_point end) {
+    seconds t = (std::chrono::duration_cast<std::chrono::seconds>(end - start)).count();
+    assert(t >= 0);
+    return t;
+  }
+
+  static inline double Duration(time_point start, time_point end) {
+    double t = (std::chrono::duration<double>(end - start)).count();
+    assert(t >= 0);
+    return t;
+  }
+
+  /* }}} */
+
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/opt/sfm/sfmCnf.c b/src/opt/sfm/sfmCnf.c
index e3af7e011..7c917fa7e 100644
--- a/src/opt/sfm/sfmCnf.c
+++ b/src/opt/sfm/sfmCnf.c
@@ -110,6 +110,9 @@ int Sfm_TruthToCnf( word Truth, word * pTruth, int nVars, Vec_Int_t * vCover, Ve
     {
         int i, k, c, RetValue, Literal, Cube, nCubes = 0;
         assert( nVars > 0 );
+
+        Abc_TtFlipVar5( &Truth, nVars );
+        Abc_TtFlipVar5( pTruth, nVars );
         for ( c = 0; c < 2; c ++ )
         {
             if ( nVars <= 6 )
@@ -145,6 +148,8 @@ int Sfm_TruthToCnf( word Truth, word * pTruth, int nVars, Vec_Int_t * vCover, Ve
                 Vec_StrPush( vCnf, (char)-1 );
             }
         }
+        Abc_TtFlipVar5( pTruth, nVars );
+
         return nCubes;
     }
 }
diff --git a/src/opt/sfm/sfmCore.c b/src/opt/sfm/sfmCore.c
index 87c11e615..a57c5623a 100644
--- a/src/opt/sfm/sfmCore.c
+++ b/src/opt/sfm/sfmCore.c
@@ -167,7 +167,7 @@ p->timeSat += Abc_Clock() - clk;
         {
             printf( "%3d: %3d ", p->nCexes, iVar );
             Vec_WrdForEachEntry( p->vDivCexes, uSign, i )
-                printf( "%d", Abc_InfoHasBit((unsigned *)&uSign, p->nCexes-1) );
+                printf( "%d", Abc_TtGetBit(&uSign, p->nCexes-1) );
             printf( "\n" );
         }
         // find the next divisor to try
diff --git a/src/opt/sfm/sfmSat.c b/src/opt/sfm/sfmSat.c
index c83f86883..5d670f81d 100644
--- a/src/opt/sfm/sfmSat.c
+++ b/src/opt/sfm/sfmSat.c
@@ -213,8 +213,8 @@ word Sfm_ComputeInterpolant( Sfm_Ntk_t * p )
         if ( Vec_IntEntry(p->vValues, i) ^ sat_solver_var_value(p->pSat, iVar) ) // insert 1
         {
             pSign = Vec_WrdEntryP( p->vDivCexes, i );
-            assert( !Abc_InfoHasBit( (unsigned *)pSign, p->nCexes) );
-            Abc_InfoXorBit( (unsigned *)pSign, p->nCexes );
+            assert( !Abc_TtGetBit( pSign, p->nCexes) );
+            Abc_TtXorBit( pSign, p->nCexes );
         }
     p->nCexes++;
     return SFM_SAT_SAT;
@@ -284,8 +284,8 @@ int Sfm_ComputeInterpolantInt( Sfm_Ntk_t * p, word Truth[2] )
         if ( Value ^ sat_solver_var_value(p->pSat, iVar) ) // insert 1
         {
             word * pSign = Vec_WrdEntryP( p->vDivCexes, i );
-            assert( !Abc_InfoHasBit( (unsigned *)pSign, p->nCexes) );
-            Abc_InfoXorBit( (unsigned *)pSign, p->nCexes );
+            assert( !Abc_TtGetBit( pSign, p->nCexes) );
+            Abc_TtXorBit( pSign, p->nCexes );
         }
     }
     p->nCexes++;
@@ -310,7 +310,7 @@ word Sfm_ComputeInterpolant2( Sfm_Ntk_t * p )
     ResP = Abc_Tt6Isop( Truth[1], ~Truth[0], Vec_IntSize(p->vDivIds), &nCubesP );
     ResN = Abc_Tt6Isop( Truth[0], ~Truth[1], Vec_IntSize(p->vDivIds), &nCubesN );
     Res  = nCubesP <= nCubesN ? ResP : ~ResN;
-    //Dau_DsdPrintFromTruth( &Res, Vec_IntSize(p->vDivIds) );            
+    //Dau_DsdPrintFromTruth( &Res, Vec_IntSize(p->vDivIds) );
     return Res;
 }
 
diff --git a/src/proof/cec/cec.h b/src/proof/cec/cec.h
index 10101e6c0..ca7eed5a7 100644
--- a/src/proof/cec/cec.h
+++ b/src/proof/cec/cec.h
@@ -201,6 +201,27 @@ struct Cec_ParSeq_t_
     int              fVerbose;      // verbose stats
 };
 
+// CEC SimGen parameters
+typedef struct Cec_ParSimGen_t_ Cec_ParSimGen_t;
+struct Cec_ParSimGen_t_
+{
+    int              fVerbose;          // verbose flag
+    int              fVeryVerbose;      // verbose flag
+    int              expId;             // experiment ID for SimGen
+    int              bitwidthOutgold;   // bitwidth of the output gold
+    int              nSimWords;       // number of words in a round of random simulation
+    int              nMaxIter;          // maximum number of rounds of random simulation
+    char *           outGold;           // data containing outgold
+    float            timeOutSim;        // timeout for simulation
+    int              fUseWatchlist;     // use watchlist
+    float            fImplicationTime;  // time spent in implication
+    int              nImplicationExecution; // number of times implication was executed
+    int              nImplicationSuccess; // number of times implication was successful
+    int              nImplicationTotalChecks; // number of times implication was checked
+    int              nImplicationSuccessChecks; // number of times implication was successful
+    char *           pFileName;         // file name to dump simulation vectors
+};
+
 ////////////////////////////////////////////////////////////////////////
 ///                      MACRO DEFINITIONS                           ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/proof/cec/cecCorr.c b/src/proof/cec/cecCorr.c
index c3edf61ff..8d4c730a1 100644
--- a/src/proof/cec/cecCorr.c
+++ b/src/proof/cec/cecCorr.c
@@ -1320,9 +1320,9 @@ Vec_Int_t * Gia_ManFindStopFlops( Gia_Man_t * p, int nFlopIncFreq, int fVerbose
         if ( Spot >= 0 && Vec_IntEntry(vAvail, i) == 0 )
             Vec_IntPush( vHeads, i );
     Vec_IntForEachEntry( vHeads, Spot, i ) {
-        Vec_IntFill( vAvail, Gia_ManRegNum(p), 0 );
+        Gia_ManIncrementTravId( p );
         for ( k = 0, Temp = Spot; Vec_IntEntry(vNexts, Temp) >= 0; k++, Temp = Vec_IntEntry(vNexts, Temp) ) {
-            if ( Vec_IntEntry(vAvail, Temp) )
+            if ( Gia_ObjUpdateTravIdCurrentId(p, Temp) )
                 break;
             Vec_IntWriteEntry( vAvail, Temp, 1 );
         }
@@ -1331,9 +1331,13 @@ Vec_Int_t * Gia_ManFindStopFlops( Gia_Man_t * p, int nFlopIncFreq, int fVerbose
             nItems++;
             if ( vRes == NULL ) 
                 vRes = Vec_IntAlloc( 100 );
-            for ( k = 0, Temp = Spot; Vec_IntEntry(vNexts, Temp) >= 0; k++, Temp = Vec_IntEntry(vNexts, Temp) )
+            Gia_ManIncrementTravId( p );
+            for ( k = 0, Temp = Spot; Vec_IntEntry(vNexts, Temp) >= 0; k++, Temp = Vec_IntEntry(vNexts, Temp) ) {
+                if ( Gia_ObjUpdateTravIdCurrentId(p, Temp) )
+                    break;            
                 if ( k % nFlopIncFreq == 0 )
                     Vec_IntPush( vRes, Temp );
+            }
         }
         while ( Vec_IntEntry(vNexts, Spot) >= 0 )
         {
diff --git a/src/proof/cec/cecSatG2.c b/src/proof/cec/cecSatG2.c
index 554fd550d..9cbbe3cad 100644
--- a/src/proof/cec/cecSatG2.c
+++ b/src/proof/cec/cecSatG2.c
@@ -21,6 +21,9 @@
 #include "aig/gia/gia.h"
 #include "misc/util/utilTruth.h"
 #include "cec.h"
+#include "bdd/extrab/extraBdd.h"
+#include "base/abc/abc.h"
+#include "map/if/if.h"
 
 #define USE_GLUCOSE2
 
@@ -222,6 +225,36 @@ void Cec4_ManSetParams( Cec_ParFra_t * pPars )
     pPars->fBMiterInfo    =       0;    // printing BMiter information
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Default parameter settings.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cec_SimGenSetParDefault( Cec_ParSimGen_t * pPars )
+{
+    memset( pPars, 0, sizeof(Cec_ParSimGen_t) );
+    pPars->fVerbose             = 0; // verbose output
+    pPars->fVeryVerbose         = 0; // verbose output and outputs files
+    pPars->bitwidthOutgold      = 2; // bitwidth of the output golden model
+    pPars->nSimWords          = 4; // number of words in a round of random simulation
+    pPars->expId                = 1; // experiment ID
+    pPars->nMaxIter             = -1; // the maximum number of rounds of random simulation
+    pPars->timeOutSim           = 1000.0; // the timeout for simulation in sec
+    pPars->fUseWatchlist        = 0; // use watchlist
+    pPars->fImplicationTime     = 0.0; // time spent in implication
+    pPars->nImplicationExecution = 0; // the number of implication executions
+    pPars->nImplicationSuccess   = 0; // the number of implication successes
+    pPars->nImplicationTotalChecks = 0; // the number of implication checks
+    pPars->nImplicationSuccessChecks = 0; // the number of implication successful checks
+    pPars->pFileName            = NULL; // file name to dump simulation vectors
+}
+
 /**Function*************************************************************
 
   Synopsis    []
@@ -1830,7 +1863,7 @@ int Cec4_ManPerformSweeping( Gia_Man_t * p, Cec_ParFra_t * pPars, Gia_Man_t ** p
 
     Cec4_Man_t * pMan = Cec4_ManCreate( p, pPars ); 
     Gia_Obj_t * pObj, * pRepr; 
-    int i, fSimulate = 1;
+    int i, fSimulate = 1, Id;
     if ( pPars->fVerbose )
         printf( "Solver type = %d. Simulate %d words in %d rounds. SAT with %d confs. Recycle after %d SAT calls.\n", 
             pPars->jType, pPars->nWords, pPars->nRounds, pPars->nBTLimit, pPars->nCallsRecycle );
@@ -1855,6 +1888,22 @@ int Cec4_ManPerformSweeping( Gia_Man_t * p, Cec_ParFra_t * pPars, Gia_Man_t ** p
             }
     }
 
+    if( p->vSimsPi && p->nSimWords > 0){ // if the simulation pis are already set, do not generate new ones 
+        pPars->nWords = p->nSimWords;
+        Vec_WrdFreeP( &p->vSims );
+        p->vSims     = Vec_WrdStart( Gia_ManObjNum(p) *  pPars->nWords);
+        assert( Vec_WrdSize(p->vSimsPi) == Gia_ManCiNum(p) * p->nSimWords ); 
+        Gia_ManForEachCiId(p, Id, i){
+          memmove( Vec_WrdEntryP(p->vSims, Id*p->nSimWords), Vec_WrdEntryP(p->vSimsPi, i*p->nSimWords), sizeof(word)*p->nSimWords );
+        }
+        Cec4_ManSimulate( p, pMan );
+        if ( pPars->fCheckMiter && !Cec4_ManSimulateCos(p) ) // cex detected
+          goto finalize;
+        if ( fSimOnly )
+          goto finalize;
+        goto execute_sat;
+    }
+
     // simulate one round and create classes
     Cec4_ManSimAlloc( p, pPars->nWords );
     Cec4_ManSimulateCis( p );
@@ -1889,6 +1938,7 @@ int Cec4_ManPerformSweeping( Gia_Man_t * p, Cec_ParFra_t * pPars, Gia_Man_t ** p
         if ( i && i % 5 == 0 && pPars->fVerbose )
             Cec4_ManPrintStats( p, pPars, pMan, 1 );
     }
+    execute_sat:
     if ( i && i % 5 && pPars->fVerbose )
         Cec4_ManPrintStats( p, pPars, pMan, 1 );
 
@@ -2003,7 +2053,7 @@ finalize:
     //Gia_ManEquivPrintClasses( p, 1, 0 );
     if ( ppNew && *ppNew == NULL )
         *ppNew = Gia_ManDup(p);
-    Gia_ManRemoveWrongChoices( p );
+    if ( p->pNexts ) Gia_ManRemoveWrongChoices( p );
     return p->pCexSeq ? 0 : 1;
 }
 Gia_Man_t * Cec4_ManSimulateTest( Gia_Man_t * p, Cec_ParFra_t * pPars )
@@ -2186,6 +2236,2244 @@ void Cec4_ManSimulateTest5( Gia_Man_t * p, int nConfs, int fVerbose )
     Gia_ManStop( pAig );
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Get ISOP LUT.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void getISOPObjId( Gia_Man_t * pMan, int ObjId, char * pSop[2] , int nCubes[2] ){
+
+    assert( Gia_ObjIsLut(pMan, ObjId));
+    char * pSopInfo = pMan->vTTISOPs->pArray + Vec_IntEntry( pMan->vTTLut, ObjId );
+    int k;
+    // get the ISOPs positive polarity
+    for(k = 0; k < 2; k++ ){
+      nCubes[k] =  *pSopInfo;
+      pSopInfo++;
+      if(nCubes[k] == 0){
+        pSop[k] = NULL;
+        continue;
+      }
+      pSop[k] = pSopInfo;
+      pSopInfo += nCubes[k] * 2;
+    }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Encode SOPs.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+Vec_Str_t * encodeSOP(char * pSop, int nFanins, int nCubes){
+
+    Vec_Str_t * vSop = Vec_StrAlloc( nCubes * 2 );
+    char pEncodeCube  = 0;
+    char pDCs = 0;
+    int fanin=0;
+    while( *pSop != '\0'){
+      if( *pSop == '\0')
+        continue;
+      if ( *pSop == '-' ){
+        //pDCs |= ( 1 << (nFanins - fanin - 1) );
+        pDCs |= ( 1 << fanin );
+      } else if ( *pSop == '1' ){
+        //pEncodeCube |= ( 1 << (nFanins - fanin - 1) );
+        pEncodeCube |= ( 1 << fanin );
+      }
+      fanin++;
+      if(fanin == nFanins){
+        Vec_StrPush( vSop, pEncodeCube );
+        Vec_StrPush( vSop, pDCs );
+        pEncodeCube =  0;
+        pDCs =  0;
+        fanin = 0;
+        pSop += 3;
+      }
+      pSop++;
+    }
+    return vSop;
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Extract SOP.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+char * extractSOP( DdManager * dd, DdNode * bFunc, int nFanins, int polarity, int * _nCubes){
+    
+    extern int Abc_CountZddCubes( DdManager * dd, DdNode * zCover );
+    extern int Abc_ConvertZddToSop( DdManager * dd, DdNode * zCover, char * pSop, int nFanins, Vec_Str_t * vCube, int fPhase );
+
+    Vec_Str_t * vCube = Vec_StrAlloc( 100 );
+    int nCubes; char * pSop;
+    DdNode * bCover, * zCover;
+    if( polarity == 0){
+      bCover = Cudd_zddIsop( dd, Cudd_Not(bFunc), Cudd_Not(bFunc), &zCover );
+    } else {
+      bCover = Cudd_zddIsop( dd, bFunc, bFunc, &zCover );
+    }
+    Cudd_Ref( zCover );
+    Cudd_Ref( bCover );
+    Cudd_RecursiveDeref( dd, bCover );
+    nCubes = Abc_CountZddCubes( dd, zCover );
+    pSop = ABC_ALLOC( char, (nFanins + 3) * nCubes + 1 );
+    pSop[(nFanins + 3) * nCubes] = 0;
+    // create the SOP
+    Vec_StrFill( vCube, nFanins, '-' );
+    Vec_StrPush( vCube, '\0' );
+    Abc_ConvertZddToSop( dd, zCover, pSop, nFanins, vCube, polarity );
+    Cudd_RecursiveDerefZdd( dd, zCover );
+
+    if ( pSop == NULL || nFanins != Abc_SopGetVarNum( pSop )){
+        if ( pSop == NULL )
+          printf("SOP generation failed.\n");
+        else {
+          ABC_FREE( pSop );
+          printf( "Node has %d fanins but its SOP has support size %d.\n", nFanins, Abc_SopGetVarNum( pSop ));
+        }
+        fflush( stdout );
+        Vec_StrFree( vCube );
+        return NULL;
+    }
+    
+    Vec_StrFree( vCube );
+    *_nCubes = nCubes;
+    return pSop;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Compute ISOPs of both polarities.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void computeISOPs( Gia_Man_t * p, Abc_Ntk_t * pNtkNew ){
+
+    Abc_Obj_t * pObjNew;
+    DdManager * dd = (DdManager *)pNtkNew->pManFunc;
+    DdNode * bFunc;
+    char * pSop;
+    int nCubes, i, jjj;
+    Vec_Str_t * encodedSop;
+    // compute SOP sizes
+    Vec_Int_t * vGuide = Vec_IntAlloc( Abc_NtkObjNumMax(pNtkNew) );
+    Vec_IntFill( vGuide, Abc_NtkObjNumMax(pNtkNew), -1 );
+    // Collect BDDs in array
+    Vec_Ptr_t * vFuncs = Vec_PtrStart( Abc_NtkObjNumMax(pNtkNew) );
+    assert( !Cudd_ReorderingStatus(dd, (Cudd_ReorderingType *)&nCubes) );
+    Abc_NtkForEachNode( pNtkNew, pObjNew, i )
+        if ( !Abc_ObjIsBarBuf(pObjNew) )
+            Vec_PtrWriteEntry( vFuncs, i, pObjNew->pData );
+    // compute the number of cubes in the ISOPs and detemine polarity
+    nCubes = Extra_bddCountCubes( dd, (DdNode **)Vec_PtrArray(vFuncs), Vec_PtrSize(vFuncs), -1, ABC_INFINITY, Vec_IntArray(vGuide) );
+    Vec_PtrFree( vFuncs );
+    assert( Abc_NtkHasBdd(pNtkNew) );
+    if ( dd->size > 0 )
+    Cudd_zddVarsFromBddVars( dd, 2 );
+
+    // go through the objects
+    Abc_NtkForEachNode( pNtkNew, pObjNew, i )
+    {
+        // derive ISOPs in both polarities
+        if ( Abc_ObjIsBarBuf(pObjNew) )
+            continue;
+        assert( pObjNew->pData );
+        bFunc = (DdNode *)pObjNew->pData;
+        int nFanins = Abc_ObjFaninNum(pObjNew);
+        assert( nFanins <= 8); // we only support 8 fanins due to the data structure of vTTISOPs
+        // Check if node function is constant
+        if ( Cudd_IsConstant(bFunc) ){
+          pSop = ABC_ALLOC( char, nFanins + 4 );
+          pSop[0] = ' ';
+          pSop[1] = '0' + (int)(bFunc == Cudd_ReadOne(dd));
+          pSop[2] = '\n';
+          pSop[3] = '\0';
+          ABC_FREE( pSop );
+          // it's not a LUT, it should be skipped
+          continue;
+        }
+        // save location of the ISOP info in vTTISOPs
+        Vec_IntInsert( p->vTTLut, pObjNew->iTemp , p->vTTISOPs->nSize );
+        
+        // get the ZDD of the negative polarity
+        pSop = extractSOP( dd, bFunc, nFanins, 0 , &nCubes);
+        if ( pSop == NULL )
+            goto cleanup;
+        // encode the sop and save it in the vTTISOPs
+        encodedSop = encodeSOP( pSop, nFanins, nCubes );
+        Vec_StrPush( p->vTTISOPs, (char) nCubes );
+        if (nCubes > 0){ 
+          for (jjj = 0; jjj < nCubes; jjj++){
+            Vec_StrPush( p->vTTISOPs, encodedSop->pArray[jjj*2] ); Vec_StrPush( p->vTTISOPs, encodedSop->pArray[jjj*2+1] );
+          }
+        }
+        Vec_StrFree( encodedSop );
+        ABC_FREE( pSop );
+    
+        // get the ZDD of the positive polarity
+        pSop = extractSOP( dd, bFunc, nFanins, 1 , &nCubes);
+        if ( pSop == NULL )
+            goto cleanup;
+        // encode the sop and save it in the vTTISOPs
+        encodedSop = encodeSOP( pSop, nFanins, nCubes );
+        Vec_StrPush( p->vTTISOPs, (char) nCubes );
+        if (nCubes > 0){ 
+          for (jjj = 0; jjj < nCubes; jjj++){
+            Vec_StrPush( p->vTTISOPs, encodedSop->pArray[jjj*2] ); Vec_StrPush( p->vTTISOPs, encodedSop->pArray[jjj*2+1] );
+          }
+        }
+        Vec_StrFree( encodedSop );
+        ABC_FREE( pSop );
+    
+    }
+
+
+cleanup:
+    // free all used memory to generate SOPs
+    Vec_IntFree( vGuide );
+    Abc_NtkDelete( pNtkNew );
+    return;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Derive SOPs with positive and negative polarity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+void Cec_DeriveSOPs( Gia_Man_t * p ){
+
+    extern Hop_Obj_t * Abc_ObjHopFromGia( Hop_Man_t * pHopMan, Gia_Man_t * p, int GiaId, Vec_Ptr_t * vCopies );
+
+    // generate the structure to contain LUT ids and their corresponding TTISOPS
+    int nCountLuts = Gia_ManLutNum(p);
+    p->vTTISOPs = Vec_StrAlloc( nCountLuts * 10);
+    p->vTTLut = Vec_IntAlloc( Gia_ManObjNum(p) );
+    Vec_IntFill( p->vTTLut, Gia_ManObjNum(p), -1 );
+
+    // Transform the Gia into a HOP network
+    Abc_Ntk_t * pNtkNew;
+    Abc_Obj_t * pObjNew, * pObjNewLi, * pObjNewLo, * pConst0 = NULL;
+    Gia_Obj_t * pObj, * pObjLi, * pObjLo;
+    Vec_Ptr_t * vReflect = Vec_PtrStart( Gia_ManObjNum(p) );
+    int i, k, iFan;
+    assert( Gia_ManHasMapping(p) );
+    pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC,  ABC_FUNC_AIG, 1 );
+    // duplicate the name and the spec
+    pNtkNew->pName = Extra_UtilStrsav(p->pName);
+    pNtkNew->pSpec = Extra_UtilStrsav(p->pSpec);
+    Gia_ManFillValue( p );
+    // create constant
+    pConst0 = Abc_NtkCreateNodeConst0( pNtkNew );
+    Gia_ManConst0(p)->Value = Abc_ObjId(pConst0);
+    // create PIs
+    Gia_ManForEachPi( p, pObj, i )
+        pObj->Value = Abc_ObjId( Abc_NtkCreatePi( pNtkNew ) );
+    // create POs
+    Gia_ManForEachPo( p, pObj, i )
+        pObj->Value = Abc_ObjId( Abc_NtkCreatePo( pNtkNew ) );
+    // create as many latches as there are registers in the manager
+    Gia_ManForEachRiRo( p, pObjLi, pObjLo, i )
+    {
+        pObjNew = Abc_NtkCreateLatch( pNtkNew );
+        pObjNewLi = Abc_NtkCreateBi( pNtkNew );
+        pObjNewLo = Abc_NtkCreateBo( pNtkNew );
+        Abc_ObjAddFanin( pObjNew, pObjNewLi );
+        Abc_ObjAddFanin( pObjNewLo, pObjNew );
+        pObjLi->Value = Abc_ObjId( pObjNewLi );
+        pObjLo->Value = Abc_ObjId( pObjNewLo );
+        Abc_LatchSetInit0( pObjNew );
+    }
+    Gia_ManForEachLut( p, i )
+    {
+        pObj = Gia_ManObj(p, i);
+        assert( pObj->Value == ~0 );
+        if ( Gia_ObjLutSize(p, i) == 0 )
+        {
+            pObj->Value = Abc_ObjId(pConst0);
+            continue;
+        }
+        pObjNew = Abc_NtkCreateNode( pNtkNew );
+        Gia_LutForEachFanin( p, i, iFan, k )
+            Abc_ObjAddFanin( pObjNew, Abc_NtkObj(pNtkNew, Gia_ObjValue(Gia_ManObj(p, iFan))) );
+        pObjNew->pData = Abc_ObjHopFromGia( (Hop_Man_t *)pNtkNew->pManFunc, p, i, vReflect );
+        pObjNew->fPersist = 0;
+        pObj->Value = Abc_ObjId( pObjNew );
+        pObjNew->iTemp = i;
+    }
+    
+    Vec_PtrFree( vReflect );
+
+    // HOP -> BDD
+    Abc_NtkAigToBdd(pNtkNew);
+
+    // Determine both polarity ISOPs
+    computeISOPs( p, pNtkNew );
+
+    return;
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Evaluate MFFC depth.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+int evaluate_mffc(Gia_Man_t * p, int rootId, int fanId, Vec_Int_t * vLeaves){
+
+    int quality = 0, jMFFCLeaf;
+    int nLeaves = Vec_IntSize(vLeaves);    
+    for(jMFFCLeaf = 0; jMFFCLeaf < nLeaves ; jMFFCLeaf++){
+      int idMFFCLeaf = Vec_IntEntry(vLeaves, jMFFCLeaf);
+      int level_leaf = Gia_ObjLevelId(p, idMFFCLeaf) ;
+      int level_root = Gia_ObjLevelId(p, fanId) ;
+      quality +=  level_root - level_leaf;
+    }
+    if( quality != 0 && nLeaves > 0)
+      quality /= nLeaves;
+    return quality;
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Compute MFFCs.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void computeMFFCs( Gia_Man_t * p ){
+
+
+    int i, ith_fan, iFan;
+    Vec_Int_t * vNodes, * vLeaves, * vInners;
+    vNodes  = Vec_IntAlloc( 100 );
+    vLeaves = Vec_IntAlloc( 10 );
+    vInners = Vec_IntAlloc( 100 );
+    Vec_Int_t * vNodesNew, * vLeavesNew, * vInnersNew;
+    vNodesNew  = Vec_IntAlloc( 100 );
+    vLeavesNew = Vec_IntAlloc( 10 );
+    vInnersNew = Vec_IntAlloc( 100 );
+    p->vMFFCsLuts = Vec_IntStartFull( Gia_ManObjNum(p) );
+    //Vec_IntFill( p->vMFFCsLuts, Gia_ManObjNum(p), -1 );
+    p->vMFFCsInfo = Vec_IntAlloc( Gia_ManLutNum(p) * 5 );
+    Gia_ManCreateRefs( p );
+    Gia_ManForEachLut( p, i )
+    {
+        Gia_Obj_t * pObj = Gia_ManObj( p, i );
+
+        if ( !Gia_ObjRefNum(p, pObj) )
+            continue;
+        if ( !Gia_ObjCheckMffc(p, pObj, 10000, vNodes, vLeaves, vInners) )
+            continue;
+
+        Vec_IntInsert( p->vMFFCsLuts, i  , Vec_IntSize(p->vMFFCsInfo) );
+        Gia_LutForEachFanin( p, i, iFan, ith_fan ){
+          if (Vec_IntFind(vNodes, iFan) != -1){
+            if(Gia_ObjIsCi(Gia_ManObj(p, iFan)) == 1){
+              Vec_IntPush(p->vMFFCsInfo, Gia_ObjLevelId(p, i) ); // push the level of the CI
+              continue;
+            }
+            Gia_Obj_t * pObjFanin = Gia_ManObj( p, iFan );
+            if ( !Gia_ObjRefNum(p, pObjFanin) ){
+                Vec_IntPush(p->vMFFCsInfo, 0);
+                continue;
+            }
+            if ( !Gia_ObjCheckMffc(p, pObjFanin, 10000, vNodesNew, vLeavesNew, vInnersNew)){
+                Vec_IntPush(p->vMFFCsInfo, 0);
+                continue;
+            }
+            assert( Vec_IntSize(vLeavesNew) > 0);
+            int quality = evaluate_mffc(p, i, iFan, vLeavesNew);
+            Vec_IntPush(p->vMFFCsInfo, quality);
+
+          } else {
+            Vec_IntPush( p->vMFFCsInfo, 0 );
+          }
+
+        }
+    }
+    Vec_IntFree( vNodes );
+    Vec_IntFree( vLeaves );
+    Vec_IntFree( vInners );
+    Vec_IntFree( vNodesNew );
+    Vec_IntFree( vLeavesNew );
+    Vec_IntFree( vInnersNew );
+
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Evaluate MFFC depth.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+int extract_quality_mffc(Gia_Man_t * p, int ObjId, char pDCs){
+
+    if( Vec_IntEntry( p->vMFFCsLuts, ObjId ) == -1)
+      return 0;
+    assert( Vec_IntEntry( p->vMFFCsLuts, ObjId ) != -1);
+    int * pMFFC = p->vMFFCsInfo->pArray + Vec_IntEntry( p->vMFFCsLuts, ObjId );
+    int iFan, ith_fan, quality = 0;
+    //int nFanins = Gia_ObjLutSize(p, ObjId);
+    Gia_LutForEachFanin( p, ObjId, iFan, ith_fan ){
+      int qualityMFFC = *pMFFC;
+      if (qualityMFFC == 0 || (pDCs & (1 << ith_fan)) > 0){ // count the cones without don't cares
+        pMFFC++;
+        continue;
+      }
+      quality +=  qualityMFFC;
+      pMFFC++;
+    }
+    return quality;
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Generate LUTs Ranking for SimGen algo.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+int * sortArray( int * array, int n ){
+
+    int i, j, temp;
+    int * positions = (int *) malloc( n * sizeof(int) );
+    for(i = 0; i < n; i++)
+      positions[i] = i;
+    for(i = 0; i < n; i++){
+      for(j = i+1; j < n; j++){
+        if(array[i] < array[j]){
+          temp = array[i];
+          array[i] = array[j];
+          array[j] = temp;
+          temp = positions[i];
+          positions[i] = positions[j];
+          positions[j] = temp;
+        }
+      }
+    }
+    return positions;
+
+}
+
+void generateLutsRankings( Gia_Man_t * p){
+
+    p->vLutsRankings = Vec_PtrStart( Gia_ManObjNum(p) );
+    Vec_Int_t * vLutsRankingsTmp = Vec_IntAlloc( Gia_ManLutNum(p) * 5 ); 
+    int LutId, iii, k, jjj;
+    char * pSop[2]; int nCubes[2]; int nFanins;
+    int * ranks, * fanins;
+    Gia_ManForEachLut( p, LutId )
+    {
+        nFanins = Gia_ObjLutSize(p, LutId);
+        Vec_PtrInsert( p->vLutsRankings, LutId, vLutsRankingsTmp->pArray + Vec_IntSize(vLutsRankingsTmp) );
+        assert( nFanins > 0 );
+        ranks = (int*) malloc( nFanins * sizeof(int) );
+        fanins = (int*) malloc( nFanins * sizeof(int) );
+        Gia_LutForEachFanin( p, LutId, k, iii ){
+          fanins[iii] = k;
+          ranks[iii] = 0;
+        }
+        
+        nFanins = Gia_ObjLutSize(p, LutId);
+        getISOPObjId( p, LutId, pSop, nCubes );
+        for(k = 0; k < 2; k++){
+          for(iii = 0; iii < nCubes[k]; iii++){
+            //char pCube =  pSop[k][iii*2];
+            char pDCs =  pSop[k][iii*2+1];
+            for(jjj = 0; jjj < nFanins; jjj++){
+              if ( (pDCs & (1 << jjj)) == 0 )
+                ranks[jjj]++;
+            }
+          }
+        }
+        int * positions = sortArray( ranks, nFanins );
+        for(jjj = 0; jjj < nFanins; jjj++){
+          Vec_IntPush( vLutsRankingsTmp, fanins[positions[jjj]] );
+        }
+        free( positions );
+        free( ranks );
+        free( fanins );
+    }
+    //Vec_IntFree( vLutsRankingsTmp );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Generate Nodes Watchlist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+Vec_Ptr_t * generateWatchList( Gia_Man_t * p ){
+
+    Vec_Ptr_t * vWatchList = Vec_PtrStart( Gia_ManObjNum(p) );
+    int LutId;
+    Gia_ManForEachLut( p, LutId )
+    {
+        int * ranking = (int *) Vec_PtrEntry( p->vLutsRankings, LutId );
+        int nodeId = ranking[0];
+        if( Vec_PtrEntry( vWatchList, nodeId ) == NULL ){
+          Vec_Int_t * vWatchListTmp = Vec_IntAlloc( 5 );
+          Vec_PtrWriteEntry( vWatchList, nodeId, vWatchListTmp );
+          Vec_IntPush( vWatchListTmp, LutId );
+          //Vec_IntFree( vWatchListTmp );
+        } else {
+          Vec_IntPush( (Vec_Int_t *) Vec_PtrEntry( vWatchList, nodeId ), LutId );
+        }
+    }
+    return vWatchList;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fill in the fanout vectors for the LUTs.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void Gia_generateFanoutMapping( Gia_Man_t * p )
+{
+    int iObj, iFanin, k;
+    assert( Gia_ManHasMapping(p) );
+    Vec_WecFreeP( &p->vFanouts2 );
+    p->vFanouts2 = Vec_WecStart( Gia_ManObjNum(p) );
+    Gia_ManForEachLut( p, iObj )
+    {
+        Gia_LutForEachFanin( p, iObj, iFanin, k )
+        {
+            Vec_WecPush( p->vFanouts2, iFanin, iObj );
+        }
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Remove all non-LUT nodes from equivalence classes.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+void Cec_RemoveNonLutNodes( Gia_Man_t * p){
+
+    int i, iRepr, kElement, firstLutId, prevLutId;
+    Vec_Int_t * vLutIds = Vec_IntAlloc( Gia_ManObjNum(p) );
+    Gia_ManForEachClass0( p, iRepr )
+    {
+      Gia_ClassForEachObj1( p, iRepr, kElement ){
+        Vec_IntPush( vLutIds, kElement );
+      }
+
+      firstLutId = -1; prevLutId = -1;
+      if( !Gia_ObjIsLut(p, iRepr) ){
+          Gia_ObjSetRepr( p, iRepr, GIA_VOID );
+          Gia_ObjSetNext( p, iRepr, 0 );
+      } else {
+          firstLutId = iRepr;
+          prevLutId = iRepr;
+      }
+      Vec_IntForEachEntry( vLutIds, kElement, i ){
+
+        if( !Gia_ObjIsLut(p, kElement) ){
+            Gia_ObjSetRepr( p, kElement, GIA_VOID );
+            Gia_ObjSetNext( p, kElement, 0 );
+            continue;
+        }
+        if(firstLutId == -1){
+            Gia_ObjSetRepr( p, kElement, GIA_VOID );
+            firstLutId = kElement;
+            prevLutId = kElement;
+        } else {
+            Gia_ObjSetRepr( p, kElement, firstLutId );
+            Gia_ObjSetNext( p, prevLutId , kElement );
+            prevLutId = kElement;
+        }
+      }
+      Vec_IntClear( vLutIds );
+      // no lut found
+      if(firstLutId == -1){
+        continue;
+      }
+      Gia_ObjSetNext( p, prevLutId, 0 );
+
+    }
+    Vec_IntFree( vLutIds );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Evaluate equivalence classes.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int evaluate_equiv_classes(Gia_Man_t * p, int verbose){
+
+    int i, k;
+    int quality = 0;
+    Gia_ManForEachClass0( p, i )
+    {
+        Gia_ClassForEachObj1( p, i, k ){
+          quality++;
+        }
+    }
+
+    if (verbose)
+      printf("**Quality = %d\n", quality);
+
+    return quality;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Compute total number of classes.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+int totalNumClasses(Gia_Man_t * p){
+  int iRepr;
+  int numClasses = 0;
+  Gia_ManForEachClass0( p, iRepr ){
+    numClasses++;
+  }
+  return numClasses;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Save PI simulation values.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+void saveSimVectors( Gia_Man_t * p, Vec_Ptr_t * pValues, int bitLength, int jth_word, int kth_bit){
+
+    int i, Id;
+    int nWords = bitLength / 64;
+    assert(nWords == 0); // Not considering case with large outgold values
+    Gia_ManForEachCiId( p, Id, i ){
+        Vec_Wrd_t * pValuesPi = (Vec_Wrd_t *) Vec_PtrEntry( pValues, i );
+        word pValuePiJWord = 0;
+        if(kth_bit == 0){
+          Vec_WrdPush( pValuesPi, 0 );
+        } else {
+          pValuePiJWord = Vec_WrdEntry( pValuesPi, jth_word );
+        }
+        word * pSim = Cec4_ObjSim( p, Id );
+        pValuePiJWord = (pSim[0] << kth_bit) ^ pValuePiJWord;
+        Vec_WrdWriteEntry( pValuesPi, jth_word, pValuePiJWord );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Simulate the CIs with random values.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+void executeRandomSim( Gia_Man_t * p, Cec4_Man_t * pMan , int dynSim, int nMaxIter , Vec_Ptr_t * vSimSave, int verbose ){
+
+  clock_t start_time = clock();
+  int i, j, k, Id;
+  int numClass = 100000;
+  int oldNumClass = 0, iMaxNumber = 200, iNumber = 0;
+  if(dynSim){
+    while (numClass != oldNumClass && iNumber < iMaxNumber)
+    {
+      oldNumClass = numClass;
+      Cec4_ManSimulateCis( p );
+      Cec4_ManSimulate( p, pMan );
+      int quality = evaluate_equiv_classes(p, 0);
+      if (verbose)
+        printf("Time elapsed: %f (classes size: %d)\n", (float)(clock() - start_time)/CLOCKS_PER_SEC, quality);
+      numClass = totalNumClasses(p);
+      iNumber++;
+      Gia_ManForEachCiId( p, Id, j ){
+        Vec_Wrd_t * vSimPI = (Vec_Wrd_t *) Vec_PtrEntry( vSimSave, j );
+        word * pSim = Cec4_ObjSim( p, Id );
+        for( k = 0; k < p->nSimWords; k++ ){
+          Vec_WrdPush( vSimPI, pSim[k] );
+        }
+      }
+    }
+    
+
+  } else {
+    for(i = 0; i < nMaxIter; i++){
+      Cec4_ManSimulateCis( p );
+      Cec4_ManSimulate( p, pMan );
+      int quality = evaluate_equiv_classes(p, 0);
+      Cec_RemoveNonLutNodes( p );
+      if (verbose)
+        printf("Time elapsed: %f (classes size: %d)\n", (float)(clock() - start_time)/CLOCKS_PER_SEC, quality);
+      Gia_ManForEachCiId( p, Id, j ){
+        Vec_Wrd_t * vSimPI = (Vec_Wrd_t *) Vec_PtrEntry( vSimSave, j );
+        word * pSim = Cec4_ObjSim( p, Id );
+        for( k = 0; k < p->nSimWords; k++ ){
+          Vec_WrdPush( vSimPI, pSim[k] );
+        }
+      }
+    }
+  }
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Export Equivalence classes.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void exportEquivClasses(Gia_Man_t * p, char * filename){
+
+    FILE * pFile;
+    pFile = fopen( filename, "wb" );
+    int i, j, iii = 0;
+    Gia_ManForEachClass0( p, i )
+    {
+        fprintf( pFile, "Class %d: %d ", iii , i);
+        Gia_ClassForEachObj1( p, i, j ){
+          fprintf( pFile, " %d ", j );
+        }
+        fprintf(pFile, "\n");
+        iii++;
+    }
+    fclose( pFile );
+
+
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Generate the output golden values.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+char * generateOutGoldValues(Gia_Man_t * p){
+
+    char * pOutGold = (char *) malloc( sizeof(char) * Gia_ManObjNum(p) );
+    int i, k;
+    int cnt = 85; // 0b01010101
+    Gia_ManForEachLut( p, i ){
+        pOutGold[i] = (char) 0;
+    }
+    Gia_ManForEachClass0( p, i ){
+        pOutGold[i] = (char) cnt;
+        cnt ^= 1;
+        Gia_ClassForEachObj1( p, i, k ){
+          pOutGold[k] = (char) cnt;
+          cnt ^= 1;
+        }
+    }
+    return pOutGold;
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Check if it exists at least one class.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int existsOneClass(Gia_Man_t * p){
+  int iRepr;
+  Gia_ManForEachClass0( p, iRepr ){
+    return 1;
+  }
+  return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Extract nth equivalence class.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+Vec_Int_t * extractNthClass(Gia_Man_t * p, int nth_class){
+
+  Vec_Int_t * vClass = Vec_IntAlloc( Gia_ManLutNum(p) );
+  int iRepr, jLut;
+  Gia_ManForEachClass0( p, iRepr ){
+    if(nth_class == 0){
+      Vec_IntPush(vClass, iRepr);
+      Gia_ClassForEachObj1( p, iRepr, jLut )
+        Vec_IntPush(vClass, jLut);
+      break;
+    }
+    nth_class--;
+  }
+  assert(Vec_IntSize(vClass) > 0);
+  return vClass;
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Compute the LUTs order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+Vec_Int_t * computeLutsOrder(Gia_Man_t * p, int reorder_type){
+
+    Vec_Int_t * luts_order = Vec_IntAlloc( Gia_ManLutNum(p) );
+    int * luts_tmp = (int *) malloc( sizeof(int) * Gia_ManLutNum(p));
+    int iRepr, jLut, iii, jjj, kkk;
+    Gia_ManForEachClass0( p, iRepr ){
+        luts_tmp[ 0 ] = iRepr;
+        iii = 1;
+        Gia_ClassForEachObj1( p, iRepr, jLut ){
+          if(reorder_type == 0){ // decreasing level order
+            int found = 0;
+            for(jjj = 0; jjj < iii; jjj++){
+              if(Gia_ObjLevelId(p, jLut) <= Gia_ObjLevelId(p, luts_tmp[jjj])){
+                for (kkk = iii; kkk > jjj; kkk--) {
+                  luts_tmp[kkk] = luts_tmp[kkk - 1];
+                }
+                luts_tmp[jjj] = jLut;
+                found = 1;
+                break;
+              }
+            }
+            if(!found){
+              luts_tmp[iii] = jLut;
+            }
+            iii++;
+          } else if(reorder_type == 1) { // increasing level order
+            int found = 0;
+            for(jjj = 0; jjj < iii; jjj++){
+              if(Gia_ObjLevelId(p, jLut) >= Gia_ObjLevelId(p, luts_tmp[jjj])){
+                for (kkk = iii; kkk > jjj; kkk--) {
+                  luts_tmp[kkk] = luts_tmp[kkk - 1];
+                }
+                luts_tmp[jjj] = jLut;
+                found = 1;
+                break;
+              }
+            }
+            if(!found){
+              luts_tmp[iii] = jLut;
+            }
+            iii++;
+          }
+        }
+        for(kkk = 0; kkk < iii; kkk++)
+          Vec_IntPush(luts_order, luts_tmp[kkk] );
+    }
+    free(luts_tmp);
+    return luts_order;
+
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Compute the fanin cones.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+void computeFaninCones_rec(Gia_Man_t * p, int ObjId, Vec_Int_t * vLutsFaninCones ){
+
+    int FaninId, jth_fanin;
+    Gia_LutForEachFanin( p, ObjId, FaninId, jth_fanin ){
+      if( Vec_IntEntry( vLutsFaninCones, FaninId ) == 0 ){
+        Vec_IntWriteEntry( vLutsFaninCones, FaninId, 1 );
+        if( Gia_ObjIsCi( Gia_ManObj(p, FaninId) ) == 0 )
+          computeFaninCones_rec( p, FaninId, vLutsFaninCones );
+      }
+    }
+}
+
+Vec_Int_t * computeFaninCones( Gia_Man_t * p, Vec_Int_t * vLuts ){
+
+    int i, jth_fanin;
+    Vec_Int_t * vLutsFaninCones = Vec_IntStart(Gia_ManObjNum(p));
+    Vec_IntForEachEntry( vLuts, i, jth_fanin ){
+      computeFaninCones_rec( p, i, vLutsFaninCones );
+    }
+    return vLutsFaninCones;
+
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Check compatibility ISOP and Vec.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+int checkCompatibilityCube( Gia_Man_t * pMan, char * pCube, int nFanins, char * pCubeGold ){
+
+    char pCubeOnes = *pCube; char pDCs = *(pCube+1);
+    char pCubeGoldOnes = *pCubeGold; char pCubeNotAssigned = *(pCubeGold+1);
+
+    char pSkipBits = pDCs | pCubeNotAssigned;
+    char pConflictBits = pCubeOnes ^ pCubeGoldOnes;
+    char isConflict = ~pSkipBits & pConflictBits;
+    if ( isConflict )
+      return 0;
+
+    return 1;
+
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Compute quality of SOP.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int compute_quality_sop(Gia_Man_t * p , char * pSop, int ObjId ,int nFanins, int experimentID){
+
+    int quality = 0;
+    //char pValues = *pSop;
+    pSop++;
+    char pDCs = *(pSop);
+    switch (experimentID){
+    case 1: // Reverse Simulation
+    case 2: // Simple Implication
+    case 3: // Advanced Implication
+      break;
+    case 4: // Advanced Implication + Count DCs
+      while (pDCs > 0){
+        if((pDCs & 1) == 1)
+          quality += p->nLevels * 5; // the presence of DCs is more important than mffc 
+        pDCs = pDCs >> 1;
+      }      
+      break;
+    case 5: // Advanced Implication + Count DC + FFC
+      while (pDCs > 0){
+        if((pDCs & 1) == 1)
+          quality += p->nLevels * 5; // the presence of DCs is more important than mffc
+        pDCs = pDCs >> 1;
+      }   
+      pDCs = *(pSop);   
+      quality += extract_quality_mffc(p, ObjId, pDCs);
+      break;
+    default:
+      break;
+    }
+    return quality;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Execute roulette wheel.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int rouletteWheel( Vec_Int_t * vQualitySops, int numValid){
+
+    int i, max_int = 0xffffffff;
+    float totalSum;
+		totalSum = 0.0;
+		for ( i = 0; i < numValid; i++ )
+			totalSum += (float) Vec_IntEntry(vQualitySops, i);
+
+    unsigned int randValue = Gia_ManRandom(0);
+    float randValueNormalized = (float) ((float)randValue / max_int);
+		float randomNum =  randValueNormalized * totalSum;
+
+		// Select the index based on inverse proportional probability
+    float cumulativeProbability = 0.0;
+		for ( i = 0; i < numValid; i++ ) {
+      cumulativeProbability += Vec_IntEntry(vQualitySops, i);
+      if (cumulativeProbability > randomNum) {
+        return i;
+      }
+		}
+    return -1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Select SOP depending on quality value and the experimentID.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int selectSop( Vec_Int_t * vQualitySops, int ith_max_quality, int experimentID){
+
+    assert(experimentID > 0); // random simulation should not be used here
+    int numValid = Vec_IntSize(vQualitySops);
+    int idSelected = -1;
+    switch (experimentID){
+    //case 1:
+    //  idSelected = Aig_ManRandom(0) % numValid;
+    //  break;    
+    default:
+      idSelected = rouletteWheel( vQualitySops, numValid);
+      break;
+    }
+    if(idSelected == -1){
+      idSelected = ith_max_quality;
+    }
+    assert( idSelected != -1);
+    return idSelected;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Check implication.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int check_implication( Gia_Man_t * p, int ObjId , int validBit , int fanoutValue, int fanoutNotSet, char * inputsFaninsValues, char * networkValues1s, char * networkValuesNotSet , int experimentID){
+
+    assert(experimentID > 1);
+    int ith_cube, jjj;
+    int nFanins = Gia_ObjLutSize(p, ObjId);
+    char * pSopBoth[2]; int nCubesBoth[2];
+    getISOPObjId( p, ObjId, pSopBoth, nCubesBoth );
+
+    if (fanoutNotSet == 0){
+      // case in which the output is set // backward implication
+      char * pSop = pSopBoth[fanoutValue];
+      int nCubes = nCubesBoth[fanoutValue];
+      int compatible = 0;
+      int lastCube = 0;
+      for(ith_cube = 0; ith_cube < nCubes; ith_cube++){
+        if(checkCompatibilityCube( p, pSop + ith_cube * 2, nFanins, inputsFaninsValues ) ){
+          compatible++;
+          lastCube = ith_cube;
+        }
+      }
+      
+
+      if(compatible == 1){
+        //char selectedSop = *(pSop + lastCube * 2);
+        //char selectedDCs = *(pSop + lastCube * 2 + 1);
+        assert(0); // TODO: implement the case in which the output is set
+        return 1;
+      } else if (compatible == 0){
+        return -1;
+      }
+
+      return 0;
+    } 
+    // forward implication
+    int compatible[2];
+    compatible[0] = 0;
+    compatible[1] = 0;
+    for(jjj = 0; jjj < 2; jjj++){
+
+      char * pSop = pSopBoth[jjj];
+      int nCubes = nCubesBoth[jjj];
+      for(ith_cube = 0; ith_cube < nCubes; ith_cube++){
+        if(checkCompatibilityCube( p, pSop + ith_cube * 2, nFanins, inputsFaninsValues ) ){
+          compatible[jjj]++;
+          if(compatible[jjj] > 1)
+            break;
+        }
+      }
+    }
+
+    if(compatible[0] > 0 && compatible[1] > 0){
+      return 0;
+    } else if (compatible[0] == 0 && compatible[1] == 0){
+      return -1;
+    }
+
+    if(experimentID == 2){
+      // simple implication
+      if(compatible[0] > 1 || compatible[1] > 1){
+        return 0;
+      }
+      char mask = 1 << validBit;
+      if(compatible[0] == 1){
+        networkValuesNotSet[ObjId] &= (~mask);
+      } else {
+        networkValues1s[ObjId] |= (1 << validBit);
+        networkValuesNotSet[ObjId] &= (~mask);
+      }     
+      return 1;
+    } else if (experimentID > 2){
+      // advanced implication
+      char mask = 1 << validBit;
+      if(compatible[0] >= 1){
+        networkValuesNotSet[ObjId] &= (~mask);
+      } else {
+        networkValues1s[ObjId] |= (1 << validBit);
+        networkValuesNotSet[ObjId] &= (~mask);
+      }
+      return 1;
+    }
+
+    assert(0);
+    // In C++ assert(0) doesn't count as a proper exit.
+    // needs to return a value to compile.
+    return -1;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Check compatibility of cubes for implications.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+int checkCompatibilityImplication( Gia_Man_t * p, Cec_ParSimGen_t * pPars, char * netValid, int objId, char * networkValues1s, char * networkValuesNotSet , Vec_Int_t * vLuts2Imply, Vec_Int_t * vLutsValidity  , int experimentID){
+
+
+    char _valid_vecs = *netValid;
+    char inputsFaninsValues[2] = {0, 0};
+    int firstElement = 0;
+    int iii = -1, FaninId, jjj;
+    pPars->nImplicationTotalChecks++;
+    while (_valid_vecs > 0){
+      iii++;
+      if( (_valid_vecs & 1) == 0){
+        _valid_vecs = _valid_vecs >> 1;
+        continue;
+      }
+      // retrieve value of the fanout
+      char mask = 1 << iii;
+      int fanoutValue = (networkValues1s[objId] & mask) >> iii;
+      int fanoutNotSet = (networkValuesNotSet[objId] & mask) >> iii;
+
+      if(fanoutNotSet == 0){
+        // disable backward implication in this function
+        _valid_vecs = _valid_vecs >> 1;
+        continue;
+      }
+      // re-arrange fanin values format
+      Gia_LutForEachFanin( p, objId, FaninId, jjj ){
+        char valueFanin = networkValues1s[FaninId];
+        char valueFaninNotSet = networkValuesNotSet[FaninId];
+        inputsFaninsValues[0] |= ( ((valueFanin & mask) >> iii) << jjj);
+        inputsFaninsValues[1] |= ( ((valueFaninNotSet & mask) >> iii) << jjj);
+      }        
+
+
+      if(fanoutNotSet == 0 && inputsFaninsValues[1] == 0){
+        _valid_vecs = _valid_vecs >> 1;
+        continue;
+      }
+
+      int status = check_implication( p, objId, iii, fanoutValue, fanoutNotSet, inputsFaninsValues, networkValues1s, networkValuesNotSet , experimentID);
+      if(status == -1){
+        *netValid = *netValid & ~(1 << iii);
+      } else if( status == 1){
+        if(firstElement == 0){
+          pPars->nImplicationSuccessChecks++;
+          Vec_IntPush( vLutsValidity, 1 << iii );
+          Vec_IntPush( vLuts2Imply, objId );
+        } else {
+          Vec_IntWriteEntry( vLutsValidity, Vec_IntSize(vLutsValidity) - 1, Vec_IntEntry(vLutsValidity, Vec_IntSize(vLutsValidity) - 1) | (1 << iii) );
+        }
+      }
+
+      _valid_vecs = _valid_vecs >> 1;
+    }
+
+    if( *netValid == 0){
+      return 0;
+    }
+
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Compute list of luts to imply.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+int computeLutsToImply( Gia_Man_t * p, Cec_ParSimGen_t * pPars, char * netValid, int ObjId, char * networkValues1s, char * networkValuesNotSet , Vec_Int_t * vLutsFaninCones, Vec_Int_t * vLuts2Imply, Vec_Int_t * vLutsValidity , Vec_Ptr_t * vNodesWatchlist, int experimentID){
+
+    int i, FanoutId, jth_fanout, LutId, k;
+    
+    if(vNodesWatchlist == NULL){
+      // Option 1: iterate through fanouts to check if there can be an implication and if yes, apply it
+      Gia_LutForEachFanout2( p, ObjId, FanoutId, jth_fanout ){
+        if( Vec_IntEntry(vLutsFaninCones, FanoutId) == 0){
+          // if the lut FanoutId is not in any cone, it shouldn't be considered
+          continue;
+        }
+        int status = checkCompatibilityImplication( p, pPars, netValid, FanoutId, networkValues1s, networkValuesNotSet, vLuts2Imply, vLutsValidity, experimentID);
+        if(status <= 0){
+          return status;
+        }
+      }
+    } else {
+      // Option 2: iterate through the watchlist to check if there can be an implication and if yes, apply it
+      Vec_Int_t * vWatchlist = (Vec_Int_t *) Vec_PtrEntry( vNodesWatchlist, ObjId );
+      if(vWatchlist == NULL){
+        return 1;
+      }
+      Vec_IntForEachEntry( vWatchlist, FanoutId, i ){
+        if( Vec_IntEntry(vLutsFaninCones, FanoutId) == 0){
+          // if the lut FanoutId is not in any cone, it shouldn't be considered
+          continue;
+        }
+        int status = checkCompatibilityImplication( p, pPars, netValid, FanoutId, networkValues1s, networkValuesNotSet, vLuts2Imply, vLutsValidity, experimentID);
+        if(status <= 0){
+          return status;
+        }
+      }
+      // update watchlist of LUTs
+      Vec_IntForEachEntry( vWatchlist, LutId, i ){
+        int * ranking = (int *) Vec_PtrEntry( p->vLutsRankings, LutId );
+        int FaninSize = Gia_ObjLutSize( p, LutId ), newWatchK = -1;
+        for(k = 0; k < FaninSize ; k++){
+          if(ranking[k] == ObjId){
+            newWatchK = k+1;
+            break;
+          }
+        }
+        assert(newWatchK != -1);
+        if(newWatchK >= FaninSize){ // the LUT is already fully watched
+          continue;
+        }
+        int newWatch = ranking[newWatchK];
+        Vec_Int_t * vNewWatch = (Vec_Int_t *) Vec_PtrEntry( vNodesWatchlist, newWatch );
+        if(vNewWatch == NULL){ // case in which there was no watch for a certain variable
+          vNewWatch = Vec_IntAlloc( 10 );
+          Vec_PtrWriteEntry( vNodesWatchlist, newWatch, vNewWatch );
+          Vec_IntPush( vNewWatch, LutId );
+        } else {
+          if(Vec_IntFind(vNewWatch, LutId) == -1){
+            Vec_IntPush( vNewWatch, LutId );
+          }
+        }
+      }
+
+    }
+    return 1;
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Execute implications.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int executeImplications( Gia_Man_t * p, Cec_ParSimGen_t * pPars, char * netValid, int ObjId, char * networkValues1s, char * networkValuesNotSet , Vec_Int_t * vLutsFaninCones, Vec_Ptr_t * vNodesWatchlist , int experimentID){
+
+    assert( *netValid > 0);
+    pPars->nImplicationExecution++;
+    int iii = -1, FanoutId;
+    Vec_Int_t * vLuts2Imply = Vec_IntAlloc( 10 );
+    Vec_Int_t * vLutsValidity = Vec_IntAlloc( 10 ); 
+
+    // first compute the list of luts to imply
+    int status = computeLutsToImply( p, pPars, netValid, ObjId, networkValues1s, networkValuesNotSet, vLutsFaninCones, vLuts2Imply, vLutsValidity, vNodesWatchlist , experimentID);
+    if(status <= 0){
+      Vec_IntFree( vLuts2Imply );
+      Vec_IntFree( vLutsValidity );
+      return status;
+    } 
+
+    // second recursively go through the implied luts if there is any implication that can be applied
+    Vec_IntForEachEntry( vLuts2Imply, FanoutId, iii ){
+      pPars->nImplicationSuccess++;
+      char validFanoutId = Vec_IntEntry(vLutsValidity, iii);
+      status = executeImplications( p, pPars, &validFanoutId, FanoutId, networkValues1s, networkValuesNotSet, vLutsFaninCones, vNodesWatchlist ,experimentID);
+      if (status == -1){
+        Vec_IntFree( vLuts2Imply );
+        Vec_IntFree( vLutsValidity );
+        return -1;
+      }
+    }
+
+
+    Vec_IntFree( vLuts2Imply );
+    Vec_IntFree( vLutsValidity );
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Compute network values.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int computeNetworkValues(Gia_Man_t * p, Cec_ParSimGen_t * pPars, int ObjId ,  char * netValid, char lutValues1s, char * networkValues1s, char * networkValuesNotSet , Vec_Int_t * modifiedLuts , Vec_Int_t * vLutsFaninCones , Vec_Ptr_t * vNodesWatchlist , int experimentID ){
+
+    assert(experimentID > 0);
+    assert(  *netValid > 0 );
+
+    if( Gia_ObjIsCi( Gia_ManObj(p, ObjId) ) ){
+      printf("[ERROR] It is not possible to call computeNetworkValues for PIs");
+      return -1;
+    }
+    char * pSopBoth[2]; int nCubesBoth[2];
+    char * pSop; int nCube, ith_cube, jth_fanin, FaninId;
+    getISOPObjId( p, ObjId, pSopBoth, nCubesBoth );
+    Vec_Ptr_t * vSops = Vec_PtrAlloc( 8 ); // for now consider only 8 parallalel SOPs due to char size
+    Vec_Int_t * vQualitySops = Vec_IntAlloc( 8 ); // compute qualities of SOPs
+    Vec_Int_t * vCubeId = Vec_IntAlloc( 8 ); // save ids of the selected cubes
+    char _valid_vecs = *netValid;
+    char _desired_values = lutValues1s;
+    int iii = -1, max_quality, ith_max_quality, validNum =0;
+    int nFanins = Gia_ObjLutSize(p, ObjId);
+    // first compute all SOPs that are available 
+    while (_valid_vecs > 0){
+      iii++;
+      if( (_valid_vecs & 1) == 0){
+        _valid_vecs = _valid_vecs >> 1;
+        _desired_values = _desired_values >> 1;
+        continue;
+      }
+      validNum++;
+      if( (_desired_values & 1) == 0){
+        // negative polarity
+        pSop = pSopBoth[0];
+        nCube = nCubesBoth[0];
+      } else {
+        // positive polarity
+        pSop = pSopBoth[1];
+        nCube = nCubesBoth[1];
+      }
+      Vec_IntClear(vQualitySops); // reset the quality of the SOPs
+      Vec_IntClear(vCubeId); // reset the ids of the cubes
+      char valuesFaninsMasked[2] = {0, 0}; // re-arrange all the fanin values for a specific iteration
+      Gia_LutForEachFanin( p, ObjId, FaninId, jth_fanin ){
+        char valuesFanin = networkValues1s[FaninId];
+        char valueFaninNotSet = networkValuesNotSet[FaninId];
+        char mask = 1 << iii;
+        valuesFaninsMasked[0] |= ( ((valuesFanin & mask) >> iii) << jth_fanin);
+        valuesFaninsMasked[1] |= ( ((valueFaninNotSet & mask) >> iii) << jth_fanin);
+      }
+      max_quality = 0;
+      ith_max_quality = -1;
+      for(ith_cube = 0; ith_cube < nCube; ith_cube++){
+        if(checkCompatibilityCube( p, pSop + ith_cube * 2, nFanins, valuesFaninsMasked ) ){
+          int quality = 1;
+          quality += compute_quality_sop(p, pSop + ith_cube * 2, ObjId , nFanins, experimentID);
+          if(quality > max_quality){
+            max_quality = quality;
+            ith_max_quality = ith_cube;
+          }
+          Vec_IntPush(vQualitySops, quality);
+          Vec_IntPush(vCubeId, ith_cube);
+        }
+      }
+      if(ith_max_quality == -1){ // no cube found that respects the values of the fanins
+        // the vector is not valid
+        validNum--;
+        *netValid = *netValid & ~(1 << iii);
+      } else {
+        int _idCube = selectSop(vQualitySops, ith_max_quality, experimentID);
+        int idSop = Vec_IntEntry(vCubeId, _idCube);
+        Vec_PtrPush( vSops, pSop + idSop * 2 );
+      }
+      _valid_vecs = _valid_vecs >> 1;
+      _desired_values = _desired_values >> 1;
+    }
+    Vec_IntFree( vQualitySops );
+    Vec_IntFree( vCubeId );
+    assert( validNum == Vec_PtrSize(vSops) );
+    _valid_vecs = *netValid;
+    // if not SOP available is valid return 0 ( not -1 since the valid vector might have been modified to skip DCs // there might be some valid SOPs for the next fanin)
+    if( _valid_vecs == 0){
+      //printInfoLutValues( p, ObjId, netValid, lutValues1s, networkValues1s, networkValuesNotSet);
+      //printf("[WARNING] No valid SOPs found for node %d\n", ObjId);
+      Vec_PtrFree( vSops );
+      return 0;
+    }
+    Vec_IntPush( modifiedLuts, ObjId );
+    // second traverse the graph applying the selected SOPs
+    Gia_LutForEachFanin( p, ObjId, FaninId, jth_fanin ){
+      // re-arrange SOPs as luts values across multiple iterations for each fanin
+      iii = -1;
+      validNum = -1;
+      _valid_vecs = *netValid;
+      char valuesFanin1s = 0;
+      char valuesFaninDCs = 0;
+      while (_valid_vecs > 0){
+        iii++;
+        if( (_valid_vecs & 1) == 0){
+          _valid_vecs = _valid_vecs >> 1;
+          continue;
+        }
+        validNum++;
+        char mask_fanin = 1 << jth_fanin;
+
+        pSop = (char *) Vec_PtrEntry(vSops, validNum);
+        char pSop1s = *pSop;
+        pSop++;
+        char pSopDCs = *pSop;
+        valuesFanin1s |= ( (pSop1s & mask_fanin) >> jth_fanin) << iii;
+        valuesFaninDCs |= ( (pSopDCs & mask_fanin) >> jth_fanin) << iii;
+        _valid_vecs = _valid_vecs >> 1;
+      }
+
+      // compute the values of the fanin
+      char prevNetValue = networkValues1s[FaninId];
+      char prevNetValueNotSet = networkValuesNotSet[FaninId];
+      char values2propagate = ~valuesFaninDCs & *netValid &  prevNetValueNotSet;
+      networkValues1s[FaninId] |= valuesFanin1s & values2propagate;
+      networkValuesNotSet[FaninId] &= valuesFaninDCs & *netValid;   
+
+      if(values2propagate == 0){
+        continue; // no value 2 propagate
+      }
+
+      // apply implications
+      char tmp_values2propagate = values2propagate;
+      int status;
+      char difference_valid;
+      if(experimentID > 1){
+        clock_t start_time = clock();
+        status = executeImplications(p, pPars, &values2propagate, FaninId, networkValues1s, networkValuesNotSet , vLutsFaninCones, vNodesWatchlist , experimentID);
+        pPars->fImplicationTime += (float)(clock() - start_time)/CLOCKS_PER_SEC;
+        if( status == -1){
+          networkValues1s[FaninId] = prevNetValue;
+          networkValuesNotSet[FaninId] = prevNetValueNotSet;
+          Vec_PtrFree( vSops );
+          return -1;
+        }
+        assert( tmp_values2propagate >= values2propagate );
+        // remove the values that are not valid
+        difference_valid = tmp_values2propagate ^ values2propagate;
+        if( difference_valid ){
+          // some values are not valid 
+          networkValuesNotSet[FaninId] &= ~difference_valid;
+          *netValid &= ~difference_valid;
+          // update also the validity signal and corresponding values
+          values2propagate = ~valuesFaninDCs & *netValid &  prevNetValueNotSet;
+          networkValues1s[FaninId] |= valuesFanin1s & values2propagate;
+          networkValuesNotSet[FaninId] &= valuesFaninDCs & *netValid;  
+          tmp_values2propagate = values2propagate;
+        }
+        values2propagate = tmp_values2propagate;
+        if(values2propagate == 0){
+          continue; // no value 2 propagate
+        }
+      }
+
+      if( !Gia_ObjIsCi( Gia_ManObj(p, FaninId) ) ){   
+        //printf("***********************\n");
+        //printInfoLutValues( p, ObjId, netValid, lutValues1s, networkValues1s, networkValuesNotSet);
+        status = computeNetworkValues(p, pPars, FaninId, &values2propagate, valuesFanin1s, networkValues1s, networkValuesNotSet, modifiedLuts, vLutsFaninCones, vNodesWatchlist , experimentID);
+        if(status == -1){
+          networkValues1s[FaninId] = prevNetValue;
+          networkValuesNotSet[FaninId] = prevNetValueNotSet;
+          Vec_PtrFree( vSops );
+          return -1;
+        }
+        assert( tmp_values2propagate >= values2propagate );
+        difference_valid = tmp_values2propagate ^ values2propagate;
+        if( difference_valid ){
+          // some values are not valid 
+          networkValuesNotSet[FaninId] &= ~difference_valid;
+          *netValid &= ~difference_valid;
+        }
+      }
+    }
+
+    Vec_PtrFree( vSops );
+
+    return 1;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Set values of primary inputs.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+void saveInputVectors( Gia_Man_t * p, Cec4_Man_t * pMan, char * pValues){
+
+    int i, Id, w;
+    Gia_ManForEachCiId( p, Id, i ){
+        word * pSim = Cec4_ObjSim( p, Id );
+        for ( w = 0; w < p->nSimWords; w++ )
+            pSim[w] = (word)pValues[ Id ];
+        pSim[0] <<= 1;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Export Simulation values.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void exportSimValues( Gia_Man_t * p, char * filename )
+{
+    FILE * pFile;
+    pFile = fopen( filename, "wb" );
+    Gia_Obj_t * pObj; int i, j;
+    Gia_ManForEachObj( p, pObj, i )
+    {
+        word * pSim  = Cec4_ObjSim( p, i );
+        fprintf( pFile, "Obj %d ", i );
+        for(j = 0; j < p->nSimWords; j++){
+          fprintf( pFile, "[%d]: %lu ", j, pSim[j] );
+        }
+        fprintf(pFile, "\n");
+    }
+    fclose( pFile );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Compute Input Vectors using SimGen.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+************************************************************************/
+
+int computeInputVectors(Gia_Man_t * p, Cec4_Man_t * pMan, Cec_ParSimGen_t * pPars , Vec_Int_t * vLuts , char * outGold, int outGold_bitwidth , Vec_Int_t * vLutsFaninCones , Vec_Ptr_t * vNodesWatchlist , Vec_Ptr_t * vSimSave ,int experimentID){
+
+    char * networkValues1s, * networkValuesNotSet; // data structure containing the values inside the network
+    char networkValid = (char) (1 << outGold_bitwidth) - 1; // keeps track which array out of the 8 is valid
+    int jLut, mainLoop_condition, iii, numLuts;
+    
+    numLuts = Vec_IntSize(vLuts);
+    assert(numLuts > 0);
+
+    networkValues1s = (char *) malloc( Gia_ManObjNum(p));
+    memset(networkValues1s, 0, sizeof(char) * Gia_ManObjNum(p));
+    networkValuesNotSet = (char *) malloc( Gia_ManObjNum(p));
+    memset(networkValuesNotSet, 0xFF, sizeof(char) * Gia_ManObjNum(p));
+    mainLoop_condition = numLuts > 0;
+    iii = 0;
+    int success = 0, lastjGold = -1;
+    while ( mainLoop_condition ){
+      jLut = Vec_IntEntry(vLuts, iii);
+      char jLutGold = outGold[jLut];
+
+      // TODO: Dynamic outgold
+
+      // check if the value of the lut has been set already or not 
+      char lutValueNotSet = networkValuesNotSet[jLut];
+      char lutValues1s = networkValues1s[jLut];
+      if( lutValueNotSet & networkValid){
+
+        char netValid = networkValid & lutValueNotSet;
+        char * networkValues1sCopy = (char *) malloc( Gia_ManObjNum(p));
+        memcpy(networkValues1sCopy, networkValues1s, sizeof(char) * Gia_ManObjNum(p));
+        char * networkValuesNotSetCopy = (char *) malloc( Gia_ManObjNum(p));
+        memcpy(networkValuesNotSetCopy, networkValuesNotSet, sizeof(char) * Gia_ManObjNum(p));
+        Vec_Int_t * modifiedLuts = Vec_IntAlloc( Gia_ManLutNum(p) );
+        // add the first lut to the modified luts
+        Vec_IntPush(modifiedLuts, jLut);
+        networkValues1sCopy[jLut] |= jLutGold & netValid;
+        networkValuesNotSetCopy[jLut] &= ~netValid;
+        // traverse the graph to retrieve values in the middle of the network
+        int status = computeNetworkValues(p, pPars, jLut , &netValid, jLutGold, networkValues1sCopy, networkValuesNotSetCopy, modifiedLuts, vLutsFaninCones, vNodesWatchlist , experimentID);
+        if( status == -1 ){
+          Vec_IntFree(modifiedLuts);
+          free(networkValues1sCopy);
+          free(networkValuesNotSetCopy);
+          goto exit_cond;
+        }
+
+        char orig_netValid = networkValid & lutValueNotSet;
+        char difference_valid = orig_netValid ^ netValid;
+        if( difference_valid == orig_netValid){
+          if(pPars->fVeryVerbose)
+            printf("FAILED 0 out of %d - node %d (gold = %d valid = %d)\n", outGold_bitwidth, jLut, jLutGold, netValid);
+        } else if( difference_valid != 0){
+          int jjj = 0, iLut;
+          Vec_IntForEachEntry( modifiedLuts, iLut, jjj ){
+            networkValues1sCopy[jLut] = networkValues1s[iLut];
+            networkValuesNotSetCopy[jLut] = networkValuesNotSet[iLut];
+          }
+          memcpy(networkValues1s, networkValues1sCopy, sizeof(char) * Gia_ManObjNum(p));
+          memcpy(networkValuesNotSet, networkValuesNotSetCopy, sizeof(char) * Gia_ManObjNum(p));
+
+          int different = 0;
+          while (difference_valid != 0) {
+            if (difference_valid & 1) {
+              different++;
+            }
+            difference_valid >>= 1;
+          }
+          if( outGold_bitwidth - different >= 2){ // at least 2 bits should be respected
+            if(lastjGold != jLutGold){
+              success += 1;
+              lastjGold = jLutGold;
+            }
+          }
+          if(pPars->fVeryVerbose)
+            printf("SUCCESSFUL %d out of %d - node %d (gold = %d valid = %d)\n", outGold_bitwidth - different, outGold_bitwidth, jLut, jLutGold, netValid);
+        } else {
+          if(lastjGold != jLutGold){
+            success += 1;
+            lastjGold = jLutGold;
+          }
+          memcpy(networkValues1s, networkValues1sCopy, sizeof(char) * Gia_ManObjNum(p));
+          memcpy(networkValuesNotSet, networkValuesNotSetCopy, sizeof(char) * Gia_ManObjNum(p));
+          if(pPars->fVeryVerbose)
+            printf("SUCCESSFUL %d out of %d - node %d (gold = %d valid = %d)\n", outGold_bitwidth, outGold_bitwidth, jLut, jLutGold, netValid);
+        }
+
+
+        free(networkValues1sCopy);
+        free(networkValuesNotSetCopy);
+        Vec_IntFree(modifiedLuts);
+        
+
+      } else { // all the different values that are still valid have been set
+        char luts_values = lutValues1s & networkValid;
+        char out_gold_values = jLutGold & networkValid;        
+        char validAssignments = ~( luts_values ^ out_gold_values ) & networkValid;
+        char numOnes = 0;
+        if (validAssignments != 0){
+          while (validAssignments != 0) {
+            if (validAssignments & 1) {
+              numOnes++;
+            }
+            validAssignments >>= 1;
+          }
+        }
+        validAssignments = ~( luts_values ^ out_gold_values ) & networkValid;
+        if(pPars->fVeryVerbose)
+          printf("(1) SUCCESSFUL %d out of %d - node %d (gold = %d valid = %d)\n", numOnes, outGold_bitwidth, jLut, jLutGold, validAssignments);
+      }
+
+      iii++;
+      mainLoop_condition = (iii < numLuts);
+    }
+
+    if(success >= 2){
+      saveInputVectors(p, pMan, networkValues1s);
+      Cec4_ManSimulate( p, pMan );
+      // saving the pi simulation values in a compacted format
+      int jth_word = p->iData & 0xFFFF;
+      int kth_bit = (p->iData & 0xFFFF0000) >> 16; 
+      if( kth_bit + outGold_bitwidth >= 64 ){
+        kth_bit = 0;
+        jth_word += 1;
+      }
+      saveSimVectors(p, vSimSave, outGold_bitwidth, jth_word, kth_bit);
+      kth_bit += outGold_bitwidth;
+      p->iData = (kth_bit << 16) | jth_word;
+      if( pPars->fVerbose || pPars->fVeryVerbose){
+        printf("**Exporting simulation values in file sim_values.txt\n");
+        exportSimValues( p, "sim_values.txt" );
+      }
+    }
+
+
+exit_cond:
+    free(networkValues1s);
+    free(networkValuesNotSet);
+
+    if(success < 2){
+      return -1;
+    } else {
+      return 1;
+    }
+
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Core function of SimGen.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+***********************************************************************/
+
+
+void executeControlledSim(Gia_Man_t * p, Cec4_Man_t * pMan, Cec_ParSimGen_t * pPars , int levelOrder, Vec_Ptr_t * vSimSave, int experimentID){
+
+    char * outGold;
+    //int outGold_bitwidth = pPars->bitwidthOutgold;
+    int numClasses = totalNumClasses(p);
+    int iTrials = 0, outer_loop_condition = iTrials < (numClasses * 1.5); 
+    int nthClass = 0, status, oldNumClasses = numClasses, iter;
+    Vec_Int_t * luts_order, * vecTmp;
+    Vec_Int_t * vLutsFaninCones;
+    clock_t start_time = clock();
+    outGold = generateOutGoldValues(p); // generate the first outgold values
+    pPars->outGold = outGold;
+    Vec_Ptr_t * vNodesWatchList = NULL; 
+    if(pPars->fUseWatchlist){
+      printf("**Activating watchlist feauture\n");
+    }
+    while( existsOneClass(p) && outer_loop_condition ){
+      luts_order = extractNthClass(p, nthClass);
+      if( levelOrder != -1 ){
+        // test different luts orders on which to apply simgen
+        luts_order = computeLutsOrder(p, 1); // incresing level order // TODO: redo taking luts_order as input
+      }
+      // compute the fanin cones of the luts to apply implication only in the cone
+      vLutsFaninCones = computeFaninCones( p, luts_order );
+      if(pPars->fUseWatchlist){
+        vNodesWatchList = generateWatchList(p);
+      }
+      status = computeInputVectors(p, pMan, pPars, luts_order, outGold, pPars->bitwidthOutgold, vLutsFaninCones, vNodesWatchList, vSimSave, experimentID);
+      if( status == -1 ){
+        if(pPars->fVerbose || pPars->fVeryVerbose)
+          printf("FAILED - no valid input vectors found for class %d\n", nthClass);
+        nthClass++;
+      } else {
+        numClasses = totalNumClasses(p);
+        if (oldNumClasses == numClasses){
+          nthClass++;
+        }
+        oldNumClasses = numClasses;
+        free(outGold);
+        outGold = generateOutGoldValues(p); // generate a new outgold since the classes are updated
+        pPars->outGold = outGold;
+        if(pPars->fVerbose || pPars->fVeryVerbose)
+          printf("SUCCESSFUL - input vectors found for class %d\n", nthClass);
+        //nthClass = 0;
+      }
+
+      Vec_IntFree(vLutsFaninCones);
+      Vec_IntFree(luts_order);
+      if(pPars->fUseWatchlist){
+        Vec_PtrForEachEntry( Vec_Int_t *, vNodesWatchList, vecTmp, iter ){
+          if (vecTmp != NULL)
+            Vec_IntFree(vecTmp);        
+        }
+        Vec_PtrFree(vNodesWatchList);
+      }
+      if(nthClass >= numClasses){
+        nthClass = 0;
+        if (oldNumClasses == numClasses){
+          iTrials++;
+        } 
+        oldNumClasses = numClasses;
+        iTrials++;
+      }
+      outer_loop_condition = iTrials < 3; 
+      clock_t end_time = clock();
+      if ( (float)(end_time - start_time)/CLOCKS_PER_SEC > pPars->timeOutSim){ // hard limit of 1000 sec
+        printf("Timeout of %f sec reached\n", pPars->timeOutSim);
+        break;
+      }
+      if(pPars->fVerbose || pPars->fVeryVerbose){
+        int quality = evaluate_equiv_classes(p, 0);
+        printf("Time elapsed: %f (classes quality: %d)\n", (float)(clock() - start_time)/CLOCKS_PER_SEC, quality);
+      }
+    }
+
+    //drawNetworkGia( p, "network.dot");
+    //drawConeNetworkGia( p, "cone_network.dot", 31);
+
+    free(outGold);
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Call SAT solver.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void Cec4_CallSATsolver(Gia_Man_t * p, Cec4_Man_t * pMan, Cec_ParFra_t * pPars){
+
+    extern Gia_Obj_t *  Cec4_ManFindRepr( Gia_Man_t * p, Cec4_Man_t * pMan, int iObj );
+    int i;
+    Gia_Obj_t * pObj, * pRepr; 
+    p->iPatsPi = 0;
+    Vec_WrdFill( p->vSimsPi, Vec_WrdSize(p->vSimsPi), 0 );
+    pMan->nSatSat = 0;
+    pMan->pNew = Cec4_ManStartNew( p );
+    Gia_ManForEachAnd( p, pObj, i )
+    {
+        Gia_Obj_t * pObjNew; 
+        pMan->nAndNodes++;
+        if ( Gia_ObjIsXor(pObj) )
+            pObj->Value = Gia_ManHashXorReal( pMan->pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
+        else
+            pObj->Value = Gia_ManHashAnd( pMan->pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
+        if ( pPars->nLevelMax && Gia_ObjLevel(p, pObj) > pPars->nLevelMax )
+            continue;
+        pObjNew = Gia_ManObj( pMan->pNew, Abc_Lit2Var(pObj->Value) );
+        if ( Gia_ObjIsAnd(pObjNew) )
+        if ( Vec_BitEntry(pMan->vFails, Gia_ObjFaninId0(pObjNew, Abc_Lit2Var(pObj->Value))) || 
+             Vec_BitEntry(pMan->vFails, Gia_ObjFaninId1(pObjNew, Abc_Lit2Var(pObj->Value))) )
+            Vec_BitWriteEntry( pMan->vFails, Abc_Lit2Var(pObjNew->Value), 1 );
+        //if ( Gia_ObjIsAnd(pObjNew) )
+        //    Gia_ObjSetAndLevel( pMan->pNew, pObjNew );
+        // select representative based on candidate equivalence classes
+        pRepr= Gia_ObjReprObj( p, i );
+        if ( pRepr == NULL )
+            continue; 
+        if ( 1 ) // select representative based on recent counter-examples
+        {
+            pRepr = (Gia_Obj_t *) Cec4_ManFindRepr( p, pMan, i );
+            if ( pRepr == NULL )
+                continue;
+        }
+        int id_obj = Gia_ObjId( p, pObj );
+        int id_repr = Gia_ObjId( p, pRepr );
+
+        if ( Abc_Lit2Var(pObj->Value) == Abc_Lit2Var(pRepr->Value))
+        {
+            if ( pPars->fBMiterInfo ) 
+            {
+                Bnd_ManMerge( id_repr, id_obj, pObj->fPhase ^ pRepr->fPhase );
+            }
+            if((pObj->Value ^ pRepr->Value) != (pObj->fPhase ^ pRepr->fPhase)){
+              pObj->Value = Abc_LitNotCond( pRepr->Value, pObj->fPhase ^ pRepr->fPhase );
+            }
+            assert( (pObj->Value ^ pRepr->Value) == (pObj->fPhase ^ pRepr->fPhase) );
+            Gia_ObjSetProved( p, i );
+            if ( Gia_ObjId(p, pRepr) == 0 )
+                pMan->iLastConst = i;
+            continue;
+        }
+        if ( Cec4_ManSweepNode(pMan, i, Gia_ObjId(p, pRepr)) && Gia_ObjProved(p, i) )
+        {
+            if (pPars->fBMiterInfo){
+
+                Bnd_ManMerge( id_repr, id_obj, pObj->fPhase ^ pRepr->fPhase );
+                // printf( "proven %d merged into %d (phase : %d)\n", Gia_ObjId(p, pObj), Gia_ObjId(p,pRepr), pObj->fPhase ^ pRepr -> fPhase );
+
+            }
+            pObj->Value = Abc_LitNotCond( pRepr->Value, pObj->fPhase ^ pRepr->fPhase );
+
+
+        }
+    }
+
+    printf( "SAT calls = %d:  P = %d (0=%d a=%.2f m=%d)  D = %d (0=%d a=%.2f m=%d)  F = %d   Sim = %d  Recyc = %d  Xor = %.2f %%\n", 
+            pMan->nSatUnsat + pMan->nSatSat + pMan->nSatUndec, 
+            pMan->nSatUnsat, pMan->nConflicts[1][0], (float)pMan->nConflicts[1][1]/Abc_MaxInt(1, pMan->nSatUnsat-pMan->nConflicts[1][0]), pMan->nConflicts[1][2],
+            pMan->nSatSat,   pMan->nConflicts[0][0], (float)pMan->nConflicts[0][1]/Abc_MaxInt(1, pMan->nSatSat  -pMan->nConflicts[0][0]), pMan->nConflicts[0][2],  
+            pMan->nSatUndec,  
+            pMan->nSimulates, pMan->nRecycles, 100.0*pMan->nGates[1]/Abc_MaxInt(1, pMan->nGates[0]+pMan->nGates[1]) );
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Print encoded cube.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void printEncodedCube( char pCube, char pDCs, int nFanins ){
+
+    int i;
+    for (i = 0; i < nFanins; i++){
+      if ( pCube & (1 << i) )
+        printf("1");
+      else if ( pDCs & (1 << i) )
+        printf("-");
+      else
+        printf("0");
+    }
+    printf("\n");
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Print ISOP.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void printISOP( char * pSop, int nCubes, int nFanins ){
+
+    int jth_cube = 0;
+    while (jth_cube < nCubes){
+      char pCube =  *pSop; pSop++;
+      char pDCs =  *pSop; pSop++;
+      printEncodedCube( pCube, pDCs, nFanins );
+      jth_cube++;
+    }
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Print ISOP LUT.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+
+void printISOPLUT(Gia_Man_t * pMan, int ObjId){
+
+    assert( Gia_ObjIsLut(pMan, ObjId));
+    char * pSop[2]; int nCubes[2];
+    getISOPObjId( pMan, ObjId, pSop, nCubes );
+    printf("Negative Polarity\n");
+    printISOP( pSop[0], nCubes[0], Gia_ObjLutSize(pMan, ObjId) );
+    printf("Positive Polarity\n");
+    printISOP( pSop[1], nCubes[1], Gia_ObjLutSize(pMan, ObjId) );
+
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Execute SimGen.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+***********************************************************************/
+
+Gia_Man_t * Cec_SimGenRun( Gia_Man_t * p, Cec_ParSimGen_t * pPars ){
+
+    extern void Gia_ManDupMapping( Gia_Man_t * pNew, Gia_Man_t * p );
+    Cec4_Man_t * pManSim;  
+    int i, k, nWordsPerCi;
+    Gia_Man_t * pMapped;
+    Vec_Ptr_t * vSimPisSave;
+    Cec_ParFra_t * pCECPars;
+
+    if (!Gia_ManHasMapping(p)){
+      // apply technology mapping if not already done
+      If_Par_t IfPars, * pIfPars = &IfPars;
+      Gia_ManSetIfParsDefault( pIfPars );
+      pIfPars->nLutSize = 6;
+      pMapped = Gia_ManPerformMapping( p, pIfPars );
+      if(pPars->fVerbose)
+        printf("Performing LUT-mapping\n");
+    } else {
+      pMapped = Gia_ManDup( p );
+      Gia_ManDupMapping( pMapped, p );
+      if(pPars->fVerbose)
+        printf("Using already mapped network\n");
+    }
+    pCECPars = (Cec_ParFra_t *) malloc(sizeof( Cec_ParFra_t )); // parameters of CEC
+    pManSim = Cec4_ManCreate( pMapped, pCECPars );
+    pManSim->pPars->fVerbose = 0; // disabling verbose sat solver
+
+    Cec_DeriveSOPs( pMapped );
+
+    /*
+    if (pPars->fVeryVerbose)
+    {    
+      printf("**Printing LUTs information**\n");
+      Gia_ManForEachLut( pMapped, i ){
+        printf("LUT %d\n", i);
+        Gia_LutForEachFanin( pMapped, i, iFan, k ){
+          printf("\tFANIN %d\n", iFan);
+        }
+        printISOPLUT( pMapped, i );
+      }
+    }
+    */
+
+    // compute MFFCs
+    Gia_ManLevelNum( pMapped); // compute levels
+    computeMFFCs( pMapped );
+    if (pPars->fUseWatchlist) {
+      generateLutsRankings( pMapped );
+    }
+    
+
+    // generate vectors of fanouts
+    Gia_generateFanoutMapping( pMapped );
+
+    pMapped->nSimWords = (int) pPars->nSimWords ;
+    vSimPisSave = Vec_PtrAlloc( Gia_ManCiNum(pMapped) );
+    for ( i = 0; i < Gia_ManCiNum(pMapped); i++ ){
+      Vec_Wrd_t * vSim = Vec_WrdAlloc( pMapped->nSimWords );
+      Vec_PtrPush( vSimPisSave, vSim );
+    }
+    // simulate n rounds of random simulation and create classes      
+    Cec4_ManSimAlloc( pMapped, pMapped->nSimWords );
+    if(pPars->nMaxIter >= 0){
+      executeRandomSim( pMapped, pManSim, 0, pPars->nMaxIter, vSimPisSave, pPars->fVeryVerbose);
+    } else if (pPars->nMaxIter == -1){
+      executeRandomSim( pMapped, pManSim, 1, pPars->nMaxIter, vSimPisSave, pPars->fVeryVerbose);
+    } else {
+      printf("Invalid number of iterations %d\n", pPars->nMaxIter);
+      return NULL;
+    }
+
+    // extra data to compact multiple pi values in single words
+    pMapped->iData = ((Vec_Wrd_t *)Vec_PtrEntry( vSimPisSave, 0 ))->nSize; // [0:15] number of words filled
+                         // [16:31] number of bits filled in the iData word
+    assert(pMapped->iData > 0);
+
+    Cec_RemoveNonLutNodes( pMapped ); // remove all the non-LUT nodes from the equivalence classes
+    
+    if(pPars->fVerbose || pPars->fVeryVerbose){
+      // IMPORTANT: the number of classes changes due to the previous operation
+      evaluate_equiv_classes(pMapped, 1);
+      printf("**Printing Class information before running the Sim algos in file pre_classes.txt**\n");
+      exportEquivClasses(pMapped, "pre_classes.txt");
+    }
+    //Cec4_ManPrintClasses2(pMapped);
+    clock_t begin = clock();      
+    assert(pPars->expId > 0);
+    executeControlledSim( pMapped, pManSim, pPars, -1 , vSimPisSave, pPars->expId );
+    
+    float implicationSuccessRate = (float)pPars->nImplicationSuccess / (float)pPars->nImplicationExecution;
+    float implicationSuccessCheckRate = (float)pPars->nImplicationSuccessChecks / (float)pPars->nImplicationTotalChecks;
+    printf("Time elapsed: %f (implication time %f - %f successful recursions - %f successful checks)\n", (double)(clock() - begin) / CLOCKS_PER_SEC, pPars->fImplicationTime, implicationSuccessRate, implicationSuccessCheckRate);
+
+    //Cec4_ManPrintClasses2(pMapped);
+    if(pPars->fVerbose || pPars->fVeryVerbose){
+      printf("**Printing Class information before running the Sim algos in file post_classes.txt**\n");
+      exportEquivClasses(pMapped, "post_classes.txt");
+      evaluate_equiv_classes(pMapped, 1);
+    }
+
+    // save random and controlled sim pis values
+    if(p->vSimsPi != NULL){
+      Vec_WrdFree( p->vSimsPi );
+    } 
+    nWordsPerCi = ((Vec_Wrd_t *)Vec_PtrEntry( vSimPisSave, 0 ))->nSize;
+    assert( nWordsPerCi > 0 );
+    p->vSimsPi = Vec_WrdStart( Gia_ManCiNum(p) * nWordsPerCi );
+
+    // copy the sim pis
+    assert( Gia_ManCiNum(p) == Vec_PtrSize(vSimPisSave) );
+    for (i = 0; i < Gia_ManCiNum(p); i++){
+      Vec_Wrd_t * vSim = (Vec_Wrd_t *)Vec_PtrEntry( vSimPisSave, i );
+      assert( vSim->nSize == nWordsPerCi );
+      word * pSim = Vec_WrdEntryP( p->vSimsPi, i * nWordsPerCi );
+      for ( k = 0; k < nWordsPerCi; k++ )
+        pSim[k] = Vec_WrdEntry( vSim, k );
+    }
+    p->nSimWords = nWordsPerCi;
+
+    if (pPars->pFileName != NULL){
+      Vec_WrdDumpHex( pPars->pFileName, p->vSimsPi, nWordsPerCi , 1 );
+    }
+
+    // free memory
+    Vec_IntFree( pMapped->vTTLut );
+    Vec_StrFree( pMapped->vTTISOPs );
+    Cec4_ManDestroy( pManSim );
+    Gia_ManStop( pMapped );
+
+    return p;
+}
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/proof/cec/cecSatG3.c b/src/proof/cec/cecSatG3.c
index 58696310b..133bf4a90 100644
--- a/src/proof/cec/cecSatG3.c
+++ b/src/proof/cec/cecSatG3.c
@@ -2120,7 +2120,7 @@ finalize:
         CbsP_ManStop(pCbs);
     //Gia_ManStaticFanoutStop( p );
     //Gia_ManEquivPrintClasses( p, 1, 0 );
-    Gia_ManRemoveWrongChoices( p );
+    if ( p->pNexts ) Gia_ManRemoveWrongChoices( p );
     return p->pCexSeq ? 0 : 1;
 }
 Gia_Man_t * Cec5_ManSimulateTest( Gia_Man_t * p, Cec_ParFra_t * pPars, int fCbs, int approxLim, int subBatchSz, int adaRecycle )
diff --git a/src/proof/ssw/ssw.h b/src/proof/ssw/ssw.h
index 7299e37d1..bb4ff7594 100644
--- a/src/proof/ssw/ssw.h
+++ b/src/proof/ssw/ssw.h
@@ -74,6 +74,8 @@ struct Ssw_Pars_t_
     int              fEquivDump;    // enables dumping equivalences
     int              fEquivDump2;   // enables dumping equivalences
     int              fStopWhenGone; // stop when PO output is not a candidate constant
+    int              nSkip;
+    int              nSkipLimit;
     // optimized latch correspondence
     int              fLatchCorrOpt; // perform register correspondence (optimized)
     int              nSatVarMax;    // max number of SAT vars before recycling SAT solver (optimized latch corr only)
diff --git a/src/proof/ssw/sswAig.c b/src/proof/ssw/sswAig.c
index acd8f919f..247a614ae 100644
--- a/src/proof/ssw/sswAig.c
+++ b/src/proof/ssw/sswAig.c
@@ -75,6 +75,57 @@ void Ssw_FrmStop( Ssw_Frm_t * p )
     ABC_FREE( p );
 }
 
+/**Function*************************************************************
+
+  Synopsis    [Computes the size of two-output cone.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Aig_ObjDeref_rec( Aig_Obj_t * pNode )
+{
+    int Counter = 1;
+    assert( pNode->nRefs > 0 );
+    if ( --pNode->nRefs > 0 )
+        return 0;
+    assert( pNode->nRefs == 0 );
+    if ( Aig_ObjIsCi(pNode) || Aig_ObjIsConst1(pNode) )
+        return 0;
+    Counter += Aig_ObjDeref_rec( Aig_ObjFanin0(pNode) );
+    Counter += Aig_ObjDeref_rec( Aig_ObjFanin1(pNode) );
+    return Counter;
+}
+int Aig_ObjRef_rec( Aig_Obj_t * pNode )
+{
+    int Counter = 1;
+    assert( pNode->nRefs >= 0 );
+    if ( pNode->nRefs++ > 0 )
+        return 0;
+    assert( pNode->nRefs == 1 );
+    if ( Aig_ObjIsCi(pNode) || Aig_ObjIsConst1(pNode) )
+        return 0;
+    Counter += Aig_ObjRef_rec( Aig_ObjFanin0(pNode) );
+    Counter += Aig_ObjRef_rec( Aig_ObjFanin1(pNode) );
+    return Counter;
+}
+int Aig_ManConeSize( Aig_Obj_t * pNode0, Aig_Obj_t * pNode1 )
+{
+    pNode0 = Aig_Regular(pNode0);
+    pNode1 = Aig_Regular(pNode1);
+    Aig_ObjRef( pNode0 );
+    Aig_ObjRef( pNode1 );
+    int Count0 = Aig_ObjDeref_rec(pNode0) + Aig_ObjDeref_rec(pNode1);
+    int Count1 = Aig_ObjRef_rec(pNode0)   + Aig_ObjRef_rec(pNode1);   
+    Aig_ObjDeref( pNode0 );
+    Aig_ObjDeref( pNode1 );     
+    assert( Count0 == Count1 );
+    return Count0;
+}
+
 /**Function*************************************************************
 
   Synopsis    [Performs speculative reduction for one node.]
@@ -120,8 +171,16 @@ static inline void Ssw_FramesConstrainNode( Ssw_Man_t * p, Aig_Man_t * pFrames,
     // add the constraint
     if ( fTwoPos )
     {
-        Aig_ObjCreateCo( pFrames, pObjNew2 );
-        Aig_ObjCreateCo( pFrames, pObjNew );
+        if ( p->pPars->nSkipLimit ) {
+            if ( Aig_ManConeSize(pObjNew, pObjNew2) < p->pPars->nSkipLimit ) {
+                Aig_ObjCreateCo( pFrames, pObjNew2 );
+                Aig_ObjCreateCo( pFrames, pObjNew );
+            }
+        }
+        else if ( p->pPars->nSkip == 0 || rand() % p->pPars->nSkip == 0 ) {
+            Aig_ObjCreateCo( pFrames, pObjNew2 );
+            Aig_ObjCreateCo( pFrames, pObjNew );
+        }
     }
     else
     {
@@ -158,6 +217,8 @@ Aig_Man_t * Ssw_FramesWithClasses( Ssw_Man_t * p )
         Ssw_ObjSetFrame( p, pObj, 0, Aig_ObjCreateCi(pFrames) );
     // add timeframes
     iLits = 0;
+    if ( p->pPars->nSkip )
+        srand(1);
     for ( f = 0; f < p->pPars->nFramesK; f++ )
     {
         // map constants and PIs
@@ -189,7 +250,6 @@ Aig_Man_t * Ssw_FramesWithClasses( Ssw_Man_t * p )
     // add the POs for the latch outputs of the last frame
     Saig_ManForEachLo( p->pAig, pObj, i )
         Aig_ObjCreateCo( pFrames, Ssw_ObjFrame( p, pObj, p->pPars->nFramesK ) );
-
     // remove dangling nodes
     Aig_ManCleanup( pFrames );
     // make sure the satisfying assignment is node assigned
diff --git a/src/sat/bmc/bmc.h b/src/sat/bmc/bmc.h
index 795296e6f..92fbb7422 100644
--- a/src/sat/bmc/bmc.h
+++ b/src/sat/bmc/bmc.h
@@ -64,8 +64,11 @@ struct Bmc_EsPar_t_
     int        fUniqFans;
     int        fLutCascade;
     int        RuntimeLim;
+    int        nRandFuncs;
+    int        nMintNum;
     int        fVerbose; 
     char *     pTtStr;
+    char *     pSymStr;
 };
 
 static inline void Bmc_EsParSetDefault( Bmc_EsPar_t * pPars )
@@ -88,7 +91,7 @@ static inline void Bmc_EsParSetDefault( Bmc_EsPar_t * pPars )
     pPars->fUniqFans   = 0;
     pPars->fLutCascade = 0;
     pPars->RuntimeLim  = 0;
-    pPars->fVerbose    = 1; 
+    pPars->fVerbose    = 0; 
 }
 
 
diff --git a/src/sat/bmc/bmcMaj.c b/src/sat/bmc/bmcMaj.c
index b6ff80a58..68601338e 100644
--- a/src/sat/bmc/bmcMaj.c
+++ b/src/sat/bmc/bmcMaj.c
@@ -953,7 +953,7 @@ void Exa_ManExactSynthesis( Bmc_EsPar_t * pPars )
         }
         if ( status == GLUCOSE_UNDEC )
         {
-            printf( "The problem timed out after %d sec.\n", pPars->RuntimeLim );
+            printf( "The solver timed out after %d sec.\n", pPars->RuntimeLim );
             break;
         }
         iMint = Exa_ManEval( p );
@@ -1499,12 +1499,22 @@ void Exa3_ManPrint( Exa3_Man_t * p, int i, int iMint, abctime clk )
     printf( "Conf =%9d  ", bmcg_sat_solver_conflictnum(p->pSat) );
     Abc_PrintTime( 1, "Time", clk );
 }
-void Exa3_ManExactSynthesis( Bmc_EsPar_t * pPars )
+int Exa3_ManExactSynthesis( Bmc_EsPar_t * pPars )
 {
-    int i, status, iMint = 1;
+    int i, status, Res = 0, iMint = 1;
     abctime clkTotal = Abc_Clock();
     Exa3_Man_t * p; int fCompl = 0;
-    word pTruth[16]; Abc_TtReadHex( pTruth, pPars->pTtStr );
+    word pTruth[16]; 
+    if ( pPars->pSymStr ) {
+        word * pFun = Abc_TtSymFunGenerate( pPars->pSymStr, pPars->nVars );
+        pPars->pTtStr = ABC_CALLOC( char, pPars->nVars > 2 ? (1 << (pPars->nVars-2)) + 1 : 2 );
+        Extra_PrintHexadecimalString( pPars->pTtStr, (unsigned *)pFun, pPars->nVars );
+        printf( "Generated symmetric function: %s\n", pPars->pTtStr );
+        ABC_FREE( pFun );
+    }
+    if ( pPars->pTtStr )
+        Abc_TtReadHex( pTruth, pPars->pTtStr );
+    else assert( 0 );
     assert( pPars->nVars <= 10 );
     assert( pPars->nLutSize <= 6 );
     p = Exa3_ManAlloc( pPars, pTruth );
@@ -1532,17 +1542,54 @@ void Exa3_ManExactSynthesis( Bmc_EsPar_t * pPars )
     if ( pPars->fVerbose && status != GLUCOSE_UNDEC )
         Exa3_ManPrint( p, i, iMint, Abc_Clock() - clkTotal );
     if ( iMint == -1 )
-        Exa3_ManPrintSolution( p, fCompl );
+        Exa3_ManPrintSolution( p, fCompl ), Res = 1;
     else if ( status == GLUCOSE_UNDEC )
-        printf( "The problem timed out after %d sec.\n", pPars->RuntimeLim );
+        printf( "The solver timed out after %d sec.\n", pPars->RuntimeLim );
     else 
         printf( "The problem has no solution.\n" );
     printf( "Added = %d.  Tried = %d.  ", p->nUsed[1], p->nUsed[0] );
     Abc_PrintTime( 1, "Total runtime", Abc_Clock() - clkTotal );
     if ( iMint == -1 )
         Exa3_ManDumpBlif( p, fCompl );
+    if ( pPars->pSymStr ) 
+        ABC_FREE( pPars->pTtStr );
     Exa3_ManFree( p );
+    return Res;
 }
+void Exa3_ManExactSynthesisRand( Bmc_EsPar_t * pPars )
+{
+    int i, k, nDecs = 0, nWords = Abc_TtWordNum(pPars->nVars);
+    word * pFun = ABC_ALLOC( word, nWords );
+    Abc_Random(1);
+    printf( "\n" );
+    for ( i = 0; i < pPars->nRandFuncs; i++ ) {
+        if ( pPars->nMintNum == 0 )
+            for ( k = 0; k < nWords; k++ )
+                pFun[k] = Abc_RandomW(0);
+        else {
+            Abc_TtClear( pFun, nWords );
+            for ( k = 0; k < pPars->nMintNum; k++ ) {
+                int iMint = 0;
+                do iMint = Abc_Random(0) % (1 << pPars->nVars);
+                while ( Abc_TtGetBit(pFun, iMint) );
+                Abc_TtSetBit( pFun, iMint );
+            }
+        }
+        pPars->pTtStr = ABC_CALLOC( char, pPars->nVars > 2 ? (1 << (pPars->nVars-2)) + 1 : 2 );
+        Extra_PrintHexadecimalString( pPars->pTtStr, (unsigned *)pFun, pPars->nVars );
+        printf( "\nIteration %d : ", i );
+        if ( pPars->nMintNum )
+            printf( "Random function has %d positive minterms.", pPars->nMintNum );
+        printf( "\n" );
+        if ( pPars->fVerbose )
+            printf( "Truth table : %s\n", pPars->pTtStr );
+        nDecs += Exa3_ManExactSynthesis( pPars );
+        ABC_FREE( pPars->pTtStr );
+    }
+    printf( "Decomposable are %d (out of %d) functions (%.2f %%).\n", nDecs, pPars->nRandFuncs, 100.0*nDecs/pPars->nRandFuncs );
+    ABC_FREE( pFun );
+}
+
 
 /**Function*************************************************************
 
diff --git a/src/sat/bmc/bmcMaj2.c b/src/sat/bmc/bmcMaj2.c
index 8becc6321..665b61611 100644
--- a/src/sat/bmc/bmcMaj2.c
+++ b/src/sat/bmc/bmcMaj2.c
@@ -1387,7 +1387,17 @@ void Exa3_ManExactSynthesis2( Bmc_EsPar_t * pPars )
     int i, status, iMint = 1;
     abctime clkTotal = Abc_Clock();
     Exa3_Man_t * p; int fCompl = 0;
-    word pTruth[16]; Abc_TtReadHex( pTruth, pPars->pTtStr );
+    word pTruth[16];
+    if ( pPars->pSymStr ) {
+        word * pFun = Abc_TtSymFunGenerate( pPars->pSymStr, pPars->nVars );
+        pPars->pTtStr = ABC_CALLOC( char, pPars->nVars > 2 ? (1 << (pPars->nVars-2)) + 1 : 2 );
+        Extra_PrintHexadecimalString( pPars->pTtStr, (unsigned *)pFun, pPars->nVars );
+        printf( "Generated symmetric function: %s\n", pPars->pTtStr );
+        ABC_FREE( pFun );
+    }    
+    if ( pPars->pTtStr )
+        Abc_TtReadHex( pTruth, pPars->pTtStr );
+    else assert( 0 );    
     assert( pPars->nVars <= 10 );
     assert( pPars->nLutSize <= 6 );
     p = Exa3_ManAlloc( pPars, pTruth );
@@ -1422,6 +1432,8 @@ void Exa3_ManExactSynthesis2( Bmc_EsPar_t * pPars )
     Abc_PrintTime( 1, "Total runtime", Abc_Clock() - clkTotal );
     if ( iMint == -1 )
         Exa3_ManDumpBlif( p, fCompl );
+    if ( pPars->pSymStr ) 
+        ABC_FREE( pPars->pTtStr );
     Exa3_ManFree( p );
 }
 
diff --git a/src/sat/bsat/satSolver.c b/src/sat/bsat/satSolver.c
index eea280293..6b246a2e6 100644
--- a/src/sat/bsat/satSolver.c
+++ b/src/sat/bsat/satSolver.c
@@ -60,9 +60,10 @@ static void printlits(lit* begin, lit* end)
 static inline double drand(double* seed) {
     int q;
     *seed *= 1389796;
-    q = (int)(*seed / 2147483647);
+    q = (int)(*seed * 4.6566128752457969e-10); // 1.0/2147483647.0;
     *seed -= (double)q * 2147483647;
-    return *seed / 2147483647; }
+    return *seed * 4.6566128752457969e-10; // 1.0/2147483647.0
+}
 
 
 // Returns a random integer 0 <= x < size. Seed must never be 0.
@@ -1954,12 +1955,12 @@ int sat_solver_solve_internal(sat_solver* s)
 
     while (status == l_Undef){
         ABC_INT64_T nof_conflicts;
-        double Ratio = (s->stats.learnts == 0)? 0.0 :
-            s->stats.learnts_literals / (double)s->stats.learnts;
         if ( s->nRuntimeLimit && Abc_Clock() > s->nRuntimeLimit )
             break;
         if (s->verbosity >= 1)
         {
+            double Ratio = (s->stats.learnts == 0)? 0.0 :
+                s->stats.learnts_literals / (double)s->stats.learnts;
             printf("| %9.0f | %7.0f %8.0f | %7.0f %7.0f %8.0f %7.1f | %6.3f %% |\n", 
                 (double)s->stats.conflicts,
                 (double)s->stats.clauses, 
diff --git a/src/sat/cadical/LICENSE b/src/sat/cadical/LICENSE
new file mode 100644
index 000000000..ead29d7a3
--- /dev/null
+++ b/src/sat/cadical/LICENSE
@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2016-2021 Armin Biere, Johannes Kepler University Linz, Austria
+Copyright (c) 2020-2021 Mathias Fleury, Johannes Kepler University Linz, Austria
+Copyright (c) 2020-2021 Nils Froleyks, Johannes Kepler University Linz, Austria
+Copyright (c) 2022-2024 Katalin Fazekas, Vienna University of Technology, Austria
+Copyright (c) 2021-2024 Armin Biere, University of Freiburg, Germany
+Copyright (c) 2021-2024 Mathias Fleury, University of Freiburg, Germany
+Copyright (c) 2023-2024 Florian Pollitt, University of Freiburg, Germany
+Copyright (c) 2024-2024 Tobias Faller, University of Freiburg, Germany
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/sat/cadical/VERSION b/src/sat/cadical/VERSION
new file mode 100644
index 000000000..a1bba8921
--- /dev/null
+++ b/src/sat/cadical/VERSION
@@ -0,0 +1 @@
+2.2.0-rc1
diff --git a/src/sat/cadical/arena.hpp b/src/sat/cadical/arena.hpp
new file mode 100644
index 000000000..522fce36e
--- /dev/null
+++ b/src/sat/cadical/arena.hpp
@@ -0,0 +1,111 @@
+#ifndef _arena_hpp_INCLUDED
+#define _arena_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// This memory allocation arena provides fixed size pre-allocated memory for
+// the moving garbage collector 'copy_non_garbage_clauses' in 'collect.cpp'
+// to hold clauses which should survive garbage collection.
+
+// The advantage of using a pre-allocated arena is that the allocation order
+// of the clauses can be adapted in such a way that clauses watched by the
+// same literal are allocated consecutively.  This improves locality during
+// propagation and thus is more cache friendly. A similar technique is
+// implemented in MiniSAT and Glucose and gives substantial speed-up in
+// propagations per second even though it might even almost double peek
+// memory usage.  Note that in MiniSAT this arena is actually required for
+// MiniSAT to be able to use 32 bit clauses references instead of 64 bit
+// pointers.  This would restrict the maximum number of clauses and thus is
+// a restriction we do not want to use anymore.
+
+// New learned clauses are allocated in CaDiCaL outside of this arena and
+// moved to the arena during garbage collection.  The additional 'to' space
+// required for such a moving garbage collector is only allocated for those
+// clauses surviving garbage collection, which usually needs much less
+// memory than all clauses.  The net effect is that in our implementation
+// the moving garbage collector using this arena only needs roughly 50% more
+// memory than allocating the clauses directly.  Both implementations can be
+// compared by varying the 'opts.arenatype' option (which also controls the
+// allocation order of clauses during moving them).
+
+// The standard sequence of using the arena is as follows:
+//
+//   Arena arena;
+//   ...
+//   arena.prepare (bytes);
+//   q1 = arena.copy (p1, bytes1);
+//   ...
+//   qn = arena.copy (pn, bytesn);
+//   CADICAL_assert (bytes1 + ... + bytesn <= bytes);
+//   arena.swap ();
+//   ...
+//   if (!arena.contains (q)) delete q;
+//   ...
+//   arena.prepare (bytes);
+//   q1 = arena.copy (p1, bytes1);
+//   ...
+//   qn = arena.copy (pn, bytesn);
+//   CADICAL_assert (bytes1 + ... + bytesn <= bytes);
+//   arena.swap ();
+//   ...
+//
+// One has to be really careful with 'qi' references to arena memory.
+
+struct Internal;
+
+class Arena {
+
+  Internal *internal;
+
+  struct {
+    char *start, *top, *end;
+  } from, to;
+
+public:
+  Arena (Internal *);
+  ~Arena ();
+
+  // Prepare 'to' space to hold that amount of memory.  Precondition is that
+  // the 'to' space is empty.  The following sequence of 'copy' operations
+  // can use as much memory in sum as pre-allocated here.
+  //
+  void prepare (size_t bytes);
+
+  // Does the memory pointed to by 'p' belong to this arena? More precisely
+  // to the 'from' space, since that is the only one remaining after 'swap'.
+  //
+  bool contains (void *p) const {
+    char *c = (char *) p;
+    return (from.start <= c && c < from.top) ||
+           (to.start <= c && c < to.top);
+  }
+
+  // Allocate that amount of memory in 'to' space.  This assumes the 'to'
+  // space has been prepared to hold enough memory with 'prepare'.  Then
+  // copy the memory pointed to by 'p' of size 'bytes'.  Note that it does
+  // not matter whether 'p' is in 'from' or allocated outside of the arena.
+  //
+  char *copy (const char *p, size_t bytes) {
+    char *res = to.top;
+    to.top += bytes;
+    CADICAL_assert (to.top <= to.end);
+    memcpy (res, p, bytes);
+    return res;
+  }
+
+  // Completely delete 'from' space and then replace 'from' by 'to' (by
+  // pointer swapping).  Everything previously allocated (in 'from') and not
+  // explicitly copied to 'to' with 'copy' becomes invalid.
+  //
+  void swap ();
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/averages.hpp b/src/sat/cadical/averages.hpp
new file mode 100644
index 000000000..3ebdcddfa
--- /dev/null
+++ b/src/sat/cadical/averages.hpp
@@ -0,0 +1,43 @@
+#ifndef _averages_hpp_INCLUDED
+#define _averages_hpp_INCLUDED
+
+#include "global.h"
+
+#include "ema.hpp" // alphabetically after 'averages.hpp'
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Averages {
+
+  int64_t swapped;
+
+  struct {
+
+    struct {
+      EMA fast; // average fast (small window) moving glucose level
+      EMA slow; // average slow (large window) moving glucose level
+    } glue;
+
+    struct {
+      EMA fast; // average fast (small window) moving trail level
+      EMA slow; // average slow (large window) moving trail level
+    } trail;
+
+    EMA decisions;
+
+    EMA size;  // average learned clause size
+    EMA jump;  // average (potential non-chronological) back-jump level
+    EMA level; // average back track level after conflict
+
+  } current, saved;
+
+  Averages () : swapped (0) {}
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/bins.hpp b/src/sat/cadical/bins.hpp
new file mode 100644
index 000000000..aeefeceeb
--- /dev/null
+++ b/src/sat/cadical/bins.hpp
@@ -0,0 +1,28 @@
+#ifndef _bins_hpp_INCLUDED
+#define _bins_hpp_INCLUDED
+
+#include "global.h"
+
+#include "util.hpp" // Alphabetically after 'bins'.
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+using namespace std;
+
+struct Bin {
+  int lit;
+  int64_t id;
+};
+
+typedef vector<Bin> Bins;
+
+inline void shrink_bins (Bins &bs) { shrink_vector (bs); }
+inline void erase_bins (Bins &bs) { erase_vector (bs); }
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/block.hpp b/src/sat/cadical/block.hpp
new file mode 100644
index 000000000..202355f82
--- /dev/null
+++ b/src/sat/cadical/block.hpp
@@ -0,0 +1,43 @@
+#ifndef _block_hpp_INCLUDED
+#define _block_hpp_INCLUDED
+
+#include "global.h"
+
+#include "heap.hpp" // Alphabetically after 'block.hpp'.
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct block_more_occs_size {
+  Internal *internal;
+  block_more_occs_size (Internal *i) : internal (i) {}
+  bool operator() (unsigned a, unsigned b);
+};
+
+typedef heap<block_more_occs_size> BlockSchedule;
+
+class Blocker {
+
+  friend struct Internal;
+
+  vector<struct Clause *> candidates;
+  vector<struct Clause *> reschedule;
+  BlockSchedule schedule;
+
+  Blocker (Internal *i) : schedule (block_more_occs_size (i)) {}
+
+  void erase () {
+    erase_vector (candidates);
+    erase_vector (reschedule);
+    schedule.erase ();
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/cadical.hpp b/src/sat/cadical/cadical.hpp
new file mode 100644
index 000000000..c9ed41332
--- /dev/null
+++ b/src/sat/cadical/cadical.hpp
@@ -0,0 +1,1351 @@
+#ifndef _cadical_hpp_INCLUDED
+#define _cadical_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdint>
+#include <cstdio>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+/*========================================================================*/
+
+// This provides the actual API of the CaDiCaL solver, which is implemented
+// in the class 'Solver' below.  Beside its constructor and destructor most
+// important is the IPASIR part which you can find between 'BEGIN IPASIR'
+// and 'END IPASIR' comments below.  The following '[Example]' below might
+// also be a good starting point to understand the API.
+
+/*========================================================================*/
+
+// The SAT competition standardized the exit code of SAT solvers to the
+// following which then is also used return code for 'solve' functions.
+// In the following example we use those constants for brevity though.
+
+enum Status {
+  SATISFIABLE = 10,
+  UNSATISFIABLE = 20,
+  UNKNOWN = 0,
+};
+
+/*========================================================================*/
+
+// [Example]
+//
+// The internal solver state follows the IPASIR API model used in the
+// incremental track of the SAT competition.  State transitions are
+// triggered by member function calls, declared and described below.
+//
+// Consider the following code (from 'test/api/example.cpp') of API usage:
+//
+//   CaDiCaL::Solver * solver = new CaDiCaL::Solver;
+//
+//   // ------------------------------------------------------------------
+//   // Encode Problem and check without assumptions.
+//
+//   enum { TIE = 1, SHIRT = 2 };
+//
+//   solver->add (-TIE), solver->add (SHIRT),  solver->add (0);
+//   solver->add (TIE),  solver->add (SHIRT),  solver->add (0);
+//   solver->add (-TIE), solver->add (-SHIRT), solver->add (0);
+//
+//   int res = solver->solve ();    // Solve instance.
+//   CADICAL_assert (res == 10);            // Check it is 'SATISFIABLE'.
+//
+//   res = solver->val (TIE);       // Obtain assignment of 'TIE'.
+//   CADICAL_assert (res < 0);              // Check 'TIE' assigned to 'false'.
+//
+//   res = solver->val (SHIRT);     // Obtain assignment of 'SHIRT'.
+//   CADICAL_assert (res > 0);              // Check 'SHIRT' assigned to 'true'.
+//
+//   // ------------------------------------------------------------------
+//   // Incrementally solve again under one assumption.
+//
+//   solver->assume (TIE);          // Now force 'TIE' to true.
+//
+//   res = solver->solve ();        // Solve again incrementally.
+//   CADICAL_assert (res == 20);            // Check it is 'UNSATISFIABLE'.
+//
+//   res = solver->failed (TIE);    // Check 'TIE' responsible.
+//   CADICAL_assert (res);                  // Yes, 'TIE' in core.
+//
+//   res = solver->failed (SHIRT);  // Check 'SHIRT' responsible.
+//   CADICAL_assert (!res);                 // No, 'SHIRT' not in core.
+//
+//   // ------------------------------------------------------------------
+//   // Incrementally solve once more under another assumption.
+//
+//   solver->assume (-SHIRT);       // Now force 'SHIRT' to false.
+//
+//   res = solver->solve ();        // Solve again incrementally.
+//   CADICAL_assert (res == 20);            // Check it is 'UNSATISFIABLE'.
+//
+//   res = solver->failed (TIE);    // Check 'TIE' responsible.
+//   CADICAL_assert (!res);                 // No, 'TIE' not in core.
+//
+//   res = solver->failed (-SHIRT); // Check '!SHIRT' responsible.
+//   CADICAL_assert (res);                  // Yes, '!SHIRT' in core.
+//
+//   // ------------------------------------------------------------------
+//
+//   delete solver;
+
+/*========================================================================*/
+
+// [States and Transitions]
+//
+// Compared to IPASIR we also use an 'ADDING' state in which the solver
+// stays while adding non-zero literals until the clause is completed
+// through adding a zero literal.  The additional 'INITIALIZING',
+// 'CONFIGURING' and 'DELETING' states are also not part of IPASIR but also
+// useful for testing and debugging.
+//
+// We have the following transitions which are all synchronous except for
+// the reentrant 'terminate' call:
+//
+//                         new
+// INITIALIZING --------------------------> CONFIGURING
+//
+//                    set / trace
+//  CONFIGURING --------------------------> CONFIGURING
+//
+//               add (non zero literal)
+//        VALID --------------------------> ADDING
+//
+//               add (zero literal)
+//        VALID --------------------------> STEADY
+//
+//               assume (non zero literal)
+//        READY --------------------------> STEADY
+//
+//                        solve
+//        READY --------------------------> SOLVING
+//
+//                     (internal)
+//      SOLVING --------------------------> SOLVED
+//
+//                val (non zero literal)
+//    SATISFIED --------------------------> SATISFIED
+//
+//               failed (non zero literal)
+//  UNSATISFIED --------------------------> UNSATISFIED
+//
+//               implied (non zero literal)
+// INCONCLUSIVE --------------------------> INCONCLUSIVE
+//
+//                        delete
+//        VALID --------------------------> DELETING
+//
+// where
+//
+//       SOLVED = SATISFIED    | UNSATISFIED | INCONCLUSIVE
+//        READY = CONFIGURING  | STEADY      | SOLVED
+//        VALID = READY        | ADDING
+//      INVALID = INITIALIZING | DELETING
+//
+// The 'SOLVING' state is only visible in different contexts, i.e., from
+// another thread or from a signal handler.  It is used to implement
+// 'terminate'.  Here is the only asynchronous transition:
+//
+//               terminate (asynchronously)
+//      SOLVING  ------------------------->  STEADY
+//
+// The important behaviour to remember is that adding, assuming or
+// constraining 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 'failed' only
+// in the 'UNSATISFIED' state.  Solving can only be started in the 'STEADY '
+// or 'CONFIGURING' state or after the previous call to 'solve' yielded an
+// 'INCONCLUSIVE , '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.
+//
+// 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 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.
+
+/*========================================================================*/
+
+// States are represented by a bit-set in order to combine them.
+
+enum State {
+  INITIALIZING = 1,   // during initialization (invalid)
+  CONFIGURING = 2,    // configure options (with 'set')
+  STEADY = 4,         // ready to call 'solve'
+  ADDING = 8,         // adding clause literals (zero missing)
+  SOLVING = 16,       // while solving (within 'solve')
+  SATISFIED = 32,     // satisfiable allows 'val'
+  UNSATISFIED = 64,   // unsatisfiable allows 'failed'
+  DELETING = 128,     // during and after deletion (invalid)
+  INCONCLUSIVE = 256, // unknown allows 'implied'
+
+  // These combined states are used to check contracts.
+
+  READY = CONFIGURING | STEADY | SATISFIED | UNSATISFIED | INCONCLUSIVE,
+  VALID = READY | ADDING,
+  INVALID = INITIALIZING | DELETING
+};
+
+/*------------------------------------------------------------------------*/
+
+// Opaque classes needed in the API and declared in the same namespace.
+
+class File;
+class Testing;
+struct Internal;
+struct External;
+
+/*------------------------------------------------------------------------*/
+
+// Forward declaration of call-back classes. See bottom of this file.
+
+class Learner;
+class FixedAssignmentListener;
+class Terminator;
+class ClauseIterator;
+class WitnessIterator;
+class ExternalPropagator;
+class Tracer;
+struct InternalTracer;
+class FileTracer;
+class StatTracer;
+
+/*------------------------------------------------------------------------*/
+
+class Solver {
+
+public:
+  // ====== BEGIN IPASIR ===================================================
+
+  // This section implements the corresponding IPASIR functionality.
+
+  Solver ();
+  ~Solver ();
+
+  static const char *signature (); // name of this library
+
+  // Core functionality as in the IPASIR incremental SAT solver interface.
+  // (recall 'READY = CONFIGURING | STEADY  | SATISFIED | UNSATISFIED').
+  // Further note that 'lit' is required to be different from 'INT_MIN' and
+  // different from '0' except for 'add'.
+
+  // Add valid literal to clause or zero to terminate clause.
+  //
+  //   require (VALID)                  // recall 'VALID = READY | ADDING'
+  //   if (lit) ensure (ADDING)         // and thus VALID but not READY
+  //   if (!lit) ensure (STEADY )       // and thus READY
+  //
+  void add (int lit);
+
+  // Here are functions simplifying clause addition. The given literals
+  // should all be valid (different from 'INT_MIN' and different from '0').
+  //
+  //   require (VALID)
+  //   ensure (STEADY )
+  //
+  void clause (int);                      // Add unit clause.
+  void clause (int, int);                 // Add binary clause.
+  void clause (int, int, int);            // Add ternary clause.
+  void clause (int, int, int, int);       // Add quaternary clause.
+  void clause (int, int, int, int, int);  // Add quinternary clause.
+  void clause (const std::vector<int> &); // Add literal vector as clause.
+  void clause (const int *, size_t);      // Add literal array as clause.
+
+  // This function can be used to check if the formula is already
+  // inconsistent (contains the empty clause or was proven to be
+  // root-level unsatisfiable).
+
+  bool inconsistent ();
+
+  // 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 (STEADY )
+  //
+  void assume (int lit);
+
+  // Try to solve the current formula.  Returns
+  //
+  //    0 = UNKNOWN      (limit reached or interrupted through 'terminate')
+  //   10 = SATISFIABLE
+  //   20 = UNSATISFIABLE
+  //
+  //   require (READY)
+  //   ensure (INCONCLUSIVE  | SATISFIED | UNSATISFIED)
+  //
+  // Note, that while in this call the solver actually transitions to state
+  // 'SOLVING', which however is only visible from a different context,
+  // i.e., from a different thread or from a signal handler.  Only right
+  // before returning from this call it goes into a 'READY' state.
+  //
+  int solve ();
+
+  // Get value (-lit=false, lit=true) of valid non-zero literal.
+  //
+  //   require (SATISFIED)
+  //   ensure (SATISFIED)
+  //
+  int val (int lit);
+
+  // Try to flip the value of the given literal without falsifying the
+  // formula.  Returns 'true' if this was successful. Otherwise the model is
+  // not changed and 'false' is returned.  If a literal was eliminated or
+  // substituted flipping will fail on that literal and in particular the
+  // solver will not taint it nor restore any clauses.
+  //
+  // The 'flip' function can only flip the value of a variables not acting
+  // as witness on the reconstruction stack.
+  //
+  // As a side effect of calling this function first all assigned variables
+  // are propagated again without using blocking literal.  Thus the first
+  // call to this function after obtaining a model adds a substantial
+  // overhead.  Subsequent calls will not need to properly propagate again.
+  //
+  // Furthermore if the reconstruction stack is non-empty and has been
+  // traversed to reconstruct a full extended model for eliminated
+  // variables (and to satisfy removed blocked clauses), the values of these
+  // witness variables obtained via 'val' before become invalid. The user
+  // thus will need to call 'val' again after calling 'flip' which will
+  // trigger then a traversal of the reconstruction stack.
+  //
+  // So try to avoid mixing 'flip' and 'val' (for efficiency only).
+  // Further, this functionality is currently not supported in the presence
+  // of an external propagator.
+  //
+  //   require (SATISFIED)
+  //   ensure (SATISFIED)
+  //
+  bool flip (int lit);
+
+  // Same as 'flip' without actually flipping it. This functionality is
+  // currently not supported in the presence of an external propagator.
+  //
+  //   require (SATISFIED)
+  //   ensure (SATISFIED)
+  //
+  bool flippable (int lit);
+
+  // Determine whether the valid non-zero literal is in the core.
+  // Returns 'true' if the literal is in the core and 'false' otherwise.
+  // Note that the core does not have to be minimal.
+  //
+  //   require (UNSATISFIED)
+  //   ensure (UNSATISFIED)
+  //
+  bool failed (int lit);
+
+  // 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)
+  //   ensure (VALID)
+  //
+  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 =====================================================
+
+  // Add call-back which allows to observe when a variable is fixed.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void connect_fixed_listener (FixedAssignmentListener *fixed_listener);
+  void disconnect_fixed_listener ();
+
+  // ====== BEGIN IPASIR-UP ================================================
+
+  // Add call-back which allows to learn, propagate and backtrack based on
+  // external constraints. Only one external propagator can be connected
+  // and after connection every related variables must be 'observed' (use
+  // 'add_observed_var' function).
+  // Disconnection of the external propagator resets all the observed
+  // variables.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void connect_external_propagator (ExternalPropagator *propagator);
+  void disconnect_external_propagator ();
+
+  // Mark as 'observed' those variables that are relevant to the external
+  // propagator. External propagation, clause addition during search and
+  // notifications are all over these observed variables.
+  // A variable can not be observed without having an external propagator
+  // connected. Observed variables are "frozen" internally, and so
+  // inprocessing will not consider them as candidates for elimination.
+  // An observed variable is allowed to be a fresh variable and it can be
+  // added also during solving.
+  //
+  //   require (VALID_OR_SOLVING)
+  //   ensure (VALID_OR_SOLVING)
+  //
+  void add_observed_var (int var);
+
+  // Removes the 'observed' flag from the given variable. A variable can be
+  // set unobserved only between solve calls, not during it (to guarantee
+  // that no yet unexplained external propagation involves it).
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void remove_observed_var (int var);
+
+  // Removes all the 'observed' flags from the variables. Disconnecting the
+  // propagator invokes this step as well.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void reset_observed_vars ();
+
+  // Get reason of valid observed literal (true = it is an observed variable
+  // and it got assigned by a decision during the CDCL loop. Otherwise:
+  // false.
+  //
+  //   require (VALID_OR_SOLVING)
+  //   ensure (VALID_OR_SOLVING)
+  //
+  bool is_decision (int lit);
+
+  // Force solve to backtrack to certain decision level. Can be called only
+  // during 'cb_decide' of a connected External Propagator.
+  // Invoking in any other time will not have an effect.
+  // If the call had an effect, the External Propagator will be notified
+  // about the backtrack via 'notify_backtrack'.
+  //
+  //   require (SOLVING)
+  //   ensure (SOLVING)
+  //
+  void force_backtrack (size_t new_level);
+
+  // ====== END IPASIR-UP ==================================================
+
+  //------------------------------------------------------------------------
+  // Adds a literal to the constraint clause. Same functionality as 'add'
+  // but the clause only exists for the next call to solve (same lifetime as
+  // assumptions). Only one constraint may exists at a time. A new
+  // constraint replaces the old. The main application of this functionality
+  // is the model checking algorithm IC3. See our FMCAD'21 paper
+  // [FroleyksBiere-FMCAD'19] for more details.
+  //
+  // Add valid literal to the constraint clause or zero to terminate it.
+  //
+  //   require (VALID)                     // recall 'VALID = READY |
+  //   ADDING' if (lit) ensure (ADDING)            // and thus VALID but not
+  //   READY if (!lit) && !adding_clause ensure (STEADY ) // and thus READY
+  //
+  void constrain (int lit);
+
+  // Determine whether the constraint was used to proof the
+  // unsatisfiability. Note that the formula might still be unsatisfiable
+  // without the constraint.
+  //
+  //   require (UNSATISFIED)
+  //   ensure (UNSATISFIED)
+  //
+  bool constraint_failed ();
+
+  // Collects a subset of those literals that are implied by unit
+  // propagation by assuming the currently defined (potentially empty) set
+  // of assumptions (see IPASIR assume(lit)) function. In case unit
+  // propgation over the defined set of assumptions (or over the clause
+  // database on its own) leads to conflict, the function returns 20 and the
+  // content of 'implicants' is undefined. In case unit propagation happens
+  // to satisfy all the clauses (not probable, but not impossible), the
+  // function returns 10 and 'implicants' is a solution of the current
+  // formula under the current assumptions (after solution reconstruction).
+  // In any other case, the function returns 0 (indicating 'UNKNOWN') and
+  // 'implicants' lists the non-conflicting current value of the trail.
+
+  // Returns
+  //
+  //    0 = UNKNOWN      (unit propagation did not lead to a conflict nor to a 
+  //                      complete assignment, or limit reached or interrupted 
+  //                      through 'terminate')
+  //   10 = SATISFIABLE
+  //   20 = UNSATISFIABLE
+
+  //   require (READY)
+  //   ensure (INCONCLUSIVE  | SATISFIED | UNSATISFIED)
+  int propagate ();
+
+  //
+  //   require (INCONCLUSIVE)
+  //   ensure (INCONCLUSIVE)
+  //
+  void implied (std::vector<int> &implicants);
+
+  //------------------------------------------------------------------------
+  // 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 steady.
+  //
+  //   require (READY)
+  //   ensure (INCONCLUSIVE |SATISFIED|UNSATISFIED)
+  //
+  int lookahead (void);
+
+  struct CubesWithStatus {
+    int status;
+    std::vector<std::vector<int>> cubes;
+  };
+
+  CubesWithStatus generate_cubes (int, int min_depth = 0);
+
+  void reset_assumptions ();
+  void reset_constraint ();
+
+  // Return the current state of the solver as defined above.
+  //
+  const State &state () const { return _state; }
+
+  // Similar to 'state ()' but using the standard 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
+
+  /*----------------------------------------------------------------------*/
+  // 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)          // for 'this'
+  //   ensure (READY)           // for 'this'
+  //
+  //   other.require (CONFIGURING)
+  //   other.ensure (CONFIGURING | STEADY )
+  //
+  void copy (Solver &other) const;
+
+  /*----------------------------------------------------------------------*/
+  // Variables are usually added and initialized implicitly whenever a
+  // literal is used as an argument except for the functions 'val', 'fixed',
+  // 'failed' and 'frozen'.  However, the library internally keeps a maximum
+  // variable index, which can be queried.
+  // With factor (BVA) the solver might also add new variables. In that case
+  // the user is required to use this to check which variables are currently
+  // free before adding new variables of their own.
+  // The alternative is to reserve variables in batches with
+  // 'reserve_difference'. Using 'reserve' in combination with any technique
+  // that could add variables (currently only factor) is not advised.
+  //
+  //   require (VALID | SOLVING)
+  //   ensure (VALID | SOLVING)
+  //
+  int vars ();
+
+  // Increase the maximum variable index explicitly.  This function makes
+  // sure that at least 'min_max_var' variables are initialized.  Since it
+  // might need to reallocate tables, it destroys a satisfying assignment
+  // and has the same state transition and conditions as 'assume' etc.
+  //
+  //   require (READY)
+  //   ensure (STEADY )
+  //
+  void reserve (int min_max_var);
+
+  // Increase the maximum variable index by a number of new variables.
+  // initializes 'number_of_vars' new variables and protects them from
+  // being used by the solver as extension variables (BVA).
+  // It returns the new maximum variable index which is the highest
+  // variable name of the consecutive range of newly reserved variables.
+  // It has the same state transition and conditions as 'reserve' above.
+  //
+  //   require (READY)
+  //   ensure (STEADY )
+  //
+  int reserve_difference (int number_of_vars);
+
+#ifndef CADICAL_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
+  // through delta debugging.
+  //
+  // Tracing API calls can also be achieved by using the environment
+  // variable 'CADICAL_API_TRACE'.  That alternative is useful if you do not
+  // want to change the source code using the solver, e.g., if you only have
+  // a binary with the solver linked in.  However, that method only allows
+  // to trace one solver instance, while with the following function API
+  // tracing can be enabled for different solver instances individually.
+  //
+  // The solver will flush the file after every trace API call but does not
+  // close it during deletion. It remains owned by the user of the library.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void trace_api_calls (FILE *file);
+#endif
+
+  //------------------------------------------------------------------------
+  // Option handling.
+
+  // Determine whether 'name' is a valid option name.
+  //
+  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>]'.
+
+  static bool is_valid_long_option (const char *arg);
+
+  // Get the current value of the option 'name'.  If 'name' is invalid then
+  // zero is returned.  Here '--...' arguments as invalid options.
+  //
+  int get (const char *name);
+
+  // Set the default verbose message prefix (default "c ").
+  //
+  void prefix (const char *verbose_message_prefix);
+
+  // Explicit version of setting an option.  If the option '<name>' exists
+  // and '<val>' can be parsed then 'true' is returned.  If the option value
+  // is out of range the actual value is computed as the closest (minimum or
+  // maximum) value possible, but still 'true' is returned.
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  // Thus options can only bet set right after initialization.
+  //
+  bool set (const char *name, int val);
+
+  // This function accepts options in command line syntax:
+  //
+  //   '--<name>=<val>', '--<name>', or '--no-<name>'
+  //
+  // It actually calls the previous 'set' function after parsing 'arg'.  The
+  // same values are expected as for 'is_valid_long_option' above and as
+  // with 'set' any value outside of the range of legal values for a
+  // particular option are set to either the minimum or maximum depending on
+  // which side of the valid interval they lie.
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  bool set_long_option (const char *arg);
+
+  // Determine whether 'name' is a valid configuration.
+  //
+  static bool is_valid_configuration (const char *);
+
+  // Overwrite (some) options with the forced values of the configuration.
+  // The result is 'true' iff the 'name' is a valid configuration.
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  bool configure (const char *);
+
+  // Increase preprocessing and inprocessing limits by '10^<val>'.  Values
+  // below '0' are ignored and values above '9' are reduced to '9'.
+  //
+  //   require (READY)
+  //   ensure (READY)
+  //
+  void optimize (int val);
+
+  // Specify search limits, where currently 'name' can be "conflicts",
+  // "decisions", "preprocessing", or "localsearch".  The first two limits
+  // are unbounded by default.  Thus using a negative limit for conflicts or
+  // decisions switches back to the default of unlimited search (for that
+  // particular limit).  The preprocessing limit determines the number of
+  // 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' 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)
+  //
+  bool limit (const char *arg, int val);
+  bool is_valid_limit (const char *arg);
+
+  // The number of currently active variables and clauses can be queried by
+  // these functions.  Variables become active if a clause is added with it.
+  // They become inactive if they are eliminated or fixed at the root level
+  // Clauses become inactive if they are satisfied, subsumed, eliminated.
+  // Redundant clauses are reduced regularly and thus the 'redundant'
+  // function is less useful.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  int active () const;          // Number of active variables.
+  int64_t redundant () const;   // Number of active redundant clauses.
+  int64_t irredundant () const; // Number of active irredundant clauses.
+
+  //------------------------------------------------------------------------
+  // 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 (INCONCLUSIVE  | SATISFIED | UNSATISFIED)
+  //
+  int simplify (int rounds = 3);
+
+  //------------------------------------------------------------------------
+  // Force termination of 'solve' asynchronously.
+  //
+  //  require (SOLVING | READY)
+  //  ensure (INCONCLUSIVE )     // actually not immediately (synchronously)
+  //
+  void terminate ();
+
+  //------------------------------------------------------------------------
+
+  // We have the following common reference counting functions, which avoid
+  // to restore clauses but require substantial user guidance.  This was the
+  // only way to use inprocessing in incremental SAT solving in Lingeling
+  // (and before in MiniSAT's 'freeze' / 'thaw') and which did not use
+  // automatic clause restoring.  In general this is slower than
+  // restoring clauses and should not be used.
+  //
+  // In essence the user freezes variables which potentially are still
+  // needed in clauses added or assumptions used after the next 'solve'
+  // call.  As in Lingeling you can freeze a variable multiple times, but
+  // then have to melt it the same number of times again in order to enable
+  // variable eliminating on it etc.  The arguments can be literals
+  // (negative indices) but conceptually variables are frozen.
+  //
+  // In the old way of doing things without restore you should not use a
+  // variable incrementally (in 'add' or 'assume'), which was used before
+  // and potentially could have been eliminated in a previous 'solve' call.
+  // This can lead to spurious satisfying assignment.  In order to check
+  // this API contract one can use the 'checkfrozen' option.  This has the
+  // drawback that restoring clauses implicitly would fail with a fatal
+  // 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)
+  //
+  bool frozen (int lit) const;
+  void freeze (int lit);
+  void melt (int lit); // Also needs 'require (frozen (lit))'.
+
+  //------------------------------------------------------------------------
+
+  // Root level assigned variables can be queried with this function.
+  // It returns '1' if the literal is implied by the formula, '-1' if its
+  // negation is implied, or '0' if this is unclear at this point.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  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
+  // successfully opened for writing.  Writing proofs has to be enabled
+  // before calling 'solve', 'add' and 'dimacs', that is in state
+  // 'CONFIGURING'.  Otherwise only partial proofs would be written.
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  bool trace_proof (FILE *file, const char *name); // Write DRAT proof.
+  bool trace_proof (const char *path);             // Open & write proof.
+
+  // Flushing the proof trace file eventually calls 'fflush' on the actual
+  // file or pipe and thus if this function returns all the proof steps
+  // should have been written (with the same guarantees as 'fflush').
+  //
+  // The additional optional argument forces to print the number of addition
+  // and deletion steps in the proof even if the verbosity level is zero but
+  // not if quiet is set as well.  The default for the stand-alone solver is
+  // to print this information (in the 'closing proof' section) but for API
+  // usage of the library we want to stay silent unless explicitly requested
+  // or verbosity is non-zero (and as explained quiet is not set).
+  //
+  // This function can be called multiple times.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void flush_proof_trace (bool print = false);
+
+  // Close proof trace early.  Similar to 'flush' we allow the user to
+  // control with 'print' in a more fine-grained way whether statistics
+  // about the size of the written proof file and if compressed on-the-fly
+  // the number of actual bytes written (including deflation percentage) are
+  // printed.  Before actually closing (or detaching in case of writing to
+  // '<stdout>') we check whether 'flush_proof_trace' was called since the
+  // last time a proof step (addition or deletion) was traced.  If this is
+  // not the case we would call 'flush_proof_trace' with the same 'print'
+  // argument.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void close_proof_trace (bool print = false);
+
+  // Enables clausal proof tracing with or without antecedents using
+  // the Tracer interface defined in 'tracer.hpp'
+  //
+  // InternalTracer, StatTracer and FileTracer for internal use
+  //
+  //   require (CONFIGURING)
+  //   ensure (CONFIGURING)
+  //
+  void connect_proof_tracer (Tracer *tracer, bool antecedents,
+                             bool finalize_clauses = false);
+  void connect_proof_tracer (InternalTracer *tracer, bool antecedents,
+                             bool finalize_clauses = false);
+  void connect_proof_tracer (StatTracer *tracer, bool antecedents,
+                             bool finalize_clauses = false);
+  void connect_proof_tracer (FileTracer *tracer, bool antecedents,
+                             bool finalize_clauses = false);
+
+  // Triggers the conclusion of incremental proofs.
+  // if the solver is SATISFIED it will trigger extend ()
+  // and give the model to the proof tracer through conclude_sat ()
+  // if the solver is UNSATISFIED it will trigger failing ()
+  // which will learn new clauses as explained below:
+  // In case of failed assumptions will provide a core negated
+  // as a clause through the proof tracer interface.
+  // With a failing constraint these can be multiple clauses.
+  // Then it will trigger a conclude_unsat event with the id(s)
+  // of the newly learnt clauses or the id of the global conflict.
+  // In case the solver is in UNKNOWN, it will collect the currently
+  // entrailed literals and add them to the proof.
+  //
+  //   require (SATISFIED || UNSATISFIED || UNKNOWN)
+  //   ensure (SATISFIED || UNSATISFIED || UNKNOWN)
+  //
+  void conclude ();
+
+  // Disconnect proof tracer. If this is not done before deleting
+  // the tracer will be deleted. Returns true if successful.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  bool disconnect_proof_tracer (Tracer *tracer);
+  bool disconnect_proof_tracer (StatTracer *tracer);
+  bool disconnect_proof_tracer (FileTracer *tracer);
+
+  //------------------------------------------------------------------------
+
+  static void usage (); // print usage information for long options
+
+  static void configurations (); // print configuration usage options
+
+  //   require (!DELETING)
+  //   ensure (!DELETING)
+  //
+  void statistics (); // print statistics
+  void resources ();  // print resource usage (time and memory)
+
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  void options (); // print current option and value list
+
+  //------------------------------------------------------------------------
+  // Traverse irredundant clauses or the extension stack in reverse order.
+  //
+  // The return value is false if traversal is aborted early due to one of
+  // the visitor functions returning false.  See description of the
+  // iterators below for more details on how to use these functions.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  bool traverse_clauses (ClauseIterator &) const;
+  bool traverse_witnesses_backward (WitnessIterator &) const;
+  bool traverse_witnesses_forward (WitnessIterator &) const;
+
+  //------------------------------------------------------------------------
+  // Files with explicit path argument support compressed input and output
+  // if appropriate helper functions 'gzip' etc. are available.  They are
+  // called through opening a pipe to an external command.
+  //
+  // If the 'strict' argument is zero then the number of variables and
+  // 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.
+  //
+  // Returns zero if successful and otherwise an error message.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  const char *read_dimacs (FILE *file, 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
+  // to a file in DIMACS format.  Clauses on the extension stack are
+  // not included, nor any redundant clauses.
+  //
+  // The 'min_max_var' parameter gives a lower bound on the number '<vars>'
+  // of variables used in the DIMACS 'p cnf <vars> ...' header.
+  //
+  // Returns zero if successful and otherwise an error message.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  const char *write_dimacs (const char *path, int min_max_var = 0);
+
+  // The extension stack for reconstruction a solution can be written too.
+  //
+  const char *write_extension (const char *path);
+
+  // Print build configuration to a file with prefix 'c '.  If the file
+  // is '<stdout>' or '<stderr>' then terminal color codes might be used.
+  //
+  static void build (FILE *file, const char *prefix = "c ");
+
+private:
+  //==== start of state ====================================================
+
+  // The solver is in the state ADDING if either the current clause or the
+  // constraint (or both) is not yet terminated.
+  bool adding_clause;
+  bool adding_constraint;
+
+  State _state; // API states as discussed above.
+
+  /*----------------------------------------------------------------------*/
+
+  // The 'Solver' class is a 'facade' object for 'External'.  It exposes the
+  // public API of 'External' but hides everything else (except for the some
+  // private functions).  It is supposed to make it easier to understand the
+  // API and use the solver through the API.
+
+  // This approach has the benefit of decoupling this header file from all
+  // internal data structures, which is particularly useful if the rest of
+  // the source is not available. For instance if only a CaDiCaL library is
+  // installed in a system, then only this header file has to be installed
+  // too, and still allows to compile and link against the library.
+
+  /*----------------------------------------------------------------------*/
+
+  // More precisely the CaDiCaL code is split into three layers:
+  //
+  //   Solver:       facade object providing the actual API of the solver
+  //   External:     communication layer between 'Solver' and 'Internal'
+  //   Internal:     the actual solver code
+  //
+  // The 'External' and 'Internal' layers are declared and implemented in
+  // the corresponding '{external,internal}.{hpp,cpp}' files (as expected),
+  // while the 'Solver' facade class is defined in 'cadical.hpp' (here) but
+  // implemented in 'solver.cpp'.  The reason for this naming mismatch is,
+  // that we want to use 'cadical.hpp' for the library header (this header
+  // file) and call the binary of the stand alone SAT also 'cadical', which
+  // is more naturally implemented in 'cadical.cpp'.
+  //
+  // Separating 'External' from 'Internal' also allows us to map external
+  // literals to internal literals, which is useful with many fixed or
+  // eliminated variables (during 'compact' the internal variable range is
+  // reduced and external variables are remapped).  Such an approach is also
+  // necessary, if we want to use extended resolution in the future (such as
+  // bounded variable addition).
+  //
+  Internal *internal; // Hidden internal solver.
+  External *external; // Hidden API to internal solver mapping.
+
+  friend class Testing; // Access to 'internal' for testing only!
+
+#ifndef CADICAL_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
+  // read, execute and also shrink through delta debugging.
+  //
+  // The environment variable is read in the constructor and the trace is
+  // opened for writing and then closed again in the destructor.
+  //
+  // Alternatively one case use 'trace_api_calls'.  Both
+  //
+  bool close_trace_api_file; // Close file if owned by solver it.
+  FILE *trace_api_file;      // Also acts as flag that we are tracing.
+
+  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 *) const;
+  void trace_api_call (const char *, const char *, int) const;
+#endif
+
+  void transition_to_steady_state ();
+
+  //------------------------------------------------------------------------
+  // Used in the stand alone solver application 'App' and the model based
+  // tester 'Mobical'.  So only these two classes need direct access to the
+  // otherwise more application specific functions listed here together with
+  // the internal DIMACS parser.
+
+  friend class App;
+  friend class Mobical;
+  friend class Parser;
+
+  // Read solution in competition format for debugging and testing.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  const char *read_solution (const char *path);
+
+  // Cross-compilation with 'MinGW' needs some work-around for 'printf'
+  // style printing of 64-bit numbers including warning messages.  The
+  // followings lines are copies of similar code in 'inttypes.hpp' but we
+  // want to keep the 'cadical.hpp' header file stand-alone.
+
+#ifndef PRINTF_FORMAT
+#ifdef __MINGW32__
+#define __USE_MINGW_ANSI_STDIO 1
+#define PRINTF_FORMAT __MINGW_PRINTF_FORMAT
+#else
+#define PRINTF_FORMAT printf
+#endif
+#endif
+
+  // This gives warning messages for wrong 'printf' style format string
+  // usage. Apparently (on 'gcc 9' at least) the first argument is 'this'
+  // here.
+  //
+  // TODO: support for other compilers (beside 'gcc' and 'clang').
+
+  /*
+#define CADICAL_ATTRIBUTE_FORMAT(FORMAT_POSITION, \
+                                 VARIADIC_ARGUMENT_POSITION) \
+  __attribute__ ((format (PRINTF_FORMAT, FORMAT_POSITION, \
+                          VARIADIC_ARGUMENT_POSITION)))
+  */
+#define CADICAL_ATTRIBUTE_FORMAT(FORMAT_POSITION, VARIADIC_ARGUMENT_POSITION)
+
+  // Messages in a common style.
+  //
+  //   require (VALID | DELETING)
+  //   ensure (VALID | DELETING)
+  //
+  void section (const char *);     // print section header
+  void message (const char *, ...) // ordinary message
+      CADICAL_ATTRIBUTE_FORMAT (2, 3);
+
+  void message ();               // empty line - only prefix
+  void error (const char *, ...) // produce error message
+      CADICAL_ATTRIBUTE_FORMAT (2, 3);
+
+  // Explicit verbose level ('section' and 'message' use '0').
+  //
+  //   require (VALID | DELETING)
+  //   ensure (VALID | DELETING)
+  //
+  void verbose (int level, const char *, ...)
+      CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+  // Factoring out common code to both 'read_dimacs' functions above.
+  //
+  //   require (VALID)
+  //   ensure (VALID)
+  //
+  const char *read_dimacs (File *, int &, int strict, bool *incremental = 0,
+                           std::vector<int> * = 0);
+
+  // Factored out common code for 'solve', 'simplify' and 'lookahead'.
+  //
+  int call_external_solve_and_check_results (bool preprocess_only);
+
+  //------------------------------------------------------------------------
+  // Print DIMACS file to '<stdout>' for debugging and testing purposes,
+  // including derived units and assumptions.  Since it will print in terms
+  // of internal literals it is otherwise not really useful.  To write a
+  // DIMACS formula in terms of external variables use 'write_dimacs'.
+  //
+  //   require (!INITIALIZING)
+  //   ensure (!INITIALIZING)
+  //
+  void dump_cnf ();
+  friend struct DumpCall; // Mobical calls 'dump_cnf' in 'DumpCall::execute'
+
+  /*----------------------------------------------------------------------*/
+
+  // Used in mobical to test external propagation internally.
+  // These functions should not be called for any other purposes.
+  //
+  ExternalPropagator *get_propagator ();
+  bool observed (int lit);
+  bool is_witness (int lit);
+
+  friend struct LemmaCall;
+  friend struct ObserveCall;
+  friend struct DisconnectCall;
+  friend class MockPropagator;
+};
+
+/*========================================================================*/
+
+// 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:
+  virtual ~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;
+};
+
+// Connected listener gets notified whenever the truth value of a variable
+// is fixed (for example during inprocessing or due to some derived unit
+// clauses).
+
+class FixedAssignmentListener {
+public:
+  virtual ~FixedAssignmentListener () {}
+
+  virtual void notify_fixed_assignment (int) = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
+// Allows to connect an external propagator to propagate values to variables
+// with an external clause as a reason or to learn new clauses during the
+// CDCL loop (without restart).
+
+class ExternalPropagator {
+
+public:
+  bool is_lazy = false; // lazy propagator only checks complete assignments
+  bool are_reasons_forgettable =
+      false; // Reason external clauses can be deleted
+
+  virtual ~ExternalPropagator () {}
+
+  // Notify the propagator about assignments to observed variables.
+  // The notification is not necessarily eager. It usually happens before
+  // the call of propagator callbacks and when a driving clause is leading
+  // to an assignment.
+  //
+  // virtual void notify_assignment (int lit, bool is_fixed) = 0;
+  virtual void notify_assignment (const std::vector<int> &lits) = 0;
+  virtual void notify_new_decision_level () = 0;
+  virtual void notify_backtrack (size_t new_level) = 0;
+
+  // Check by the external propagator the found complete solution (after
+  // solution reconstruction). If it returns false, the propagator should
+  // provide an external clause during the next callback or introduce new
+  // observed variables during this callback.
+  //
+  virtual bool cb_check_found_model (const std::vector<int> &model) = 0;
+
+  // Ask the external propagator for the next decision literal. If it
+  // returns 0, the solver makes its own choice.
+  //
+  virtual int cb_decide () { return 0; };
+
+  // Ask the external propagator if there is an external propagation to make
+  // under the current assignment. It returns either a literal to be
+  // propagated or 0, indicating that there is no external propagation under
+  // the current assignment.
+  //
+  virtual int cb_propagate () { return 0; };
+
+  // Ask the external propagator for the reason clause of a previous
+  // external propagation step (done by cb_propagate). The clause must be
+  // added literal-by-literal closed with a 0. Further, the clause must
+  // contain the propagated literal.
+  //
+  // The clause will be learned as an Irredundant Non-Forgettable Clause
+  // (see below at 'cb_has_external_clause' more details about it).
+  //
+  virtual int cb_add_reason_clause_lit (int propagated_lit) {
+    (void) propagated_lit;
+    return 0;
+  };
+
+  // The following two functions are used to add external clauses to the
+  // solver during the CDCL loop. The external clause is added
+  // literal-by-literal and learned by the solver as an irredundant
+  // (original) input clause. The clause can be arbitrary, but if it is
+  // root-satisfied or tautology, the solver will ignore it without learning
+  // it. Root-falsified literals are eagerly removed from the clause.
+  // Falsified clauses trigger conflict analysis, propagating clauses
+  // trigger propagation. In case chrono is 0, the solver backtracks to
+  // propagate the new literal on the right decision level, otherwise it
+  // potentially will be an out-of-order assignment on the current level.
+  // Unit clauses always (unless root-satisfied, see above) trigger
+  // backtracking (independently from the value of the chrono option and
+  // independently from being falsified or satisfied or unassigned) to level
+  // 0. Empty clause (or root falsified clause, see above) makes the problem
+  // unsat and stops the search immediately. A literal 0 must close the
+  // clause.
+  //
+  // The external propagator indicates that there is a clause to add.
+  // The parameter of the function allows the user to indicate that how
+  // 'forgettable' is the external clause. Forgettable clauses are allowed
+  // to be removed by the SAT solver during clause database reduction.
+  // However, it is up to the solver to decide when actually the clause is
+  // deleted. For example, unit clauses, even forgettable ones, will not be
+  // deleted. In case the clause is not 'forgettable' (the parameter is
+  // false), the solver considers the clause to be irredundant.
+  //
+  // In case the solver produces incremental proofs, these external clauses
+  // are added to the proof during solving at real-time, i.e., the proof
+  // checker can ignore them until that point (so added as input clause, but
+  // input after the query line).
+  //
+  // Reason clauses of external propagation steps are assumed to be
+  // forgettable, parameter 'reason_forgettable' can be used to change it.
+  //
+  // Currently, every external clause is expected to be over observed
+  // (therefore frozen) variables, hence no tainting or restore steps
+  // are performed upon their addition. This will be changed in later
+  // versions probably.
+  //
+  virtual bool cb_has_external_clause (bool &is_forgettable) = 0;
+
+  // The actual function called to add the external clause.
+  //
+  virtual int cb_add_external_clause_lit () = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
+// Allows to traverse all remaining irredundant clauses.  Satisfied and
+// 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 aborts early.
+
+class ClauseIterator {
+public:
+  virtual ~ClauseIterator () {}
+  virtual bool clause (const std::vector<int> &) = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
+// Allows to traverse all clauses on the extension stack together with their
+// witness cubes.  If the solver is inconsistent, i.e., an empty clause is
+// found and the formula is unsatisfiable, then nothing is traversed.
+//
+// The clauses traversed in 'traverse_clauses' together with the clauses on
+// the extension stack are logically equivalent to the original clauses.
+// See our SAT'19 paper for more details.
+//
+// The witness literals can be used to extend and fix an assignment on the
+// 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:
+  virtual ~WitnessIterator () {}
+  virtual bool witness (const std::vector<int> &clause,
+                        const std::vector<int> &witness,
+                        int64_t id = 0) = 0;
+};
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/cadicalSolver.c b/src/sat/cadical/cadicalSolver.c
new file mode 100644
index 000000000..9caea6605
--- /dev/null
+++ b/src/sat/cadical/cadicalSolver.c
@@ -0,0 +1,305 @@
+/**CFile****************************************************************
+
+  FileName    [cadicalSolver.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver CaDiCaL by Armin Biere, University of Freiburg]
+
+  Synopsis    [https://github.com/arminbiere/cadical]
+
+  Author      [Integrated into ABC by Yukio Miyasaka]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: cadicalSolver.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "ccadical.h"
+#include "cadicalSolver.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [allocate solver]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+cadical_solver* cadical_solver_new(void) {
+  cadical_solver* s = (cadical_solver*)malloc(sizeof(cadical_solver));
+  s->p = (void*)ccadical_init();
+  s->nVars = 0;
+  s->vAssumptions = NULL;
+  s->vCore = NULL;
+  return s;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [delete solver]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void cadical_solver_delete(cadical_solver* s) {
+  ccadical_release((CCaDiCaL*)s->p);
+  if(s->vAssumptions) {
+    Vec_IntFree(s->vAssumptions);
+  }
+  if(s->vCore) {
+    Vec_IntFree(s->vCore);
+  }
+  free(s);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [add clause]
+
+  Description [cadical takes x and -x as a literal for a variable x > 0,
+               where 0 is an indicator of the end of a clause.
+               since variables start from 0 in abc, a variable v is
+               translated into v + 1 in cadical.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int cadical_solver_addclause(cadical_solver* s, int* begin, int* end) {
+  for(;begin != end; begin++) {
+    if(*begin & 1) {
+      ccadical_add((CCaDiCaL*)s->p, -(1 + ((*begin) >> 1)));
+    } else {
+      ccadical_add((CCaDiCaL*)s->p,   1 + ((*begin) >> 1) );
+    }
+  }
+  ccadical_add((CCaDiCaL*)s->p, 0);
+  return !ccadical_is_inconsistent((CCaDiCaL*)s->p);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [solve with resource limits]
+
+  Description [assumptions and inspection limits are not supported.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int cadical_solver_solve(cadical_solver* s, int* begin, int* end, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal) {
+  // inspection limits are not supported
+  assert(nInsLimit == 0);
+  assert(nInsLimitGlobal == 0);
+  // set conflict limits
+  if(nConfLimit)
+    ccadical_limit((CCaDiCaL*)s->p, "conflicts", nConfLimit);
+  if(nConfLimitGlobal && (nConfLimit == 0 || nConfLimit > nConfLimitGlobal))
+    ccadical_limit((CCaDiCaL*)s->p, "conflicts", nConfLimitGlobal);
+  // assumptions
+  if(begin != end) {
+    // save
+    if(s->vAssumptions == NULL) {
+      s->vAssumptions = Vec_IntAllocArrayCopy(begin, end - begin);
+    } else {
+      Vec_IntClear(s->vAssumptions);
+      Vec_IntGrow(s->vAssumptions, end - begin);
+      Vec_IntPushArray(s->vAssumptions, begin, end - begin);
+    }
+    // assume
+    for(;begin != end; begin++) {
+      if(*begin & 1) {
+        ccadical_assume((CCaDiCaL*)s->p, -(1 + ((*begin) >> 1)));
+      } else {
+        ccadical_assume((CCaDiCaL*)s->p,   1 + ((*begin) >> 1) );
+      }
+    }
+  }
+  // solve
+  int res = ccadical_solve((CCaDiCaL*)s->p);
+  // translate this cadical return value into a corresponding ABC status value
+  switch(res) {
+  case  0: // UNDETERMINED
+    return 0;
+  case 10: // SATISFIABLE
+    return 1;
+  case 20: // UNSATISFIABLE
+    return -1;
+  default:
+    assert(0);
+  }
+  return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [get unsat core]
+
+  Description [following minisat, return number of literals in core,
+               which consists of responsible assumptions, negated.
+               array will be freed by solver.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int cadical_solver_final(cadical_solver* s, int** ppArray) {
+  int v, i;
+  if(s->vCore == NULL) {
+    s->vCore = Vec_IntAlloc(Vec_IntSize(s->vAssumptions));
+  } else {
+    Vec_IntClear(s->vCore);
+  }
+  Vec_IntForEachEntry(s->vAssumptions, v, i) {
+    int failed;
+    if(v & 1) {
+      failed = ccadical_failed((CCaDiCaL*)s->p, -(1 + (v >> 1)));
+    } else {
+      failed = ccadical_failed((CCaDiCaL*)s->p,   1 + (v >> 1) );
+    }
+    if(failed) {
+      Vec_IntPush(s->vCore, Abc_LitNot(v));
+    }
+  }
+  *ppArray = Vec_IntArray(s->vCore);
+  return Vec_IntSize(s->vCore);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [get number of variables]
+
+  Description [emulated using "nVars".]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int cadical_solver_nvars(cadical_solver* s) {
+  return s->nVars;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [add new variable]
+
+  Description [emulated using "nVars".]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int cadical_solver_addvar(cadical_solver* s) {
+  return s->nVars++;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [set number of variables]
+
+  Description [not only emulate with "nVars" but also reserve memory.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void cadical_solver_setnvars(cadical_solver* s,int n) {
+  s->nVars = n;
+  ccadical_reserve((CCaDiCaL*)s->p, n);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [get value of variable]
+
+  Description [cadical returns x (true) or -x (false) for a variable x.
+               note a variable v was translated into v + 1 in cadical.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int cadical_solver_get_var_value(cadical_solver* s, int v) {
+  return ccadical_val((CCaDiCaL*)s->p, v + 1) > 0;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Solves the given CNF using cadical.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * cadical_solve_cnf( Cnf_Dat_t * pCnf, char * pArgs, int nConfs, int nTimeLimit, int fSat, int fUnsat, int fPrintCex, int fVerbose )
+{
+    abctime clk = Abc_Clock();
+    Vec_Int_t * vRes = NULL;
+    int i, * pBeg, * pEnd, RetValue;    
+    if ( fVerbose )
+        printf( "CNF stats: Vars = %6d. Clauses = %7d. Literals = %8d. ", pCnf->nVars, pCnf->nClauses, pCnf->nLiterals );
+    cadical_solver *pSat = cadical_solver_new();
+    cadical_solver_setnvars(pSat, pCnf->nVars);
+    assert(cadical_solver_nvars(pSat) == pCnf->nVars);
+    Cnf_CnfForClause( pCnf, pBeg, pEnd, i ) {
+        if ( !cadical_solver_addclause(pSat, pBeg, pEnd) )
+        {
+            assert( 0 ); // if it happens, can return 1 (unsatisfiable)
+            return NULL;
+        }    
+    }
+    RetValue = cadical_solver_solve(pSat, NULL, NULL, 0, 0, 0, 0);
+    if ( RetValue == 1 )
+      printf( "Result: Satisfiable.  " );
+    else if ( RetValue == -1 )
+      printf( "Result: Unsatisfiable.  " );
+    else
+      printf( "Result: Undecided.  " );
+    if ( RetValue == 1 ) {
+        vRes = Vec_IntAlloc( pCnf->nVars );
+        for ( i = 0; i < pCnf->nVars; i++ )
+          Vec_IntPush( vRes, cadical_solver_get_var_value(pSat, i) );
+    }
+    cadical_solver_delete(pSat);
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+    return vRes;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadicalSolver.h b/src/sat/cadical/cadicalSolver.h
new file mode 100644
index 000000000..0192ada3c
--- /dev/null
+++ b/src/sat/cadical/cadicalSolver.h
@@ -0,0 +1,76 @@
+/**CFile****************************************************************
+
+  FileName    [cadicalSolver.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver CaDiCaL by Armin Biere, University of Freiburg]
+
+  Synopsis    [https://github.com/arminbiere/cadical]
+
+  Author      [Integrated into ABC by Yukio Miyasaka]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: cadicalSolver.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef ABC_SAT_CADICAL_SOLVER_H_
+#define ABC_SAT_CADICAL_SOLVER_H_
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "aig/gia/gia.h"
+#include "sat/cnf/cnf.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct cadical_solver_ cadical_solver;
+struct cadical_solver_
+{
+  void* p;
+  int nVars;
+  Vec_Int_t* vAssumptions;
+  Vec_Int_t* vCore;
+};
+
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+extern cadical_solver*  cadical_solver_new(void);
+extern void             cadical_solver_delete(cadical_solver* s);
+extern int              cadical_solver_addclause(cadical_solver* s, int* begin, int* end);
+extern int              cadical_solver_solve(cadical_solver* s, int* begin, int* end, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal);
+extern int              cadical_solver_final(cadical_solver* s, int** ppArray);
+extern int              cadical_solver_nvars(cadical_solver* s);
+extern int              cadical_solver_addvar(cadical_solver* s);
+extern void             cadical_solver_setnvars(cadical_solver* s,int n);
+extern int              cadical_solver_get_var_value(cadical_solver* s, int v);
+extern Vec_Int_t *      cadical_solve_cnf( Cnf_Dat_t * pCnf, char * pArgs, int nConfs, int nTimeLimit, int fSat, int fUnsat, int fPrintCex, int fVerbose );
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
diff --git a/src/sat/cadical/cadicalTest.c b/src/sat/cadical/cadicalTest.c
new file mode 100644
index 000000000..f3919160b
--- /dev/null
+++ b/src/sat/cadical/cadicalTest.c
@@ -0,0 +1,210 @@
+/**CFile****************************************************************
+
+  FileName    [cadicalTest.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName []
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: cadicalTest.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "cadicalSolver.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+void cadical_solver_test() {
+  int RetValue;
+  int Lits[3];
+  // test 1
+  {
+    cadical_solver *pSat = cadical_solver_new();
+    int a = cadical_solver_addvar(pSat);
+    int b = cadical_solver_addvar(pSat);
+    int c = cadical_solver_addvar(pSat);
+    assert(cadical_solver_nvars(pSat) == 3);
+    Lits[0] = Abc_Var2Lit(a, 0);
+    Lits[1] = Abc_Var2Lit(b, 0);
+    Lits[2] = Abc_Var2Lit(c, 0);
+    printf("adding (a, b, c)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 3);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(a, 0);
+    Lits[1] = Abc_Var2Lit(b, 1);
+    printf("adding (a, !b)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 2);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(a, 1);
+    printf("adding (!a)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 1);
+    assert(RetValue);
+    RetValue = cadical_solver_solve(pSat, NULL, NULL, 0, 0, 0, 0);
+    printf("solved: %d\n", RetValue);
+    assert(RetValue == 1);
+    int a_val = cadical_solver_get_var_value(pSat, a);
+    int b_val = cadical_solver_get_var_value(pSat, b);
+    int c_val = cadical_solver_get_var_value(pSat, c);
+    printf("a = %d, b = %d, c = %d\n", a_val, b_val, c_val);
+    assert(a_val == 0);
+    assert(b_val == 0);
+    assert(c_val == 1);
+    cadical_solver_delete(pSat);
+    printf("test 1 passed\n");
+  }
+  // test 2
+  {
+    cadical_solver *pSat = cadical_solver_new();
+    cadical_solver_setnvars(pSat, 2);
+    assert(cadical_solver_nvars(pSat) == 2);
+    Lits[0] = Abc_Var2Lit(0, 0);
+    Lits[1] = Abc_Var2Lit(1, 0);
+    printf("adding (x0, x1)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 2);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 0);
+    Lits[1] = Abc_Var2Lit(1, 1);
+    printf("adding (x0, !x1)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 2);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 1);
+    Lits[1] = Abc_Var2Lit(1, 1);
+    printf("adding (!x0, !x1)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 2);
+    assert(RetValue);
+    RetValue = cadical_solver_solve(pSat, NULL, NULL, 0, 0, 0, 0);
+    printf("solved: %d\n", RetValue);
+    assert(RetValue == 1);
+    printf("x0 = %d, x1 = %d\n", cadical_solver_get_var_value(pSat, 0), cadical_solver_get_var_value(pSat, 1));
+    assert(cadical_solver_get_var_value(pSat, 0) == 1);
+    assert(cadical_solver_get_var_value(pSat, 1) == 0);
+    cadical_solver_delete(pSat);
+    printf("test 2 passed\n");
+  }
+  // test 3
+  {
+    cadical_solver *pSat = cadical_solver_new();
+    cadical_solver_setnvars(pSat, 3);
+    assert(cadical_solver_nvars(pSat) == 3);
+    Lits[0] = Abc_Var2Lit(0, 1);
+    Lits[1] = Abc_Var2Lit(1, 0);
+    Lits[2] = Abc_Var2Lit(2, 1);
+    printf("adding (!x0, x1, !x2)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 3);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 0);
+    printf("adding (x0)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 1);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(1, 1);
+    printf("adding (!x1)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 1);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(2, 0);
+    printf("adding (x2)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 1);
+    RetValue = cadical_solver_solve(pSat, NULL, NULL, 0, 0, 0, 0);
+    printf("solved: %d\n", RetValue);
+    assert(RetValue == -1);
+    cadical_solver_delete(pSat);
+    printf("test 3 passed\n");
+  }
+  // test 4
+  {
+    cadical_solver *pSat = cadical_solver_new();
+    cadical_solver_setnvars(pSat, 3);
+    assert(cadical_solver_nvars(pSat) == 3);
+    Lits[0] = Abc_Var2Lit(0, 1);
+    Lits[1] = Abc_Var2Lit(1, 0);
+    Lits[2] = Abc_Var2Lit(2, 1);
+    printf("adding (!x0, x1, !x2)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 3);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 0);
+    printf("adding (x0)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 1);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(1, 1);
+    printf("assume (!x1)\n");
+    RetValue = cadical_solver_solve(pSat, Lits, Lits + 1, 0, 0, 0, 0);
+    printf("solved: %d\n", RetValue);
+    assert(RetValue == 1);
+    printf("x0 = %d, x1 = %d, x2 = %d\n", cadical_solver_get_var_value(pSat, 0), cadical_solver_get_var_value(pSat, 1), cadical_solver_get_var_value(pSat, 2));
+    assert(cadical_solver_get_var_value(pSat, 0) == 1);
+    assert(cadical_solver_get_var_value(pSat, 1) == 0);
+    assert(cadical_solver_get_var_value(pSat, 2) == 0);
+    cadical_solver_delete(pSat);
+    printf("test 4 passed\n");
+  }
+  // test 5
+  {
+    cadical_solver *pSat = cadical_solver_new();
+    cadical_solver_setnvars(pSat, 3);
+    assert(cadical_solver_nvars(pSat) == 3);
+    Lits[0] = Abc_Var2Lit(0, 1);
+    Lits[1] = Abc_Var2Lit(1, 0);
+    Lits[2] = Abc_Var2Lit(2, 1);
+    printf("adding (!x0, x1, !x2)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 3);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 1);
+    Lits[1] = Abc_Var2Lit(1, 1);
+    Lits[2] = Abc_Var2Lit(2, 1);
+    printf("adding (!x0, !x1, !x2)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 3);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 0);
+    printf("adding (x0)\n");
+    RetValue = cadical_solver_addclause(pSat, Lits, Lits + 1);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(1, 0);
+    Lits[1] = Abc_Var2Lit(2, 0);
+    printf("assume (x1, x2)\n");
+    RetValue = cadical_solver_solve(pSat, Lits, Lits + 2, 0, 0, 0, 0);
+    printf("solved: %d\n", RetValue);
+    assert(RetValue == -1);
+    int *pCore;
+    int nSize = cadical_solver_final(pSat, &pCore);
+    printf("core: ");
+    for(int i = 0; i < nSize; i++) {
+      if(i) {
+        printf(", ");
+      }
+      if(Abc_LitIsCompl(pCore[i])) {
+        printf("!");
+      }
+      printf("x%d", Abc_Lit2Var(pCore[i]));
+    }
+    printf("\n");
+    int neg_x2_in_core = 0;
+    for(int i = 0; i < nSize; i++) {
+      if(Abc_LitIsCompl(pCore[i]) &&  Abc_Lit2Var(pCore[i]) == 2) {
+        neg_x2_in_core = 1;
+      }
+    }
+    assert(neg_x2_in_core);
+    cadical_solver_delete(pSat);
+    printf("test 5 passed\n");
+  }
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_analyze.cpp b/src/sat/cadical/cadical_analyze.cpp
new file mode 100644
index 000000000..74b67fb06
--- /dev/null
+++ b/src/sat/cadical/cadical_analyze.cpp
@@ -0,0 +1,1285 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Code for conflict analysis, i.e., to generate the first UIP clause.  The
+// main function is 'analyze' below.  It further uses 'minimize' to minimize
+// the first UIP clause, which is in 'minimize.cpp'.  An important side
+// effect of conflict analysis is to update the decision queue by bumping
+// variables.  Similarly analyzed clauses are bumped to mark them as active.
+
+/*------------------------------------------------------------------------*/
+
+void Internal::learn_empty_clause () {
+  CADICAL_assert (!unsat);
+  build_chain_for_empty ();
+  LOG ("learned empty clause");
+  external->check_learned_empty_clause ();
+  int64_t id = ++clause_id;
+  if (proof) {
+    proof->add_derived_empty_clause (id, lrat_chain);
+  }
+  unsat = true;
+  conflict_id = id;
+  marked_failed = true;
+  conclusion.push_back (id);
+  lrat_chain.clear ();
+}
+
+void Internal::learn_unit_clause (int lit) {
+  CADICAL_assert (!unsat);
+  LOG ("learned unit clause %d, stored at position %d", lit, vlit (lit));
+  external->check_learned_unit_clause (lit);
+  int64_t id = ++clause_id;
+  if (lrat || frat) {
+    const unsigned uidx = vlit (lit);
+    unit_clauses (uidx) = id;
+  }
+  if (proof) {
+    proof->add_derived_unit_clause (id, lit, lrat_chain);
+  }
+  mark_fixed (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Move bumped variables to the front of the (VMTF) decision queue.  The
+// 'bumped' time stamp is updated accordingly.  It is used to determine
+// whether the 'queue.assigned' pointer has to be moved in 'unassign'.
+
+void Internal::bump_queue (int lit) {
+  CADICAL_assert (opts.bump);
+  const int idx = vidx (lit);
+  if (!links[idx].next)
+    return;
+  queue.dequeue (links, idx);
+  queue.enqueue (links, idx);
+  CADICAL_assert (stats.bumped != INT64_MAX);
+  btab[idx] = ++stats.bumped;
+  LOG ("moved to front variable %d and bumped to %" PRId64 "", idx,
+       btab[idx]);
+  if (!vals[idx])
+    update_queue_unassigned (idx);
+}
+
+/*------------------------------------------------------------------------*/
+
+// It would be better to use 'isinf' but there are some historical issues
+// with this function.  On some platforms it is a macro and even for C++ it
+// changed the scope (in pre 5.0 gcc) from '::isinf' to 'std::isinf'.  I do
+// not want to worry about these strange incompatibilities and thus use the
+// same trick as in older solvers (since the MiniSAT team invented EVSIDS)
+// and simply put a hard limit here.  It is less elegant but easy to port.
+
+static inline bool evsids_limit_hit (double score) {
+  CADICAL_assert (sizeof (score) == 8); // assume IEEE 754 64-bit double
+  return score > 1e150;         // MAX_DOUBLE is around 1.8e308
+}
+
+/*------------------------------------------------------------------------*/
+
+// Classical exponential VSIDS as pioneered by MiniSAT.
+
+void Internal::rescale_variable_scores () {
+  stats.rescored++;
+  double divider = score_inc;
+  for (auto idx : vars) {
+    const double tmp = stab[idx];
+    if (tmp > divider)
+      divider = tmp;
+  }
+  PHASE ("rescore", stats.rescored, "rescoring %d variable scores by 1/%g",
+         max_var, divider);
+  CADICAL_assert (divider > 0);
+  double factor = 1.0 / divider;
+  for (auto idx : vars)
+    stab[idx] *= factor;
+  score_inc *= factor;
+  PHASE ("rescore", stats.rescored,
+         "new score increment %g after %" PRId64 " conflicts", score_inc,
+         stats.conflicts);
+}
+
+void Internal::bump_variable_score (int lit) {
+  CADICAL_assert (opts.bump);
+  int idx = vidx (lit);
+  double old_score = score (idx);
+  CADICAL_assert (!evsids_limit_hit (old_score));
+  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);
+    rescale_variable_scores ();
+    old_score = score (idx);
+    CADICAL_assert (!evsids_limit_hit (old_score));
+    new_score = old_score + score_inc;
+  }
+  CADICAL_assert (!evsids_limit_hit (new_score));
+  LOG ("new %g score of %d", new_score, idx);
+  score (idx) = new_score;
+  if (scores.contains (idx))
+    scores.update (idx);
+}
+
+// Important variables recently used in conflict analysis are 'bumped',
+
+void Internal::bump_variable (int lit) {
+  if (use_scores ())
+    bump_variable_score (lit);
+  else
+    bump_queue (lit);
+}
+
+// After every conflict the variable score increment is increased by a
+// factor (if we are currently using scores).
+
+void Internal::bump_variable_score_inc () {
+  CADICAL_assert (use_scores ());
+  CADICAL_assert (!evsids_limit_hit (score_inc));
+  double f = 1e3 / opts.scorefactor;
+  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;
+  }
+  CADICAL_assert (!evsids_limit_hit (new_score_inc));
+  LOG ("bumped score increment from %g to %g with factor %g", score_inc,
+       new_score_inc, f);
+  score_inc = new_score_inc;
+}
+
+/*------------------------------------------------------------------------*/
+
+struct analyze_bumped_rank {
+  Internal *internal;
+  analyze_bumped_rank (Internal *i) : internal (i) {}
+  typedef uint64_t Type;
+  Type operator() (const int &a) const { return internal->bumped (a); }
+};
+
+struct analyze_bumped_smaller {
+  Internal *internal;
+  analyze_bumped_smaller (Internal *i) : internal (i) {}
+  bool operator() (const int &a, const int &b) const {
+    const auto s = analyze_bumped_rank (internal) (a);
+    const auto t = analyze_bumped_rank (internal) (b);
+    return s < t;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+void Internal::bump_variables () {
+
+  CADICAL_assert (opts.bump);
+
+  START (bump);
+
+  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.
+
+    MSORT (opts.radixsortlim, analyzed.begin (), analyzed.end (),
+           analyze_bumped_rank (this), analyze_bumped_smaller (this));
+  }
+
+  for (const auto &lit : analyzed)
+    bump_variable (lit);
+
+  if (use_scores ())
+    bump_variable_score_inc ();
+
+  STOP (bump);
+}
+
+/*------------------------------------------------------------------------*/
+
+// We use the glue time stamp table 'gtab' for fast glue computation.
+
+int Internal::recompute_glue (Clause *c) {
+  int res = 0;
+  const int64_t stamp = ++stats.recomputed;
+  for (const auto &lit : *c) {
+    int level = var (lit).level;
+    CADICAL_assert (gtab[level] <= stamp);
+    if (gtab[level] == stamp)
+      continue;
+    gtab[level] = stamp;
+    res++;
+  }
+  return res;
+}
+
+// Clauses resolved since the last reduction are marked as 'used', their
+// 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) {
+  LOG (c, "bumping");
+  c->used = max_used;
+  if (c->hyper)
+    return;
+  if (!c->redundant)
+    return;
+  int new_glue = recompute_glue (c);
+  if (new_glue < c->glue)
+    promote_clause (c, new_glue);
+
+  const size_t glue =
+      std::min ((size_t) c->glue, stats.used[stable].size () - 1);
+  ++stats.used[stable][glue];
+  ++stats.bump_used[stable];
+}
+
+void Internal::bump_clause2 (Clause *c) { bump_clause (c); }
+/*------------------------------------------------------------------------*/
+
+// During conflict analysis literals not seen yet either become part of the
+// first unique implication point (UIP) clause (if on lower decision level),
+// are dropped (if fixed), or are resolved away (if on the current decision
+// level and different from the first UIP).  At the same time we update the
+// number of seen literals on a decision level.  This helps conflict clause
+// minimization.  The number of seen levels is the glucose level (also
+// called 'glue', or 'LBD').
+
+inline void Internal::analyze_literal (int lit, int &open,
+                                       int &resolvent_size,
+                                       int &antecedent_size) {
+  CADICAL_assert (lit);
+  Var &v = var (lit);
+  Flags &f = flags (lit);
+
+  if (!v.level) {
+    if (f.seen || !lrat)
+      return;
+    f.seen = true;
+    unit_analyzed.push_back (lit);
+    CADICAL_assert (val (lit) < 0);
+    int64_t id = unit_id (-lit);
+    unit_chain.push_back (id);
+    return;
+  }
+  ++antecedent_size;
+  if (f.seen)
+    return;
+
+  // before marking as seen, get reason and check for missed unit
+
+  CADICAL_assert (val (lit) < 0);
+  CADICAL_assert (v.level <= level);
+  if (v.reason == external_reason) {
+    CADICAL_assert (!opts.exteagerreasons);
+    v.reason = learn_external_reason_clause (-lit, 0, true);
+    if (!v.reason) { // actually a unit
+      --antecedent_size;
+      LOG ("%d unit after explanation", -lit);
+      if (f.seen || !lrat)
+        return;
+      f.seen = true;
+      unit_analyzed.push_back (lit);
+      CADICAL_assert (val (lit) < 0);
+      const unsigned uidx = vlit (-lit);
+      int64_t id = unit_clauses (uidx);
+      CADICAL_assert (id);
+      unit_chain.push_back (id);
+      return;
+    }
+  }
+
+  f.seen = true;
+  analyzed.push_back (lit);
+
+  CADICAL_assert (v.reason != external_reason);
+  if (v.level < level)
+    clause.push_back (lit);
+  Level &l = control[v.level];
+  if (!l.seen.count++) {
+    LOG ("found new level %d contributing to conflict", v.level);
+    levels.push_back (v.level);
+  }
+  if (v.trail < l.seen.trail)
+    l.seen.trail = v.trail;
+  ++resolvent_size;
+  LOG ("analyzed literal %d assigned at level %d", lit, v.level);
+  if (v.level == level)
+    open++;
+}
+
+inline void Internal::analyze_reason (int lit, Clause *reason, int &open,
+                                      int &resolvent_size,
+                                      int &antecedent_size) {
+  CADICAL_assert (reason);
+  CADICAL_assert (reason != external_reason);
+  bump_clause (reason);
+  if (lrat)
+    lrat_chain.push_back (reason->id);
+  for (const auto &other : *reason)
+    if (other != lit)
+      analyze_literal (other, open, resolvent_size, antecedent_size);
+}
+
+/*------------------------------------------------------------------------*/
+
+// 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) {
+  CADICAL_assert (lit);
+  CADICAL_assert (val (lit) < 0);
+  Flags &f = flags (lit);
+  if (f.seen)
+    return false;
+  const Var &v = var (lit);
+  if (!v.level)
+    return false;
+  f.seen = true;
+  analyzed.push_back (lit);
+  LOG ("bumping also reason literal %d assigned at level %d", lit, v.level);
+  return true;
+}
+
+// We experimented with deeper reason bumping without much success though.
+
+inline void Internal::bump_also_reason_literals (int lit, int depth_limit,
+                                                 size_t analyzed_limit) {
+  CADICAL_assert (lit);
+  CADICAL_assert (depth_limit > 0);
+  const Var &v = var (lit);
+  CADICAL_assert (val (lit));
+  if (!v.level)
+    return;
+  Clause *reason = v.reason;
+  if (!reason || reason == external_reason)
+    return;
+  stats.ticks.search[stable]++;
+  for (const auto &other : *reason) {
+    if (other == lit)
+      continue;
+    if (!bump_also_reason_literal (other))
+      continue;
+    if (depth_limit < 2)
+      continue;
+    bump_also_reason_literals (-other, depth_limit - 1, analyzed_limit);
+    if (analyzed.size () > analyzed_limit)
+      break;
+  }
+}
+
+inline void Internal::bump_also_all_reason_literals () {
+  CADICAL_assert (opts.bump);
+  if (!opts.bumpreason)
+    return;
+  if (averages.current.decisions > opts.bumpreasonrate) {
+    LOG ("decisions per conflict rate %g > limit %d",
+         (double) averages.current.decisions, opts.bumpreasonrate);
+    return;
+  }
+  if (delay[stable].bumpreasons.limit) {
+    LOG ("delaying reason bumping %" PRId64 " more times",
+         delay[stable].bumpreasons.limit);
+    delay[stable].bumpreasons.limit--;
+    return;
+  }
+  CADICAL_assert (opts.bumpreasondepth > 0);
+  const int depth_limit = opts.bumpreasondepth + stable;
+  size_t saved_analyzed = analyzed.size ();
+  size_t analyzed_limit = saved_analyzed * opts.bumpreasonlimit;
+  for (const auto &lit : clause)
+    if (analyzed.size () <= analyzed_limit)
+      bump_also_reason_literals (-lit, depth_limit, analyzed_limit);
+    else
+      break;
+  if (analyzed.size () > analyzed_limit) {
+    LOG ("not bumping reason side literals as limit exhausted");
+    for (size_t i = saved_analyzed; i != analyzed.size (); i++) {
+      const int lit = analyzed[i];
+      Flags &f = flags (lit);
+      CADICAL_assert (f.seen);
+      f.seen = false;
+    }
+    delay[stable].bumpreasons.interval++;
+    analyzed.resize (saved_analyzed);
+  } else {
+    LOG ("bumping reasons up to depth %d", opts.bumpreasondepth);
+    delay[stable].bumpreasons.interval /= 2;
+  }
+  LOG ("delay internal %" PRId64, delay[stable].bumpreasons.interval);
+  delay[stable].bumpreasons.limit = delay[stable].bumpreasons.interval;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::clear_unit_analyzed_literals () {
+  LOG ("clearing %zd unit analyzed literals", unit_analyzed.size ());
+  for (const auto &lit : unit_analyzed) {
+    Flags &f = flags (lit);
+    CADICAL_assert (f.seen);
+    CADICAL_assert (!var (lit).level);
+    f.seen = false;
+    CADICAL_assert (!f.keep);
+    CADICAL_assert (!f.poison);
+    CADICAL_assert (!f.removable);
+  }
+  unit_analyzed.clear ();
+}
+
+void Internal::clear_analyzed_literals () {
+  LOG ("clearing %zd analyzed literals", analyzed.size ());
+  for (const auto &lit : analyzed) {
+    Flags &f = flags (lit);
+    CADICAL_assert (f.seen);
+    f.seen = false;
+    CADICAL_assert (!f.keep);
+    CADICAL_assert (!f.poison);
+    CADICAL_assert (!f.removable);
+  }
+  analyzed.clear ();
+#if 0 // to expensive, even for debugging mode
+  if (unit_analyzed.size ())
+    return;
+  for (auto idx : vars) {
+    Flags &f = flags (idx);
+    CADICAL_assert (!f.seen);
+  }
+#endif
+}
+
+void Internal::clear_analyzed_levels () {
+  LOG ("clearing %zd analyzed levels", levels.size ());
+  for (const auto &l : levels)
+    if (l < (int) control.size ())
+      control[l].reset ();
+  levels.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Smaller level and trail.  Comparing literals on their level is necessary
+// for chronological backtracking, since trail order might in this case not
+// respect level order.
+
+struct analyze_trail_negative_rank {
+  Internal *internal;
+  analyze_trail_negative_rank (Internal *s) : internal (s) {}
+  typedef uint64_t Type;
+  Type operator() (int a) {
+    Var &v = internal->var (a);
+    uint64_t res = v.level;
+    res <<= 32;
+    res |= v.trail;
+    return ~res;
+  }
+};
+
+struct analyze_trail_larger {
+  Internal *internal;
+  analyze_trail_larger (Internal *s) : internal (s) {}
+  bool operator() (const int &a, const int &b) const {
+    return analyze_trail_negative_rank (internal) (a) <
+           analyze_trail_negative_rank (internal) (b);
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Generate new driving clause and compute jump level.
+
+Clause *Internal::new_driving_clause (const int glue, int &jump) {
+
+  const size_t size = clause.size ();
+  Clause *res;
+
+  if (!size) {
+
+    jump = 0;
+    res = 0;
+
+  } else if (size == 1) {
+
+    iterating = true;
+    jump = 0;
+    res = 0;
+
+  } else {
+
+    CADICAL_assert (clause.size () > 1);
+
+    // We have to get the last assigned literals into the watch position.
+    // Sorting all literals with respect to reverse assignment order is
+    // overkill but seems to get slightly faster run-time.  For 'minimize'
+    // we sort the literals too heuristically along the trail order (so in
+    // the opposite order) with the hope to hit the recursion limit less
+    // frequently.  Thus sorting effort is doubled here.
+    //
+    MSORT (opts.radixsortlim, clause.begin (), clause.end (),
+           analyze_trail_negative_rank (this), analyze_trail_larger (this));
+
+    jump = var (clause[1]).level;
+    res = new_learned_redundant_clause (glue);
+    res->used = 1 + (glue <= opts.reducetier2glue);
+  }
+
+  LOG ("jump level %d", jump);
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// determine the OTFS level for OTFS. Unlike the find_conflict_level, we do
+// not have to fix the clause
+
+inline int Internal::otfs_find_backtrack_level (int &forced) {
+  CADICAL_assert (opts.otfs);
+  int res = 0;
+
+  for (const auto &lit : *conflict) {
+    const int tmp = var (lit).level;
+    if (tmp == level) {
+      forced = lit;
+    } else if (tmp > res) {
+      res = tmp;
+      LOG ("bt level is now %d due to %d", res, lit);
+    }
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// If chronological backtracking is enabled we need to find the actual
+// conflict level and then potentially can also reuse the conflict clause
+// as driving clause instead of deriving a redundant new driving clause
+// (forcing 'forced') if the number 'count' of literals in conflict assigned
+// at the conflict level is exactly one.
+
+inline int Internal::find_conflict_level (int &forced) {
+
+  CADICAL_assert (conflict);
+  CADICAL_assert (opts.chrono || opts.otfs || external_prop);
+
+  int res = 0, count = 0;
+
+  forced = 0;
+
+  for (const auto &lit : *conflict) {
+    const int tmp = var (lit).level;
+    if (tmp > res) {
+      res = tmp;
+      forced = lit;
+      count = 1;
+    } else if (tmp == res) {
+      count++;
+      if (res == level && count > 1)
+        break;
+    }
+  }
+
+  LOG ("%d literals on actual conflict level %d", count, res);
+
+  const int size = conflict->size;
+  int *lits = conflict->literals;
+
+  // Move the two highest level literals to the front.
+  //
+  for (int i = 0; i < 2; i++) {
+
+    const int lit = lits[i];
+
+    int highest_position = i;
+    int highest_literal = lit;
+    int highest_level = var (highest_literal).level;
+
+    for (int j = i + 1; j < size; j++) {
+      const int other = lits[j];
+      const int tmp = var (other).level;
+      if (highest_level >= tmp)
+        continue;
+      highest_literal = other;
+      highest_position = j;
+      highest_level = tmp;
+      if (highest_level == res)
+        break;
+    }
+
+    // No unwatched higher assignment level literal.
+    //
+    if (highest_position == i)
+      continue;
+
+    if (highest_position > 1) {
+      LOG (conflict, "unwatch %d in", lit);
+      remove_watch (watches (lit), conflict);
+    }
+
+    lits[highest_position] = lit;
+    lits[i] = highest_literal;
+
+    if (highest_position > 1)
+      watch_literal (highest_literal, lits[!i], conflict);
+  }
+
+  // Only if the number of highest level literals in the conflict is one
+  // then we can reuse the conflict clause as driving clause for 'forced'.
+  //
+  if (count != 1)
+    forced = 0;
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline int Internal::determine_actual_backtrack_level (int jump) {
+
+  int res;
+
+  CADICAL_assert (level > jump);
+
+  if (!opts.chrono) {
+    res = jump;
+    LOG ("chronological backtracking disabled using jump level %d", res);
+  } else if (opts.chronoalways) {
+    stats.chrono++;
+    res = level - 1;
+    LOG ("forced chronological backtracking to level %d", res);
+  } else if (jump >= level - 1) {
+    res = jump;
+    LOG ("jump level identical to chronological backtrack level %d", res);
+  } else if ((size_t) jump < assumptions.size ()) {
+    res = jump;
+    LOG ("using jump level %d since it is lower than assumption level %zd",
+         res, assumptions.size ());
+  } else if (level - jump > opts.chronolevelim) {
+    stats.chrono++;
+    res = level - 1;
+    LOG ("back-jumping over %d > %d levels prohibited"
+         "thus backtracking chronologically to level %d",
+         level - jump, opts.chronolevelim, res);
+  } else if (opts.chronoreusetrail) {
+    int best_idx = 0, best_pos = 0;
+
+    if (use_scores ()) {
+      for (size_t i = control[jump + 1].trail; i < trail.size (); i++) {
+        const int idx = abs (trail[i]);
+        if (best_idx && !score_smaller (this) (best_idx, idx))
+          continue;
+        best_idx = idx;
+        best_pos = i;
+      }
+      LOG ("best variable score %g", score (best_idx));
+    } else {
+      for (size_t i = control[jump + 1].trail; i < trail.size (); i++) {
+        const int idx = abs (trail[i]);
+        if (best_idx && bumped (best_idx) >= bumped (idx))
+          continue;
+        best_idx = idx;
+        best_pos = i;
+      }
+      LOG ("best variable bumped %" PRId64 "", bumped (best_idx));
+    }
+    CADICAL_assert (best_idx);
+    LOG ("best variable %d at trail position %d", best_idx, best_pos);
+
+    // Now find the frame and decision level in the control stack of that
+    // best variable index.  Note that, as in 'reuse_trail', the frame
+    // 'control[i]' for decision level 'i' contains the trail before that
+    // decision level, i.e., the decision 'control[i].decision' sits at
+    // 'control[i].trail' in the trail and we thus have to check the level
+    // of the control frame one higher than at the result level.
+    //
+    res = jump;
+    while (res < level - 1 && control[res + 1].trail <= best_pos)
+      res++;
+
+    if (res == jump)
+      LOG ("default non-chronological back-jumping to level %d", res);
+    else {
+      stats.chrono++;
+      LOG ("chronological backtracking to level %d to reuse trail", res);
+    }
+
+  } else {
+    res = jump;
+    LOG ("non-chronological back-jumping to level %d", res);
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::eagerly_subsume_recently_learned_clauses (Clause *c) {
+  CADICAL_assert (opts.eagersubsume);
+  LOG (c, "trying eager subsumption with");
+  mark (c);
+  int64_t lim = stats.eagertried + opts.eagersubsumelim;
+  const auto begin = clauses.begin ();
+  auto it = clauses.end ();
+#ifdef LOGGING
+  int64_t before = stats.eagersub;
+#endif
+  while (it != begin && stats.eagertried++ <= lim) {
+    Clause *d = *--it;
+    if (c == d)
+      continue;
+    if (d->garbage)
+      continue;
+    if (!d->redundant)
+      continue;
+    int needed = c->size;
+    for (auto &lit : *d) {
+      if (marked (lit) <= 0)
+        continue;
+      if (!--needed)
+        break;
+    }
+    if (needed)
+      continue;
+    LOG (d, "eager subsumed");
+    stats.eagersub++;
+    stats.subsumed++;
+    mark_garbage (d);
+  }
+  unmark (c);
+#ifdef LOGGING
+  uint64_t subsumed = stats.eagersub - before;
+  if (subsumed)
+    LOG ("eagerly subsumed %" PRIu64 " clauses", subsumed);
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+Clause *Internal::on_the_fly_strengthen (Clause *new_conflict, int uip) {
+  CADICAL_assert (new_conflict);
+  CADICAL_assert (new_conflict->size > 2);
+  LOG (new_conflict, "applying OTFS on lit %d", uip);
+  auto sorted = std::vector<int> ();
+  sorted.reserve (new_conflict->size);
+  CADICAL_assert (sorted.empty ());
+  ++stats.otfs.strengthened;
+
+  int *lits = new_conflict->literals;
+
+  CADICAL_assert (lits[0] == uip || lits[1] == uip);
+  const int other_init = lits[0] ^ lits[1] ^ uip;
+
+  CADICAL_assert (mini_chain.empty ());
+
+  const int old_size = new_conflict->size;
+  int new_size = 0;
+  for (int i = 0; i < old_size; ++i) {
+    const int other = lits[i];
+    sorted.push_back (other);
+    if (var (other).level)
+      lits[new_size++] = other;
+  }
+
+  LOG (new_conflict, "removing all units in");
+
+  CADICAL_assert (lits[0] == uip || lits[1] == uip);
+  const int other = lits[0] ^ lits[1] ^ uip;
+  lits[0] = other;
+  lits[1] = lits[--new_size];
+  LOG (new_conflict, "putting uip at pos 1");
+
+  if (other_init != other)
+    remove_watch (watches (other_init), new_conflict);
+  remove_watch (watches (uip), new_conflict);
+
+  CADICAL_assert (!lrat || lrat_chain.back () == new_conflict->id);
+  if (lrat) {
+    CADICAL_assert (!lrat_chain.empty ());
+    for (const auto &id : unit_chain) {
+      mini_chain.push_back (id);
+    }
+    const auto end = lrat_chain.rend ();
+    const auto begin = lrat_chain.rbegin ();
+    for (auto i = begin; i != end; i++) {
+      const auto id = *i;
+      mini_chain.push_back (id);
+    }
+    lrat_chain.clear ();
+    clear_unit_analyzed_literals ();
+    unit_chain.clear ();
+  }
+  CADICAL_assert (unit_analyzed.empty ());
+  // sort the clause
+  {
+    int highest_pos = 0;
+    int highest_level = 0;
+    for (int i = 1; i < new_size; i++) {
+      const unsigned other = lits[i];
+      CADICAL_assert (val (other) < 0);
+      const int level = var (other).level;
+      CADICAL_assert (level);
+      LOG ("checking %d", other);
+      if (level <= highest_level)
+        continue;
+      highest_pos = i;
+      highest_level = level;
+    }
+    LOG ("highest lit is %d", lits[highest_pos]);
+    if (highest_pos != 1)
+      swap (lits[1], lits[highest_pos]);
+    LOG ("removing %d literals", new_conflict->size - new_size);
+
+    if (new_size == 1) {
+      LOG (new_conflict, "new size = 1, so interrupting");
+      CADICAL_assert (!opts.exteagerreasons);
+      return 0;
+    } else {
+      otfs_strengthen_clause (new_conflict, uip, new_size, sorted);
+      CADICAL_assert (new_size == new_conflict->size);
+    }
+  }
+
+  if (other_init != other)
+    watch_literal (other, lits[1], new_conflict);
+  else {
+    update_watch_size (watches (other), lits[1], new_conflict);
+  }
+  watch_literal (lits[1], other, new_conflict);
+
+  LOG (new_conflict, "strengthened clause by OTFS");
+  sorted.clear ();
+
+  return new_conflict;
+}
+
+/*------------------------------------------------------------------------*/
+inline void Internal::otfs_subsume_clause (Clause *subsuming,
+                                           Clause *subsumed) {
+  stats.subsumed++;
+  CADICAL_assert (subsuming->size <= subsumed->size);
+  LOG (subsumed, "subsumed");
+  if (subsumed->redundant)
+    stats.subred++;
+  else
+    stats.subirr++;
+  if (subsumed->redundant || !subsuming->redundant) {
+    mark_garbage (subsumed);
+    return;
+  }
+  LOG ("turning redundant subsuming clause into irredundant clause");
+  subsuming->redundant = false;
+  if (proof)
+    proof->strengthen (subsuming->id);
+  mark_garbage (subsumed);
+  stats.current.irredundant++;
+  stats.added.irredundant++;
+  stats.irrlits += subsuming->size;
+  CADICAL_assert (stats.current.redundant > 0);
+  stats.current.redundant--;
+  CADICAL_assert (stats.added.redundant > 0);
+  stats.added.redundant--;
+  // ... and keep 'stats.added.total'.
+}
+
+/*------------------------------------------------------------------------*/
+
+// Candidate clause 'c' is strengthened by removing 'lit' and units.
+//
+void Internal::otfs_strengthen_clause (Clause *c, int lit, int new_size,
+                                       const std::vector<int> &old) {
+  stats.strengthened++;
+  CADICAL_assert (c->size > 2);
+  (void) shrink_clause (c, new_size);
+  if (proof) {
+    proof->otfs_strengthen_clause (c, old, mini_chain);
+  }
+  if (!c->redundant) {
+    mark_removed (lit);
+  }
+  mini_chain.clear ();
+  c->used = true;
+  LOG (c, "strengthened");
+  external->check_shrunken_clause (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// If the average number of decisions per conflict (analysis actually so not
+// taking OTFS conflicts into account) is high we do not bump reasons. This
+// is the function which updates the exponential moving decision rate
+// average.
+
+void Internal::update_decision_rate_average () {
+  int64_t current = stats.decisions;
+  int64_t decisions = current - saved_decisions;
+  UPDATE_AVERAGE (averages.current.decisions, decisions);
+  saved_decisions = current;
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the main conflict analysis routine.  It assumes that a conflict
+// was found.  Then we derive the 1st UIP clause, optionally minimize it,
+// add it as learned clause, and then uses the clause for conflict directed
+// back-jumping and flipping the 1st UIP literal.  In combination with
+// chronological backtracking (see discussion above) the algorithm becomes
+// slightly more involved.
+
+void Internal::analyze () {
+
+  START (analyze);
+
+  CADICAL_assert (conflict);
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (unit_chain.empty ());
+  CADICAL_assert (unit_analyzed.empty ());
+  CADICAL_assert (clause.empty ());
+
+  // First update moving averages of trail height at conflict.
+  //
+  UPDATE_AVERAGE (averages.current.trail.fast, num_assigned);
+  UPDATE_AVERAGE (averages.current.trail.slow, num_assigned);
+  update_decision_rate_average ();
+
+  /*----------------------------------------------------------------------*/
+
+  if (external_prop && !external_prop_is_lazy && opts.exteagerreasons) {
+    explain_external_propagations ();
+  }
+
+  if (opts.chrono || external_prop) {
+
+    int forced;
+
+    const int conflict_level = find_conflict_level (forced);
+
+    // In principle we can perform conflict analysis as in non-chronological
+    // backtracking except if there is only one literal with the maximum
+    // assignment level in the clause.  Then standard conflict analysis is
+    // unnecessary and we can use the conflict as a driving clause.  In the
+    // pseudo code of the SAT'18 paper on chronological backtracking this
+    // corresponds to the situation handled in line 4-6 in Alg. 1, except
+    // that the pseudo code in the paper only backtracks while we eagerly
+    // assign the single literal on the highest decision level.
+
+    if (forced) {
+
+      CADICAL_assert (forced);
+      CADICAL_assert (conflict_level > 0);
+      LOG ("single highest level literal %d", forced);
+
+      // The pseudo code in the SAT'18 paper actually backtracks to the
+      // 'second highest decision' level, while their code backtracks
+      // to 'conflict_level-1', which is more in the spirit of chronological
+      // backtracking anyhow and thus we also do the latter.
+      //
+      backtrack (conflict_level - 1);
+
+      // if we are on decision level 0 search assign will learn unit
+      // so we need a valid chain here (of course if we are not on decision
+      // level 0 this will not result in a valid chain).
+      // we can just use build_chain_for_units in propagate
+      //
+      build_chain_for_units (forced, conflict, 0);
+
+      LOG ("forcing %d", forced);
+      search_assign_driving (forced, conflict);
+
+      conflict = 0;
+      STOP (analyze);
+      return;
+    }
+
+    // Backtracking to the conflict level is in the pseudo code in the
+    // SAT'18 chronological backtracking paper, but not in their actual
+    // implementation.  In principle we do not need to backtrack here.
+    // However, as a side effect of backtracking to the conflict level we
+    // set 'level' to the conflict level which then allows us to reuse the
+    // old 'analyze' code as is.  The alternative (which we also tried but
+    // then abandoned) is to use 'conflict_level' instead of 'level' in the
+    // analysis, which however requires to pass it to the 'analyze_reason'
+    // and 'analyze_literal' functions.
+    //
+    backtrack (conflict_level);
+  }
+
+  // Actual conflict on root level, thus formula unsatisfiable.
+  //
+  if (!level) {
+    learn_empty_clause ();
+    if (external->learner)
+      external->export_learned_empty_clause ();
+    STOP (analyze);
+    return;
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  // First derive the 1st UIP clause by going over literals assigned on the
+  // current decision level.  Literals in the conflict are marked as 'seen'
+  // as well as all literals in reason clauses of already 'seen' literals on
+  // the current decision level.  Thus the outer loop starts with the
+  // conflict clause as 'reason' and then uses the 'reason' of the next
+  // seen literal on the trail assigned on the current decision level.
+  // During this process maintain the number 'open' of seen literals on the
+  // current decision level with not yet processed 'reason'.  As soon 'open'
+  // drops to one, we have found the first unique implication point.  This
+  // is sound because the topological order in which literals are processed
+  // follows the assignment order and a more complex algorithm to find
+  // articulation points is not necessary.
+  //
+  Clause *reason = conflict;
+  LOG (reason, "analyzing conflict");
+
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (lrat_chain.empty ());
+
+  const auto &t = &trail;
+  int i = t->size ();      // Start at end-of-trail.
+  int open = 0;            // Seen but not processed on this level.
+  int uip = 0;             // The first UIP literal.
+  int resolvent_size = 0;  // without the uip
+  int antecedent_size = 1; // with the uip and without unit literals
+  int conflict_size = 0;   // without the uip and without unit literals
+  int resolved = 0;        // number of resolution (0 = clause in CNF)
+  const bool otfs = opts.otfs;
+
+  for (;;) {
+    antecedent_size = 1; // for uip
+    analyze_reason (uip, reason, open, resolvent_size, antecedent_size);
+    if (resolved == 0)
+      conflict_size = antecedent_size - 1;
+    CADICAL_assert (resolvent_size == open + (int) clause.size ());
+
+    if (otfs && resolved > 0 && antecedent_size > 2 &&
+        resolvent_size < antecedent_size) {
+      CADICAL_assert (reason != conflict);
+      LOG (analyzed, "found candidate for OTFS conflict");
+      LOG (clause, "found candidate for OTFS conflict");
+      LOG (reason, "found candidate (size %d) for OTFS resolvent",
+           antecedent_size);
+      const int other = reason->literals[0] ^ reason->literals[1] ^ uip;
+      CADICAL_assert (other != uip);
+      reason = on_the_fly_strengthen (reason, uip);
+      if (opts.bump)
+        bump_variables ();
+
+      CADICAL_assert (conflict_size);
+      if (!reason) {
+        uip = -other;
+        CADICAL_assert (open == 1);
+        LOG ("clause is actually unit %d, stopping", -uip);
+        reverse (begin (mini_chain), end (mini_chain));
+        for (auto id : mini_chain)
+          lrat_chain.push_back (id);
+        mini_chain.clear ();
+        clear_analyzed_levels ();
+        CADICAL_assert (!opts.exteagerreasons);
+        clause.clear ();
+        break;
+      }
+      CADICAL_assert (conflict_size >= 2);
+
+      if (resolved == 1 && resolvent_size < conflict_size) {
+        // here both clauses are part of the CNF, so one subsumes the other
+        otfs_subsume_clause (reason, conflict);
+        LOG (reason, "changing conflict to");
+        --conflict_size;
+        CADICAL_assert (conflict_size == reason->size);
+        ++stats.otfs.subsumed;
+        ++stats.subsumed;
+      }
+
+      LOG (reason, "changing conflict to");
+      conflict = reason;
+      if (open == 1) {
+        int forced = 0;
+        const int conflict_level = otfs_find_backtrack_level (forced);
+        int new_level = determine_actual_backtrack_level (conflict_level);
+        UPDATE_AVERAGE (averages.current.level, new_level);
+        backtrack (new_level);
+
+        LOG ("forcing %d", forced);
+        search_assign_driving (forced, conflict);
+
+        // Clean up.
+        //
+        conflict = 0;
+        clear_analyzed_literals ();
+        clear_analyzed_levels ();
+        clause.clear ();
+        STOP (analyze);
+        return;
+      }
+
+      stats.conflicts++;
+
+      clear_analyzed_literals ();
+      clear_analyzed_levels ();
+      clause.clear ();
+      resolvent_size = 0;
+      antecedent_size = 1;
+      resolved = 0;
+      open = 0;
+      analyze_reason (0, reason, open, resolvent_size, antecedent_size);
+      conflict_size = antecedent_size - 1;
+      CADICAL_assert (open > 1);
+    }
+
+    ++resolved;
+
+    uip = 0;
+    while (!uip) {
+      CADICAL_assert (i > 0);
+      const int lit = (*t)[--i];
+      if (!flags (lit).seen)
+        continue;
+      if (var (lit).level == level)
+        uip = lit;
+    }
+    if (!--open)
+      break;
+    reason = var (uip).reason;
+    if (reason == external_reason) {
+      CADICAL_assert (!opts.exteagerreasons);
+      reason = learn_external_reason_clause (-uip, 0, true);
+      var (uip).reason = reason;
+    }
+    CADICAL_assert (reason != external_reason);
+    LOG (reason, "analyzing %d reason", uip);
+    CADICAL_assert (resolvent_size);
+    --resolvent_size;
+  }
+  LOG ("first UIP %d", uip);
+  clause.push_back (-uip);
+
+  // Update glue and learned (1st UIP literals) statistics.
+  //
+  int size = (int) clause.size ();
+  const int glue = (int) levels.size () - 1;
+  LOG (clause, "1st UIP size %d and glue %d clause", size, glue);
+  UPDATE_AVERAGE (averages.current.glue.fast, glue);
+  UPDATE_AVERAGE (averages.current.glue.slow, glue);
+  stats.learned.literals += size;
+  stats.learned.clauses++;
+  CADICAL_assert (glue < size);
+
+  // up to this point lrat_chain contains the proof for current clause in
+  // reversed order. in minimize and shrink the clause is changed and
+  // therefore lrat_chain has to be extended. Unfortunately we cannot create
+  // the chain directly during minimization (or shrinking) but afterwards we
+  // can calculate it pretty easily and even better the same algorithm works
+  // for both shrinking and minimization.
+
+  // Minimize the 1st UIP clause as pioneered by Niklas Soerensson in
+  // MiniSAT and described in our joint SAT'09 paper.
+  //
+  if (size > 1) {
+    if (opts.shrink)
+      shrink_and_minimize_clause ();
+    else if (opts.minimize)
+      minimize_clause ();
+
+    size = (int) clause.size ();
+
+    // Update decision heuristics.
+    //
+    if (opts.bump) {
+      bump_also_all_reason_literals ();
+      bump_variables ();
+    }
+
+    if (external->learner)
+      external->export_learned_large_clause (clause);
+  } else if (external->learner)
+    external->export_learned_unit_clause (-uip);
+
+  // Update actual size statistics.
+  //
+  stats.units += (size == 1);
+  stats.binaries += (size == 2);
+  UPDATE_AVERAGE (averages.current.size, size);
+
+  // reverse lrat_chain. We could probably work with reversed iterators
+  // (views) to be more efficient but we would have to distinguish in proof
+  //
+  if (lrat) {
+    LOG (unit_chain, "unit chain: ");
+    for (auto id : unit_chain)
+      lrat_chain.push_back (id);
+    unit_chain.clear ();
+    reverse (lrat_chain.begin (), lrat_chain.end ());
+  }
+
+  // Determine back-jump level, learn driving clause, backtrack and assign
+  // flipped 1st UIP literal.
+  //
+  int jump;
+  Clause *driving_clause = new_driving_clause (glue, jump);
+  UPDATE_AVERAGE (averages.current.jump, jump);
+
+  int new_level = determine_actual_backtrack_level (jump);
+  UPDATE_AVERAGE (averages.current.level, new_level);
+  backtrack (new_level);
+
+  // It should hold that (!level <=> size == 1)
+  //                 and (!uip   <=> size == 0)
+  // this means either we have already learned a clause => size >= 2
+  // in this case we will not learn empty clause or unit here
+  // or we haven't actually learned a clause in new_driving_clause
+  // then lrat_chain is still valid and we will learn a unit or empty clause
+  //
+  if (uip) {
+    search_assign_driving (-uip, driving_clause);
+  } else
+    learn_empty_clause ();
+
+  if (stable)
+    reluctant.tick (); // Reluctant has its own 'conflict' counter.
+
+  // Clean up.
+  //
+  clear_analyzed_literals ();
+  clear_unit_analyzed_literals ();
+  clear_analyzed_levels ();
+  clause.clear ();
+  conflict = 0;
+
+  lrat_chain.clear ();
+  STOP (analyze);
+
+  if (driving_clause && opts.eagersubsume)
+    eagerly_subsume_recently_learned_clauses (driving_clause);
+
+  if (lim.recompute_tier <= stats.conflicts)
+    recompute_tier ();
+}
+
+// We wait reporting a learned unit until propagation of that unit is
+// completed.  Otherwise the 'i' report gives the number of remaining
+// variables before propagating the unit (and hides the actual remaining
+// variables after propagating it).
+
+void Internal::iterate () {
+  iterating = false;
+  report ('i');
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_arena.cpp b/src/sat/cadical/cadical_arena.cpp
new file mode 100644
index 000000000..a8a9b183f
--- /dev/null
+++ b/src/sat/cadical/cadical_arena.cpp
@@ -0,0 +1,36 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+Arena::Arena (Internal *i) {
+  memset (this, 0, sizeof *this);
+  internal = i;
+}
+
+Arena::~Arena () {
+  delete[] from.start;
+  delete[] to.start;
+}
+
+void Arena::prepare (size_t bytes) {
+  LOG ("preparing 'to' space of arena with %zd bytes", bytes);
+  CADICAL_assert (!to.start);
+  to.top = to.start = new char[bytes];
+  to.end = to.start + bytes;
+}
+
+void Arena::swap () {
+  delete[] from.start;
+  LOG ("delete 'from' space of arena with %zd bytes",
+       (size_t) (from.end - from.start));
+  from = to;
+  to.start = to.top = to.end = 0;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_assume.cpp b/src/sat/cadical/cadical_assume.cpp
new file mode 100644
index 000000000..e7d5b79b7
--- /dev/null
+++ b/src/sat/cadical/cadical_assume.cpp
@@ -0,0 +1,613 @@
+#include "global.h"
+
+#include "internal.hpp"
+#include "options.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// Failed literal handling as pioneered by MiniSAT.  This first function
+// adds an assumption literal onto the assumption stack.
+
+void Internal::assume (int lit) {
+  if (level && !opts.ilbassumptions)
+    backtrack ();
+  else if (val (lit) < 0)
+    backtrack (max (0, var (lit).level - 1));
+  Flags &f = flags (lit);
+  const unsigned char bit = bign (lit);
+  if (f.assumed & bit) {
+    LOG ("ignoring already assumed %d", lit);
+    return;
+  }
+  LOG ("assume %d", lit);
+  f.assumed |= bit;
+  assumptions.push_back (lit);
+  freeze (lit);
+}
+
+// for LRAT we actually need to implement recursive DFS
+// for non-lrat use BFS. TODO: maybe derecursify to avoid stack overflow
+//
+void Internal::assume_analyze_literal (int lit) {
+  CADICAL_assert (lit);
+  Flags &f = flags (lit);
+  if (f.seen)
+    return;
+  f.seen = true;
+  analyzed.push_back (lit);
+  Var &v = var (lit);
+  CADICAL_assert (val (lit) < 0);
+  if (v.reason == external_reason) {
+    v.reason = wrapped_learn_external_reason_clause (-lit);
+    CADICAL_assert (v.reason || !v.level);
+  }
+  CADICAL_assert (v.reason != external_reason);
+  if (!v.level) {
+    int64_t id = unit_id (-lit);
+    lrat_chain.push_back (id);
+    return;
+  }
+  if (v.reason) {
+    CADICAL_assert (v.level);
+    LOG (v.reason, "analyze reason");
+    for (const auto &other : *v.reason) {
+      assume_analyze_literal (other);
+    }
+    lrat_chain.push_back (v.reason->id);
+    return;
+  }
+  CADICAL_assert (assumed (-lit));
+  LOG ("failed assumption %d", -lit);
+  clause.push_back (lit);
+}
+
+void Internal::assume_analyze_reason (int lit, Clause *reason) {
+  CADICAL_assert (reason);
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (reason != external_reason);
+  CADICAL_assert (lrat);
+  for (const auto &other : *reason)
+    if (other != lit)
+      assume_analyze_literal (other);
+  lrat_chain.push_back (reason->id);
+}
+
+// Find all failing assumptions starting from the one on the assumption
+// stack with the lowest decision level.  This goes back to MiniSAT and is
+// called 'analyze_final' there.
+
+void Internal::failing () {
+
+  START (analyze);
+
+  LOG ("analyzing failing assumptions");
+
+  CADICAL_assert (analyzed.empty ());
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (!marked_failed);
+  CADICAL_assert (!conflict_id);
+
+  if (!unsat_constraint) {
+    // Search for failing assumptions in the (internal) assumption stack.
+
+    // There are in essence three cases: (1) An assumption is falsified on
+    // the root-level and then 'failed_unit' is set to that assumption, (2)
+    // two clashing assumptions are assumed and then 'failed_clashing' is
+    // set to the second assumed one, or otherwise (3) there is a failing
+    // assumption 'first_failed' with minimum (non-zero) decision level
+    // 'failed_level'.
+
+    int failed_unit = 0;
+    int failed_clashing = 0;
+    int first_failed = 0;
+    int failed_level = INT_MAX;
+    int efailed = 0;
+
+    for (auto &elit : external->assumptions) {
+      int lit = external->e2i[abs (elit)];
+      if (elit < 0)
+        lit = -lit;
+      if (val (lit) >= 0)
+        continue;
+      const Var &v = var (lit);
+      if (!v.level) {
+        failed_unit = lit;
+        efailed = elit;
+        break;
+      }
+      if (failed_clashing)
+        continue;
+      if (v.reason == external_reason) {
+        Var &ev = var (lit);
+        ev.reason = learn_external_reason_clause (-lit);
+        if (!ev.reason) {
+          ev.level = 0;
+          failed_unit = lit;
+          efailed = elit;
+          break;
+        }
+        ev.level = 0;
+        // Recalculate assignment level
+        for (const auto &other : *ev.reason) {
+          if (other == -lit)
+            continue;
+          CADICAL_assert (val (other));
+          int tmp = var (other).level;
+          if (tmp > ev.level)
+            ev.level = tmp;
+        }
+        if (!ev.level) {
+          failed_unit = lit;
+          efailed = elit;
+          break;
+        }
+      }
+      CADICAL_assert (v.reason != external_reason);
+      if (!v.reason) {
+        failed_clashing = lit;
+        efailed = elit;
+      } else if (!first_failed || v.level < failed_level) {
+        first_failed = lit;
+        efailed = elit;
+        failed_level = v.level;
+      }
+    }
+
+    CADICAL_assert (clause.empty ());
+
+    // Get the 'failed' assumption from one of the three cases.
+    int failed;
+    if (failed_unit)
+      failed = failed_unit;
+    else if (failed_clashing)
+      failed = failed_clashing;
+    else
+      failed = first_failed;
+    CADICAL_assert (failed);
+    CADICAL_assert (efailed);
+
+    // In any case mark literal 'failed' as failed assumption.
+    {
+      Flags &f = flags (failed);
+      const unsigned bit = bign (failed);
+      CADICAL_assert (!(f.failed & bit));
+      f.failed |= bit;
+    }
+
+    // First case (1).
+    if (failed_unit) {
+      CADICAL_assert (failed == failed_unit);
+      LOG ("root-level falsified assumption %d", failed);
+      if (proof) {
+        if (lrat) {
+          unsigned eidx = (efailed > 0) + 2u * (unsigned) abs (efailed);
+          CADICAL_assert ((size_t) eidx < external->ext_units.size ());
+          const int64_t id = external->ext_units[eidx];
+          if (id) {
+            lrat_chain.push_back (id);
+          } else {
+            int64_t id = unit_id (-failed_unit);
+            lrat_chain.push_back (id);
+          }
+        }
+        proof->add_assumption_clause (++clause_id, -efailed, lrat_chain);
+        conclusion.push_back (clause_id);
+        lrat_chain.clear ();
+      }
+      goto DONE;
+    }
+
+    // Second case (2).
+    if (failed_clashing) {
+      CADICAL_assert (failed == failed_clashing);
+      LOG ("clashing assumptions %d and %d", failed, -failed);
+      Flags &f = flags (-failed);
+      const unsigned bit = bign (-failed);
+      CADICAL_assert (!(f.failed & bit));
+      f.failed |= bit;
+      if (proof) {
+        vector<int> clash = {externalize (failed), externalize (-failed)};
+        proof->add_assumption_clause (++clause_id, clash, lrat_chain);
+        conclusion.push_back (clause_id);
+      }
+      goto DONE;
+    }
+
+    // Fall through to third case (3).
+    LOG ("starting with assumption %d falsified on minimum decision level "
+         "%d",
+         first_failed, failed_level);
+
+    CADICAL_assert (first_failed);
+    CADICAL_assert (failed_level > 0);
+
+    // The 'analyzed' stack serves as working stack for a BFS through the
+    // implication graph until decisions, which are all assumptions, or
+    // units are reached.  This is simpler than corresponding code in
+    // 'analyze'.
+    {
+      LOG ("failed assumption %d", first_failed);
+      Flags &f = flags (first_failed);
+      CADICAL_assert (!f.seen);
+      f.seen = true;
+      CADICAL_assert (f.failed & bign (first_failed));
+      analyzed.push_back (-first_failed);
+      clause.push_back (-first_failed);
+    }
+  } else {
+    // unsat_constraint
+    // The assumptions necessary to fail each literal in the constraint are
+    // collected.
+    for (auto lit : constraint) {
+      lit *= -1;
+      CADICAL_assert (lit != INT_MIN);
+      flags (lit).seen = true;
+      analyzed.push_back (lit);
+    }
+  }
+
+  {
+    // used for unsat_constraint lrat
+    vector<vector<int64_t>> constraint_chains;
+    vector<vector<int>> constraint_clauses;
+    vector<int> sum_constraints;
+    vector<int> econstraints;
+    for (auto &elit : external->constraint) {
+      int lit = external->e2i[abs (elit)];
+      if (elit < 0)
+        lit = -lit;
+      if (!lit)
+        continue;
+      Flags &f = flags (lit);
+      if (f.seen)
+        continue;
+      if (std::find (econstraints.begin (), econstraints.end (), elit) !=
+          econstraints.end ())
+        continue;
+      econstraints.push_back (elit);
+    }
+
+    // no LRAT do bfs as it was before
+    if (!lrat) {
+      size_t next = 0;
+      while (next < analyzed.size ()) {
+        const int lit = analyzed[next++];
+        CADICAL_assert (val (lit) > 0);
+        Var &v = var (lit);
+        if (!v.level)
+          continue;
+        if (v.reason == external_reason) {
+          v.reason = wrapped_learn_external_reason_clause (lit);
+          if (!v.reason) {
+            v.level = 0;
+            continue;
+          }
+        }
+        CADICAL_assert (v.reason != external_reason);
+        if (v.reason) {
+          CADICAL_assert (v.level);
+          LOG (v.reason, "analyze reason");
+          for (const auto &other : *v.reason) {
+            Flags &f = flags (other);
+            if (f.seen)
+              continue;
+            f.seen = true;
+            CADICAL_assert (val (other) < 0);
+            analyzed.push_back (-other);
+          }
+        } else {
+          CADICAL_assert (assumed (lit));
+          LOG ("failed assumption %d", lit);
+          clause.push_back (-lit);
+          Flags &f = flags (lit);
+          const unsigned bit = bign (lit);
+          CADICAL_assert (!(f.failed & bit));
+          f.failed |= bit;
+        }
+      }
+      clear_analyzed_literals ();
+    } else if (!unsat_constraint) { // LRAT for case (3)
+      CADICAL_assert (clause.size () == 1);
+      const int lit = clause[0];
+      Var &v = var (lit);
+      CADICAL_assert (v.reason);
+      if (v.reason == external_reason) { // does this even happen?
+        v.reason = wrapped_learn_external_reason_clause (lit);
+      }
+      CADICAL_assert (v.reason != external_reason);
+      if (v.reason)
+        assume_analyze_reason (lit, v.reason);
+      else {
+        int64_t id = unit_id (lit);
+        lrat_chain.push_back (id);
+      }
+      for (auto &lit : clause) {
+        Flags &f = flags (lit);
+        const unsigned bit = bign (-lit);
+        if (!(f.failed & bit))
+          f.failed |= bit;
+      }
+      clear_analyzed_literals ();
+    } else { // LRAT for unsat_constraint
+      CADICAL_assert (clause.empty ());
+      clear_analyzed_literals ();
+      for (auto lit : constraint) {
+        // make sure nothing gets marked failed twice
+        // also might shortcut the case where
+        // lrat_chain is empty because clause is tautological
+        CADICAL_assert (lit != INT_MIN);
+        assume_analyze_literal (lit);
+        vector<int64_t> empty;
+        vector<int> empty2;
+        constraint_chains.push_back (empty);
+        constraint_clauses.push_back (empty2);
+        for (auto ign : clause) {
+          constraint_clauses.back ().push_back (ign);
+          Flags &f = flags (ign);
+          const unsigned bit = bign (-ign);
+          if (!(f.failed & bit)) {
+            sum_constraints.push_back (ign);
+            CADICAL_assert (!(f.failed & bit));
+            f.failed |= bit;
+          }
+        }
+        clause.clear ();
+        clear_analyzed_literals ();
+        for (auto p : lrat_chain) {
+          constraint_chains.back ().push_back (p);
+        }
+        lrat_chain.clear ();
+      }
+      for (auto &lit : sum_constraints)
+        clause.push_back (lit);
+    }
+    clear_analyzed_literals ();
+
+    // Doing clause minimization here does not do anything because
+    // the clause already contains only one literal of each level
+    // and minimization can never reduce the number of levels
+
+    VERBOSE (1, "found %zd failed assumptions %.0f%%", clause.size (),
+             percent (clause.size (), assumptions.size ()));
+
+    // We do not actually need to learn this clause, since the conflict is
+    // forced already by some other clauses.  There is also no bumping
+    // of variables nor clauses necessary.  But we still want to check
+    // correctness of the claim that the determined subset of failing
+    // assumptions are a high-level core or equivalently their negations
+    // form a unit-implied clause.
+    //
+    if (!unsat_constraint) {
+      external->check_learned_clause ();
+      if (proof) {
+        vector<int> eclause;
+        for (auto &lit : clause)
+          eclause.push_back (externalize (lit));
+        proof->add_assumption_clause (++clause_id, eclause, lrat_chain);
+        conclusion.push_back (clause_id);
+      }
+    } else {
+      CADICAL_assert (!lrat || (constraint.size () == constraint_clauses.size () &&
+                        constraint.size () == constraint_chains.size ()));
+      for (auto p = constraint.rbegin (); p != constraint.rend (); p++) {
+        const auto &lit = *p;
+        if (lrat) {
+          clause.clear ();
+          for (auto &ign : constraint_clauses.back ())
+            clause.push_back (ign);
+          constraint_clauses.pop_back ();
+        }
+        clause.push_back (-lit);
+        external->check_learned_clause ();
+        if (proof) {
+          if (lrat) {
+            for (auto p : constraint_chains.back ()) {
+              lrat_chain.push_back (p);
+            }
+            constraint_chains.pop_back ();
+            LOG (lrat_chain, "assume proof chain with constraints");
+          }
+          vector<int> eclause;
+          for (auto &lit : clause)
+            eclause.push_back (externalize (lit));
+          proof->add_assumption_clause (++clause_id, eclause, lrat_chain);
+          conclusion.push_back (clause_id);
+          lrat_chain.clear ();
+        }
+        clause.pop_back ();
+      }
+      if (proof) {
+        for (auto &elit : econstraints) {
+          if (lrat) {
+            unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
+            CADICAL_assert ((size_t) eidx < external->ext_units.size ());
+            const int64_t id = external->ext_units[eidx];
+            if (id) {
+              lrat_chain.push_back (id);
+            } else {
+              int lit = external->e2i[abs (elit)];
+              if (elit < 0)
+                lit = -lit;
+              int64_t id = unit_id (-lit);
+              lrat_chain.push_back (id);
+            }
+          }
+          proof->add_assumption_clause (++clause_id, -elit, lrat_chain);
+          conclusion.push_back (clause_id);
+          lrat_chain.clear ();
+        }
+      }
+    }
+    lrat_chain.clear ();
+    clause.clear ();
+  }
+
+DONE:
+
+  STOP (analyze);
+}
+
+bool Internal::failed (int lit) {
+  if (!marked_failed) {
+    if (!conflict_id)
+      failing ();
+    marked_failed = true;
+  }
+  conclude_unsat ();
+  Flags &f = flags (lit);
+  const unsigned bit = bign (lit);
+  return (f.failed & bit) != 0;
+}
+
+void Internal::conclude_unsat () {
+  if (!proof || concluded)
+    return;
+  concluded = true;
+  if (!marked_failed) {
+    CADICAL_assert (conclusion.empty ());
+    if (!conflict_id)
+      failing ();
+    marked_failed = true;
+  }
+  ConclusionType con;
+  if (conflict_id)
+    con = CONFLICT;
+  else if (unsat_constraint)
+    con = CONSTRAINT;
+  else
+    con = ASSUMPTIONS;
+  proof->conclude_unsat (con, conclusion);
+}
+
+void Internal::reset_concluded () {
+  if (proof)
+    proof->reset_assumptions ();
+  if (concluded) {
+    LOG ("reset concluded");
+    concluded = false;
+  }
+  if (conflict_id) {
+    CADICAL_assert (conclusion.size () == 1);
+    return;
+  }
+  conclusion.clear ();
+}
+
+// Add the start of each incremental phase (leaving the state
+// 'UNSATISFIABLE' actually) we reset all assumptions.
+
+void Internal::reset_assumptions () {
+  for (const auto &lit : assumptions) {
+    Flags &f = flags (lit);
+    const unsigned char bit = bign (lit);
+    f.assumed &= ~bit;
+    f.failed &= ~bit;
+    melt (lit);
+  }
+  LOG ("cleared %zd assumptions", assumptions.size ());
+  assumptions.clear ();
+  marked_failed = true;
+}
+
+struct sort_assumptions_positive_rank {
+  Internal *internal;
+
+  // Decision level could be 'INT_MAX' and thus 'level + 1' could overflow.
+  // Therefore we carefully have to use 'unsigned' for levels below.
+
+  const unsigned max_level;
+
+  sort_assumptions_positive_rank (Internal *s)
+      : internal (s), max_level (s->level + 1u) {}
+
+  typedef uint64_t Type;
+
+  // Set assumptions first, then sorted by position on the trail
+  // unset literals are sorted by literal value.
+
+  Type operator() (const int &a) const {
+    const int val = internal->val (a);
+    const bool assigned = (val != 0);
+    const Var &v = internal->var (a);
+    uint64_t res = (assigned ? (unsigned) v.level : max_level);
+    res <<= 32;
+    res |= (assigned ? v.trail : abs (a));
+    return res;
+  }
+};
+
+struct sort_assumptions_smaller {
+  Internal *internal;
+  sort_assumptions_smaller (Internal *s) : internal (s) {}
+  bool operator() (const int &a, const int &b) const {
+    return sort_assumptions_positive_rank (internal) (a) <
+           sort_assumptions_positive_rank (internal) (b);
+  }
+};
+
+// Sort the assumptions by the current position on the trail and backtrack
+// to the first place where the assumptions and the current trail differ.
+
+void Internal::sort_and_reuse_assumptions () {
+  CADICAL_assert (opts.ilbassumptions);
+  if (assumptions.empty ())
+    return;
+  MSORT (opts.radixsortlim, assumptions.begin (), assumptions.end (),
+         sort_assumptions_positive_rank (this),
+         sort_assumptions_smaller (this));
+
+  unsigned max_level = 0;
+  // assumptions are sorted by level, with unset at the end
+  for (auto lit : assumptions) {
+    if (val (lit))
+      max_level = var (lit).level;
+    else
+      break;
+  }
+
+  const unsigned size = min (level + 1u, max_level + 1);
+  CADICAL_assert ((size_t) level == control.size () - 1);
+  LOG (assumptions, "sorted assumptions");
+  int target = 0;
+  for (unsigned i = 1, j = 0; i < size;) {
+    const Level &l = control[i];
+    const int lit = l.decision;
+    const int alit = assumptions[j];
+    const int lev = i;
+    target = lev;
+    if (val (alit) > 0 &&
+        var (alit).level < lev) { // we can ignore propagated assumptions
+      LOG ("ILB skipping propagation %d", alit);
+      ++j;
+      continue;
+    }
+    if (!lit) { // skip fake decisions
+      target = lev - 1;
+      break;
+    }
+    ++i, ++j;
+    CADICAL_assert (var (lit).level == lev);
+    if (l.decision == alit) {
+      continue;
+    }
+    target = lev - 1;
+    LOG ("first different literal %d on the trail and %d from the "
+         "assumptions",
+         lit, alit);
+    break;
+  }
+  if (target < level)
+    backtrack (target);
+  LOG ("assumptions allow for reuse of trail up to level %d", level);
+  //  COVER (target > 1);
+  if ((size_t) level > assumptions.size ())
+    stats.assumptionsreused += assumptions.size ();
+  else
+    stats.assumptionsreused += level;
+}
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_averages.cpp b/src/sat/cadical/cadical_averages.cpp
new file mode 100644
index 000000000..d40a98cdb
--- /dev/null
+++ b/src/sat/cadical/cadical_averages.cpp
@@ -0,0 +1,40 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::init_averages () {
+
+  LOG ("initializing averages");
+
+  INIT_EMA (averages.current.jump, opts.emajump);
+  INIT_EMA (averages.current.level, opts.emalevel);
+  INIT_EMA (averages.current.size, opts.emasize);
+
+  INIT_EMA (averages.current.glue.fast, opts.emagluefast);
+  INIT_EMA (averages.current.glue.slow, opts.emaglueslow);
+
+  INIT_EMA (averages.current.decisions, opts.emadecisions);
+
+  INIT_EMA (averages.current.trail.fast, opts.ematrailfast);
+  INIT_EMA (averages.current.trail.slow, opts.ematrailslow);
+
+  CADICAL_assert (!averages.swapped);
+}
+
+void Internal::swap_averages () {
+  LOG ("saving current averages");
+  swap (averages.current, averages.saved);
+  if (!averages.swapped)
+    init_averages ();
+  else
+    LOG ("swapping in previously saved averages");
+  averages.swapped++;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_backtrack.cpp b/src/sat/cadical/cadical_backtrack.cpp
new file mode 100644
index 000000000..b3c519ba2
--- /dev/null
+++ b/src/sat/cadical/cadical_backtrack.cpp
@@ -0,0 +1,179 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// The global assignment stack can only be (partially) reset through
+// 'backtrack' which is the only function using 'unassign' (inlined and thus
+// local to this file).  It turns out that 'unassign' does not need a
+// specialization for 'probe' nor 'vivify' and thus it is shared.
+
+inline void Internal::unassign (int lit) {
+  CADICAL_assert (val (lit) > 0);
+  set_val (lit, 0);
+
+  int idx = vidx (lit);
+  LOG ("unassign %d @ %d", lit, var (idx).level);
+  num_assigned--;
+
+  // In the standard EVSIDS variable decision heuristic of MiniSAT, we need
+  // to push variables which become unassigned back to the heap.
+  //
+  if (!scores.contains (idx))
+    scores.push_back (idx);
+
+  // For VMTF we need to update the 'queue.unassigned' pointer in case this
+  // variable sits after the variable to which 'queue.unassigned' currently
+  // points.  See our SAT'15 paper for more details on this aspect.
+  //
+  if (queue.bumped < btab[idx])
+    update_queue_unassigned (idx);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Update the current target maximum assignment and also the very best
+// assignment.  Whether a trail produces a conflict is determined during
+// propagation.  Thus that all functions in the 'search' loop after
+// propagation can assume that 'no_conflict_until' is valid.  If a conflict
+// is found then the trail before the last decision is used (see the end of
+// 'propagate').  During backtracking we can then save this largest
+// propagation conflict free assignment.  It is saved as both 'target'
+// assignment for picking decisions in 'stable' mode and if it is the
+// largest ever such assignment also as 'best' assignment. This 'best'
+// assignment can then be used in future stable decisions after the next
+// 'rephase_best' overwrites saved phases with it.
+
+void Internal::update_target_and_best () {
+
+  bool reset = (rephased && stats.conflicts > last.rephase.conflicts);
+
+  if (reset) {
+    target_assigned = 0;
+    if (rephased == 'B')
+      best_assigned = 0; // update it again
+  }
+
+  if (no_conflict_until > target_assigned) {
+    copy_phases (phases.target);
+    target_assigned = no_conflict_until;
+    LOG ("new target trail level %zu", target_assigned);
+  }
+
+  if (no_conflict_until > best_assigned) {
+    copy_phases (phases.best);
+    best_assigned = no_conflict_until;
+    LOG ("new best trail level %zu", best_assigned);
+  }
+
+  if (reset) {
+    report (rephased);
+    rephased = 0;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::backtrack (int new_level) {
+  CADICAL_assert (new_level <= level);
+  if (new_level == level)
+    return;
+
+  update_target_and_best ();
+  backtrack_without_updating_phases (new_level);
+}
+
+void Internal::backtrack_without_updating_phases (int new_level) {
+
+  CADICAL_assert (new_level <= level);
+  if (new_level == level)
+    return;
+
+  stats.backtracks++;
+
+  CADICAL_assert (num_assigned == trail.size ());
+
+  const size_t assigned = control[new_level + 1].trail;
+
+  LOG ("backtracking to decision level %d with decision %d and trail %zd",
+       new_level, control[new_level].decision, assigned);
+
+  const size_t end_of_trail = trail.size ();
+  size_t i = assigned, j = i;
+
+#ifdef LOGGING
+  int unassigned = 0;
+#endif
+  int reassigned = 0;
+
+  notify_backtrack (new_level);
+  if (external_prop && !external_prop_is_lazy && !private_steps &&
+      notified > assigned) {
+    LOG ("external propagator is notified about some unassignments (trail: "
+         "%zd, notified: %zd).",
+         trail.size (), notified);
+    notified = assigned;
+  }
+
+  while (i < end_of_trail) {
+    int lit = trail[i++];
+    Var &v = var (lit);
+    if (v.level > new_level) {
+      unassign (lit);
+#ifdef LOGGING
+      unassigned++;
+#endif
+    } else {
+      // This is the essence of the SAT'18 paper on chronological
+      // backtracking.  It is possible to just keep out-of-order assigned
+      // literals on the trail without breaking the solver (after some
+      // modifications to 'analyze' - see 'opts.chrono' guarded code there).
+      CADICAL_assert (opts.chrono || external_prop || did_external_prop);
+#ifdef LOGGING
+      if (!v.level)
+        LOG ("reassign %d @ 0 unit clause %d", lit, lit);
+      else
+        LOG (v.reason, "reassign %d @ %d", lit, v.level);
+#endif
+      trail[j] = lit;
+      v.trail = j++;
+      reassigned++;
+    }
+  }
+  trail.resize (j);
+  LOG ("unassigned %d literals %.0f%%", unassigned,
+       percent (unassigned, unassigned + reassigned));
+  LOG ("reassigned %d literals %.0f%%", reassigned,
+       percent (reassigned, unassigned + reassigned));
+
+  if (propagated > assigned)
+    propagated = assigned;
+  if (propagated2 > assigned)
+    propagated2 = assigned;
+  if (no_conflict_until > assigned)
+    no_conflict_until = assigned;
+
+  propergated = 0; // Always go back to root-level.
+
+  CADICAL_assert (notified <= assigned + reassigned);
+  if (reassigned) {
+    notify_assignments ();
+  }
+
+  control.resize (new_level + 1);
+  level = new_level;
+  if (tainted_literal) {
+    CADICAL_assert (opts.ilb);
+    if (!val (tainted_literal)) {
+      tainted_literal = 0;
+    }
+  }
+  CADICAL_assert (num_assigned == trail.size ());
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_backward.cpp b/src/sat/cadical/cadical_backward.cpp
new file mode 100644
index 000000000..5778029a5
--- /dev/null
+++ b/src/sat/cadical/cadical_backward.cpp
@@ -0,0 +1,237 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Provide eager backward subsumption for resolved clauses.
+
+// The eliminator maintains a queue of clauses that are new and have to be
+// checked to subsume or strengthen other (longer or same size) clauses.
+
+void Eliminator::enqueue (Clause *c) {
+  if (!internal->opts.elimbackward)
+    return;
+  if (c->enqueued)
+    return;
+  LOG (c, "backward enqueue");
+  backward.push (c);
+  c->enqueued = true;
+}
+
+Clause *Eliminator::dequeue () {
+  if (backward.empty ())
+    return 0;
+  Clause *res = backward.front ();
+  backward.pop ();
+  CADICAL_assert (res->enqueued);
+  res->enqueued = false;
+  LOG (res, "backward dequeue");
+  return res;
+}
+
+Eliminator::~Eliminator () {
+  while (dequeue ())
+    ;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elim_backward_clause (Eliminator &eliminator, Clause *c) {
+  CADICAL_assert (opts.elimbackward);
+  CADICAL_assert (!c->redundant);
+  if (c->garbage)
+    return;
+  LOG (c, "attempting backward subsumption and strengthening with");
+  size_t len = UINT_MAX;
+  unsigned size = 0;
+  int best = 0;
+  bool satisfied = false;
+  CADICAL_assert (mini_chain.empty ());
+  for (const auto &lit : *c) {
+    const signed char tmp = val (lit);
+    if (tmp > 0) {
+      satisfied = true;
+      break;
+    }
+    if (tmp < 0)
+      continue;
+    size_t l = occs (lit).size ();
+    LOG ("literal %d occurs %zd times", lit, l);
+    if (l < len)
+      best = lit, len = l;
+    mark (lit);
+    size++;
+  }
+  if (satisfied) {
+    LOG ("clause actually already satisfied");
+    elim_update_removed_clause (eliminator, c);
+    mark_garbage (c);
+  } else if (len > (size_t) opts.elimocclim) {
+    LOG ("skipping backward subsumption due to too many occurrences");
+  } else {
+    CADICAL_assert (len);
+    LOG ("literal %d has smallest number of occurrences %zd", best, len);
+    LOG ("marked %d literals in clause of size %d", size, c->size);
+    for (auto &d : occs (best)) {
+      if (d == c)
+        continue;
+      if (d->garbage)
+        continue;
+      if ((unsigned) d->size < size)
+        continue;
+      int negated = 0;
+      unsigned found = 0;
+      satisfied = false;
+      for (const auto &lit : *d) {
+        signed char tmp = val (lit);
+        if (tmp > 0) {
+          satisfied = true;
+          break;
+        }
+        if (tmp < 0)
+          continue;
+        tmp = marked (lit);
+        if (!tmp)
+          continue;
+        if (tmp < 0) {
+          if (negated) {
+            size = UINT_MAX;
+            break;
+          } else
+            negated = lit;
+        }
+        if (++found == size)
+          break;
+      }
+      if (satisfied) {
+        LOG (d, "found satisfied clause");
+        elim_update_removed_clause (eliminator, d);
+        mark_garbage (d);
+      } else if (found == size) {
+        if (!negated) {
+          LOG (d, "found subsumed clause");
+          elim_update_removed_clause (eliminator, d);
+          mark_garbage (d);
+          stats.subsumed++;
+          stats.elimbwsub++;
+        } else {
+          int unit = 0;
+          CADICAL_assert (minimize_chain.empty ());
+          CADICAL_assert (analyzed.empty ());
+          CADICAL_assert (lrat_chain.empty ());
+          // figure out wether we strengthen c or get a new unit
+          for (const auto &lit : *d) {
+            const signed char tmp = val (lit);
+            if (tmp < 0) {
+              if (!lrat)
+                continue;
+              Flags &f = flags (lit);
+              CADICAL_assert (!f.seen);
+              if (f.seen)
+                continue;
+              f.seen = true;
+              analyzed.push_back (lit);
+              continue;
+            }
+            if (tmp > 0) {
+              satisfied = true;
+              break;
+            }
+            if (lit == negated)
+              continue;
+            if (unit) {
+              unit = INT_MIN;
+              continue; // needed to guarantee d is not satsified
+            } else
+              unit = lit;
+          }
+          if (lrat && !satisfied) {
+            // if we found a unit we need to add all unit ids from
+            // {c\d}U{d\c} otherwise just the unit ids from {c\d}
+            for (const auto &lit : *c) {
+              const signed char tmp = val (lit);
+              CADICAL_assert (tmp <= 0);
+              if (tmp >= 0)
+                continue;
+              Flags &f = flags (lit);
+              if (f.seen && unit && unit == INT_MIN) {
+                f.seen = false;
+                continue;
+              } else if (!f.seen) {
+                f.seen = true;
+                analyzed.push_back (lit);
+              }
+            }
+            if (unit == INT_MIN) { // we do not need units from {d\c}
+              for (const auto &lit : *d) {
+                flags (lit).seen = false;
+              }
+            }
+            for (const auto &lit : analyzed) {
+              Flags &f = flags (lit);
+              if (!f.seen) {
+                f.seen = true;
+                continue;
+              }
+              int64_t id = unit_id (-lit);
+              lrat_chain.push_back (id);
+            }
+            clear_analyzed_literals ();
+            lrat_chain.push_back (d->id);
+            lrat_chain.push_back (c->id);
+          } else if (lrat)
+            clear_analyzed_literals ();
+          if (satisfied) {
+            CADICAL_assert (lrat_chain.empty ());
+            mark_garbage (d);
+            elim_update_removed_clause (eliminator, d);
+          } else if (unit && unit != INT_MIN) {
+            CADICAL_assert (unit);
+            LOG (d, "unit %d through hyper unary resolution with", unit);
+            assign_unit (unit);
+            elim_propagate (eliminator, unit);
+            lrat_chain.clear ();
+            break;
+          } else if (occs (negated).size () <= (size_t) opts.elimocclim) {
+            strengthen_clause (d, negated);
+            remove_occs (occs (negated), d);
+            elim_update_removed_lit (eliminator, negated);
+            stats.elimbwstr++;
+            CADICAL_assert (negated != best);
+            eliminator.enqueue (d);
+          }
+          lrat_chain.clear ();
+        }
+      }
+    }
+  }
+  mini_chain.clear ();
+  unmark (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elim_backward_clauses (Eliminator &eliminator) {
+  if (!opts.elimbackward) {
+    CADICAL_assert (eliminator.backward.empty ());
+    return;
+  }
+  START (backward);
+  LOG ("attempting backward subsumption and strengthening with %zd clauses",
+       eliminator.backward.size ());
+  Clause *c;
+  while (!unsat && (c = eliminator.dequeue ()))
+    elim_backward_clause (eliminator, c);
+  STOP (backward);
+}
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_bins.cpp b/src/sat/cadical/cadical_bins.cpp
new file mode 100644
index 000000000..fba96f216
--- /dev/null
+++ b/src/sat/cadical/cadical_bins.cpp
@@ -0,0 +1,28 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Binary implication graph lists.
+
+void Internal::init_bins () {
+  CADICAL_assert (big.empty ());
+  if (big.size () < 2 * vsize)
+    big.resize (2 * vsize, Bins ());
+  LOG ("initialized binary implication graph");
+}
+
+void Internal::reset_bins () {
+  CADICAL_assert (!big.empty ());
+  erase_vector (big);
+  LOG ("reset binary implication graph");
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_block.cpp b/src/sat/cadical/cadical_block.cpp
new file mode 100644
index 000000000..12f852f08
--- /dev/null
+++ b/src/sat/cadical/cadical_block.cpp
@@ -0,0 +1,830 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This implements an inprocessing version of blocked clause elimination and
+// is assumed to be triggered just before bounded variable elimination.  It
+// has a separate 'block' flag while variable elimination uses 'elim'.
+// Thus it only tries to block clauses on a literal which was removed in an
+// irredundant clause in negated form before and has not been tried to use
+// as blocking literal since then.
+
+/*------------------------------------------------------------------------*/
+
+inline bool block_more_occs_size::operator() (unsigned a, unsigned b) {
+  size_t s = internal->noccs (-internal->u2i (a));
+  size_t t = internal->noccs (-internal->u2i (b));
+  if (s > t)
+    return true;
+  if (s < t)
+    return false;
+  s = internal->noccs (internal->u2i (a));
+  t = internal->noccs (internal->u2i (b));
+  if (s > t)
+    return true;
+  if (s < t)
+    return false;
+  return a > b;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Determine whether 'c' is blocked on 'lit', by first marking all its
+// literals and then checking all resolvents with negative clauses (with
+// '-lit') are tautological.  We use a move-to-front scheme for both the
+// occurrence list of negative clauses (with '-lit') and then for literals
+// within each such clause.  The clause move-to-front scheme has the goal to
+// find non-tautological clauses faster in the future, while the literal
+// move-to-front scheme has the goal to faster find the matching literal,
+// which makes the resolvent tautological (again in the future).
+
+bool Internal::is_blocked_clause (Clause *c, int lit) {
+
+  LOG (c, "trying to block on %d", lit);
+
+  CADICAL_assert (c->size >= opts.blockminclslim);
+  CADICAL_assert (c->size <= opts.blockmaxclslim);
+  CADICAL_assert (active (lit));
+  CADICAL_assert (!val (lit));
+  CADICAL_assert (!c->garbage);
+  CADICAL_assert (!c->redundant);
+  CADICAL_assert (!level);
+
+  mark (c); // First mark all literals in 'c'.
+
+  Occs &os = occs (-lit);
+  LOG ("resolving against at most %zd clauses with %d", os.size (), -lit);
+
+  bool res = true; // Result is true if all resolvents tautological.
+
+  // Can not use 'auto' here since we update 'os' during traversal.
+  //
+  const auto end_of_os = os.end ();
+  auto i = os.begin ();
+
+  Clause *prev_d = 0; // Previous non-tautological clause.
+
+  for (; i != end_of_os; i++) {
+    // Move the first clause with non-tautological resolvent to the front of
+    // the occurrence list to improve finding it faster later.
+    //
+    Clause *d = *i;
+
+    CADICAL_assert (!d->garbage);
+    CADICAL_assert (!d->redundant);
+    CADICAL_assert (d->size <= opts.blockmaxclslim);
+
+    *i = prev_d; // Move previous non-tautological clause
+    prev_d = d;  // backwards but remember clause at this position.
+
+    LOG (d, "resolving on %d against", lit);
+    stats.blockres++;
+
+    int prev_other = 0; // Previous non-tautological literal.
+
+    // No 'auto' since we update literals of 'd' during traversal.
+    //
+    const const_literal_iterator end_of_d = d->end ();
+    literal_iterator l;
+
+    for (l = d->begin (); l != end_of_d; l++) {
+      // Same move-to-front mechanism for literals within a clause.  It
+      // moves the first negatively marked literal to the front to find it
+      // faster in the future.
+      //
+      const int other = *l;
+      *l = prev_other;
+      prev_other = other;
+      if (other == -lit)
+        continue;
+      CADICAL_assert (other != lit);
+      CADICAL_assert (active (other));
+      CADICAL_assert (!val (other));
+      if (marked (other) < 0) {
+        LOG ("found tautological literal %d", other);
+        d->literals[0] = other; // Move to front of 'd'.
+        break;
+      }
+    }
+
+    if (l == end_of_d) {
+      LOG ("no tautological literal found");
+      //
+      // Since we did not find a tautological literal we restore the old
+      // order of literals in the clause.
+      //
+      const const_literal_iterator begin_of_d = d->begin ();
+      while (l-- != begin_of_d) {
+        const int other = *l;
+        *l = prev_other;
+        prev_other = other;
+      }
+      res = false; // Now 'd' is a witness that 'c' is not blocked.
+      os[0] = d;   // Move it to the front of the occurrence list.
+      break;
+    }
+  }
+  unmark (c); // ... all literals of the candidate clause.
+
+  // If all resolvents are tautological and thus the clause is blocked we
+  // restore the old order of clauses in the occurrence list of '-lit'.
+  //
+  if (res) {
+    CADICAL_assert (i == end_of_os);
+    const auto boc = os.begin ();
+    while (i != boc) {
+      Clause *d = *--i;
+      *i = prev_d;
+      prev_d = d;
+    }
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::block_schedule (Blocker &blocker) {
+  // Set skip flags for all literals in too large clauses.
+  //
+  for (const auto &c : clauses) {
+
+    if (c->garbage)
+      continue;
+    if (c->redundant)
+      continue;
+    if (c->size <= opts.blockmaxclslim)
+      continue;
+
+    for (const auto &lit : *c)
+      mark_skip (-lit);
+  }
+
+  // Connect all literal occurrences in irredundant clauses.
+  //
+  for (const auto &c : clauses) {
+
+    if (c->garbage)
+      continue;
+    if (c->redundant)
+      continue;
+
+    for (const auto &lit : *c) {
+      CADICAL_assert (active (lit));
+      CADICAL_assert (!val (lit));
+      occs (lit).push_back (c);
+    }
+  }
+
+  // We establish the invariant that 'noccs' gives the number of actual
+  // occurrences of 'lit' in non-garbage clauses,  while 'occs' might still
+  // refer to garbage clauses, thus 'noccs (lit) <= occs (lit).size ()'.  It
+  // is expensive to remove references to garbage clauses from 'occs' during
+  // blocked clause elimination, but decrementing 'noccs' is cheap.
+
+  for (auto lit : lits) {
+    if (!active (lit))
+      continue;
+    CADICAL_assert (!val (lit));
+    Occs &os = occs (lit);
+    noccs (lit) = os.size ();
+  }
+
+  // Now we fill the schedule (priority queue) of candidate literals to be
+  // tried as blocking literals.  It is probably slightly faster to do this
+  // in one go after all occurrences have been determined, instead of
+  // filling the priority queue during pushing occurrences.  Filling the
+  // schedule can not be fused with the previous loop (easily) since we
+  // first have to initialize 'noccs' for both 'lit' and '-lit'.
+
+#ifndef CADICAL_QUIET
+  int skipped = 0;
+#endif
+
+  for (auto idx : vars) {
+    if (!active (idx))
+      continue;
+    if (frozen (idx)) {
+#ifndef CADICAL_QUIET
+      skipped += 2;
+#endif
+      continue;
+    }
+    CADICAL_assert (!val (idx));
+    for (int sign = -1; sign <= 1; sign += 2) {
+      const int lit = sign * idx;
+      if (marked_skip (lit)) {
+#ifndef CADICAL_QUIET
+        skipped++;
+#endif
+        continue;
+      }
+      if (!marked_block (lit))
+        continue;
+      unmark_block (lit);
+      LOG ("scheduling %d with %" PRId64 " positive and %" PRId64
+           " negative occurrences",
+           lit, noccs (lit), noccs (-lit));
+      blocker.schedule.push_back (vlit (lit));
+    }
+  }
+
+  PHASE ("block", stats.blockings,
+         "scheduled %zd candidate literals %.2f%% (%d skipped %.2f%%)",
+         blocker.schedule.size (),
+         percent (blocker.schedule.size (), 2.0 * active ()), skipped,
+         percent (skipped, 2.0 * active ()));
+}
+
+/*------------------------------------------------------------------------*/
+
+// A literal is pure if it only occurs positive.  Then all clauses in which
+// it occurs are blocked on it. This special case can be implemented faster
+// than trying to block literals with at least one negative occurrence and
+// is thus handled separately.  It also allows to avoid pushing blocked
+// clauses onto the extension stack.
+
+void Internal::block_pure_literal (Blocker &blocker, int lit) {
+  if (frozen (lit))
+    return;
+  CADICAL_assert (active (lit));
+
+  Occs &pos = occs (lit);
+  Occs &nos = occs (-lit);
+
+  CADICAL_assert (!noccs (-lit));
+#ifndef CADICAL_NDEBUG
+  for (const auto &c : nos)
+    CADICAL_assert (c->garbage);
+#endif
+  stats.blockpurelits++;
+  LOG ("found pure literal %d", lit);
+#ifdef LOGGING
+  int64_t pured = 0;
+#endif
+  for (const auto &c : pos) {
+    if (c->garbage)
+      continue;
+    CADICAL_assert (!c->redundant);
+    LOG (c, "pure literal %d in", lit);
+    blocker.reschedule.push_back (c);
+    if (proof) {
+      proof->weaken_minus (c);
+    }
+    external->push_clause_on_extension_stack (c, lit);
+    stats.blockpured++;
+    mark_garbage (c);
+#ifdef LOGGING
+    pured++;
+#endif
+  }
+
+  erase_vector (pos);
+  erase_vector (nos);
+
+  mark_pure (lit);
+  stats.blockpured++;
+  LOG ("blocking %" PRId64 " clauses on pure literal %d", pured, lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// If there is only one negative clause with '-lit' it is faster to mark it
+// instead of marking all the positive clauses with 'lit' one after the
+// other and then resolving against the negative clause.
+
+void Internal::block_literal_with_one_negative_occ (Blocker &blocker,
+                                                    int lit) {
+  CADICAL_assert (active (lit));
+  CADICAL_assert (!frozen (lit));
+  CADICAL_assert (noccs (lit) > 0);
+  CADICAL_assert (noccs (-lit) == 1);
+
+  Occs &nos = occs (-lit);
+  CADICAL_assert (nos.size () >= 1);
+
+  Clause *d = 0;
+  for (const auto &c : nos) {
+    if (c->garbage)
+      continue;
+    CADICAL_assert (!d);
+    d = c;
+#ifndef CADICAL_NDEBUG
+    break;
+#endif
+  }
+  CADICAL_assert (d);
+  nos.resize (1);
+  nos[0] = d;
+
+  if (d && d->size > opts.blockmaxclslim) {
+    LOG (d, "skipped common antecedent");
+    return;
+  }
+
+  CADICAL_assert (!d->garbage);
+  CADICAL_assert (!d->redundant);
+  CADICAL_assert (d->size <= opts.blockmaxclslim);
+
+  LOG (d, "common %d antecedent", lit);
+  mark (d);
+  int64_t blocked = 0;
+#ifdef LOGGING
+  int64_t skipped = 0;
+#endif
+  Occs &pos = occs (lit);
+
+  // Again no 'auto' since 'pos' is update during traversal.
+  //
+  const auto eop = pos.end ();
+  auto j = pos.begin (), i = j;
+
+  for (; i != eop; i++) {
+    Clause *c = *j++ = *i;
+
+    if (c->garbage) {
+      j--;
+      continue;
+    }
+    if (c->size > opts.blockmaxclslim) {
+#ifdef LOGGING
+      skipped++;
+#endif
+      continue;
+    }
+    if (c->size < opts.blockminclslim) {
+#ifdef LOGGING
+      skipped++;
+#endif
+      continue;
+    }
+
+    LOG (c, "trying to block on %d", lit);
+
+    // We use the same literal move-to-front strategy as in
+    // 'is_blocked_clause'.  See there for more explanations.
+
+    int prev_other = 0; // Previous non-tautological literal.
+
+    // No 'auto' since literals of 'c' are updated during traversal.
+    //
+    const const_literal_iterator end_of_c = c->end ();
+    literal_iterator l;
+
+    for (l = c->begin (); l != end_of_c; l++) {
+      const int other = *l;
+      *l = prev_other;
+      prev_other = other;
+      if (other == lit)
+        continue;
+      CADICAL_assert (other != -lit);
+      CADICAL_assert (active (other));
+      CADICAL_assert (!val (other));
+      if (marked (other) < 0) {
+        LOG ("found tautological literal %d", other);
+        c->literals[0] = other; // Move to front of 'c'.
+        break;
+      }
+    }
+
+    if (l == end_of_c) {
+      LOG ("no tautological literal found");
+
+      // Restore old literal order in the clause because.
+
+      const const_literal_iterator begin_of_c = c->begin ();
+      while (l-- != begin_of_c) {
+        const int other = *l;
+        *l = prev_other;
+        prev_other = other;
+      }
+
+      continue; // ... with next candidate 'c' in 'pos'.
+    }
+
+    blocked++;
+    LOG (c, "blocked");
+    if (proof) {
+      proof->weaken_minus (c);
+    }
+    external->push_clause_on_extension_stack (c, lit);
+    blocker.reschedule.push_back (c);
+    mark_garbage (c);
+    j--;
+  }
+  if (j == pos.begin ())
+    erase_vector (pos);
+  else
+    pos.resize (j - pos.begin ());
+
+  stats.blocked += blocked;
+  LOG ("blocked %" PRId64 " clauses on %d (skipped %" PRId64 ")", blocked,
+       lit, skipped);
+
+  unmark (d);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Determine the set of candidate clauses with 'lit', which are checked to
+// be blocked by 'lit'.  Filter out too large and small clauses and which do
+// not have any negated other literal in any of the clauses with '-lit'.
+
+size_t Internal::block_candidates (Blocker &blocker, int lit) {
+
+  CADICAL_assert (blocker.candidates.empty ());
+
+  Occs &pos = occs (lit); // Positive occurrences of 'lit'.
+  Occs &nos = occs (-lit);
+
+  CADICAL_assert ((size_t) noccs (lit) <= pos.size ());
+  CADICAL_assert ((size_t) noccs (-lit) == nos.size ()); // Already flushed.
+
+  // Mark all literals in clauses with '-lit'.  Note that 'mark2' uses
+  // separate bits for 'lit' and '-lit'.
+  //
+  for (const auto &c : nos)
+    mark2 (c);
+
+  const auto eop = pos.end ();
+  auto j = pos.begin (), i = j;
+
+  for (; i != eop; i++) {
+    Clause *c = *j++ = *i;
+    if (c->garbage) {
+      j--;
+      continue;
+    }
+    CADICAL_assert (!c->redundant);
+    if (c->size > opts.blockmaxclslim)
+      continue;
+    if (c->size < opts.blockminclslim)
+      continue;
+    const const_literal_iterator eoc = c->end ();
+    const_literal_iterator l;
+    for (l = c->begin (); l != eoc; l++) {
+      const int other = *l;
+      if (other == lit)
+        continue;
+      CADICAL_assert (other != -lit);
+      CADICAL_assert (active (other));
+      CADICAL_assert (!val (other));
+      if (marked2 (-other))
+        break;
+    }
+    if (l != eoc)
+      blocker.candidates.push_back (c);
+  }
+  if (j == pos.begin ())
+    erase_vector (pos);
+  else
+    pos.resize (j - pos.begin ());
+
+  CADICAL_assert (pos.size () == (size_t) noccs (lit)); // Now also flushed.
+
+  for (const auto &c : nos)
+    unmark (c);
+
+  return blocker.candidates.size ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to find a clause with '-lit' which does not have any literal in
+// clauses with 'lit'.  If such a clause exists no candidate clause can be
+// blocked on 'lit' since all candidates would produce a non-tautological
+// resolvent with that clause.
+
+Clause *Internal::block_impossible (Blocker &blocker, int lit) {
+  CADICAL_assert (noccs (-lit) > 1);
+  CADICAL_assert (blocker.candidates.size () > 1);
+
+  for (const auto &c : blocker.candidates)
+    mark2 (c);
+
+  Occs &nos = occs (-lit);
+  Clause *res = 0;
+
+  for (const auto &c : nos) {
+    CADICAL_assert (!c->garbage);
+    CADICAL_assert (!c->redundant);
+    CADICAL_assert (c->size <= opts.blockmaxclslim);
+    const const_literal_iterator eoc = c->end ();
+    const_literal_iterator l;
+    for (l = c->begin (); l != eoc; l++) {
+      const int other = *l;
+      if (other == -lit)
+        continue;
+      CADICAL_assert (other != lit);
+      CADICAL_assert (active (other));
+      CADICAL_assert (!val (other));
+      if (marked2 (-other))
+        break;
+    }
+    if (l == eoc)
+      res = c;
+  }
+
+  for (const auto &c : blocker.candidates)
+    unmark (c);
+
+  if (res) {
+    LOG (res, "common non-tautological resolvent producing");
+    blocker.candidates.clear ();
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// In the general case we have at least two negative occurrences.
+
+void Internal::block_literal_with_at_least_two_negative_occs (
+    Blocker &blocker, int lit) {
+  CADICAL_assert (active (lit));
+  CADICAL_assert (!frozen (lit));
+  CADICAL_assert (noccs (lit) > 0);
+  CADICAL_assert (noccs (-lit) > 1);
+
+  Occs &nos = occs (-lit);
+  CADICAL_assert ((size_t) noccs (-lit) <= nos.size ());
+
+  int max_size = 0;
+
+  // Flush all garbage clauses in occurrence list 'nos' of '-lit' and
+  // determine the maximum size of negative clauses (with '-lit').
+  //
+  const auto eon = nos.end ();
+  auto j = nos.begin (), i = j;
+  for (; i != eon; i++) {
+    Clause *c = *j++ = *i;
+    if (c->garbage)
+      j--;
+    else if (c->size > max_size)
+      max_size = c->size;
+  }
+  if (j == nos.begin ())
+    erase_vector (nos);
+  else
+    nos.resize (j - nos.begin ());
+
+  CADICAL_assert (nos.size () == (size_t) noccs (-lit));
+  CADICAL_assert (nos.size () > 1);
+
+  // If the maximum size of a negative clause (with '-lit') exceeds the
+  // maximum clause size limit ignore this candidate literal.
+  //
+  if (max_size > opts.blockmaxclslim) {
+    LOG ("maximum size %d of clauses with %d exceeds clause size limit %d",
+         max_size, -lit, opts.blockmaxclslim);
+    return;
+  }
+
+  LOG ("maximum size %d of clauses with %d", max_size, -lit);
+
+  // We filter candidate clauses with positive occurrence of 'lit' in
+  // 'blocker.candidates' and return if no candidate clause remains.
+  // Candidates should be small enough and should have at least one literal
+  // which occurs negated in one of the clauses with '-lit'.
+  //
+  size_t candidates = block_candidates (blocker, lit);
+  if (!candidates) {
+    LOG ("no candidate clauses found");
+    return;
+  }
+
+  LOG ("found %zd candidate clauses", candidates);
+
+  // We further search for a clause with '-lit' that has no literal
+  // negated in any of the candidate clauses (except 'lit').  If such a
+  // clause exists, we know that none of the candidates is blocked.
+  //
+  if (candidates > 1 && block_impossible (blocker, lit)) {
+    LOG ("impossible to block any candidate clause on %d", lit);
+    CADICAL_assert (blocker.candidates.empty ());
+    return;
+  }
+
+  LOG ("trying to block %zd clauses out of %" PRId64 " with literal %d",
+       candidates, noccs (lit), lit);
+
+  int64_t blocked = 0;
+
+  // Go over all remaining candidates and try to block them on 'lit'.
+  //
+  for (const auto &c : blocker.candidates) {
+    CADICAL_assert (!c->garbage);
+    CADICAL_assert (!c->redundant);
+    if (!is_blocked_clause (c, lit))
+      continue;
+    blocked++;
+    LOG (c, "blocked");
+    if (proof) {
+      proof->weaken_minus (c);
+    }
+    external->push_clause_on_extension_stack (c, lit);
+    blocker.reschedule.push_back (c);
+    mark_garbage (c);
+  }
+
+  LOG ("blocked %" PRId64
+       " clauses on %d out of %zd candidates in %zd occurrences",
+       blocked, lit, blocker.candidates.size (), occs (lit).size ());
+
+  blocker.candidates.clear ();
+  stats.blocked += blocked;
+  if (blocked)
+    flush_occs (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Reschedule literals in a clause (except 'lit') which was blocked.
+
+void Internal::block_reschedule_clause (Blocker &blocker, int lit,
+                                        Clause *c) {
+#ifdef CADICAL_NDEBUG
+  (void) lit;
+#endif
+  CADICAL_assert (c->garbage);
+
+  for (const auto &other : *c) {
+
+    int64_t &n = noccs (other);
+    CADICAL_assert (n > 0);
+    n--;
+
+    LOG ("updating %d with %" PRId64 " positive and %" PRId64
+         " negative occurrences",
+         other, noccs (other), noccs (-other));
+
+    if (blocker.schedule.contains (vlit (-other)))
+      blocker.schedule.update (vlit (-other));
+    else if (active (other) && !frozen (other) && !marked_skip (-other)) {
+      LOG ("rescheduling to block clauses on %d", -other);
+      blocker.schedule.push_back (vlit (-other));
+    }
+
+    if (blocker.schedule.contains (vlit (other))) {
+      CADICAL_assert (other != lit);
+      blocker.schedule.update (vlit (other));
+    }
+  }
+}
+
+// Reschedule all literals in clauses blocked by 'lit' (except 'lit').
+
+void Internal::block_reschedule (Blocker &blocker, int lit) {
+  while (!blocker.reschedule.empty ()) {
+    Clause *c = blocker.reschedule.back ();
+    blocker.reschedule.pop_back ();
+    block_reschedule_clause (blocker, lit, c);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::block_literal (Blocker &blocker, int lit) {
+  CADICAL_assert (!marked_skip (lit));
+
+  if (!active (lit))
+    return; // Pure literal '-lit'.
+  if (frozen (lit))
+    return;
+
+  CADICAL_assert (!val (lit));
+
+  // If the maximum number of a negative clauses (with '-lit') exceeds the
+  // occurrence limit ignore this candidate literal.
+  //
+  if (noccs (-lit) > opts.blockocclim)
+    return;
+
+  LOG ("blocking literal candidate %d "
+       "with %" PRId64 " positive and %" PRId64 " negative occurrences",
+       lit, noccs (lit), noccs (-lit));
+
+  stats.blockcands++;
+
+  CADICAL_assert (blocker.reschedule.empty ());
+  CADICAL_assert (blocker.candidates.empty ());
+
+  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.  We also
+    // so it once happening 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
+    block_literal_with_at_least_two_negative_occs (blocker, lit);
+
+  // Done with blocked clause elimination on this literal and we do not
+  // have to try blocked clause elimination on it again until irredundant
+  // clauses with its negation are removed.
+  //
+  CADICAL_assert (!frozen (lit)); // just to be sure ...
+  unmark_block (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::block () {
+
+  if (!opts.block)
+    return false;
+  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);
+    init_watches ();
+    connect_watches ();
+    if (!propagate ()) {
+      LOG ("propagating units results in empty clause");
+      learn_empty_clause ();
+      CADICAL_assert (unsat);
+    }
+    clear_watches ();
+    reset_watches ();
+    if (unsat)
+      return false;
+  }
+
+  START_SIMPLIFIER (block, BLOCK);
+
+  stats.blockings++;
+
+  LOG ("block-%" PRId64 "", stats.blockings);
+
+  CADICAL_assert (!level);
+  CADICAL_assert (!watching ());
+  CADICAL_assert (!occurring ());
+
+  mark_satisfied_clauses_as_garbage ();
+
+  init_occs ();  // Occurrence lists for all literals.
+  init_noccs (); // Number of occurrences to avoid flushing garbage clauses.
+
+  Blocker blocker (this);
+  block_schedule (blocker);
+
+  int64_t blocked = stats.blocked;
+  int64_t resolutions = stats.blockres;
+  int64_t purelits = stats.blockpurelits;
+  int64_t pured = stats.blockpured;
+
+  while (!terminated_asynchronously () && !blocker.schedule.empty ()) {
+    int lit = u2i (blocker.schedule.front ());
+    blocker.schedule.pop_front ();
+    block_literal (blocker, lit);
+    block_reschedule (blocker, lit);
+  }
+
+  blocker.erase ();
+  reset_noccs ();
+  reset_occs ();
+
+  resolutions = stats.blockres - resolutions;
+  blocked = stats.blocked - blocked;
+
+  PHASE ("block", stats.blockings,
+         "blocked %" PRId64 " clauses in %" PRId64 " resolutions", blocked,
+         resolutions);
+
+  pured = stats.blockpured - pured;
+  purelits = stats.blockpurelits - purelits;
+
+  if (pured)
+    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+
+  if (purelits)
+    PHASE ("block", stats.blockings,
+           "found %" PRId64 " pure literals in %" PRId64 " clauses",
+           purelits, pured);
+  else
+    PHASE ("block", stats.blockings, "no pure literals found");
+
+  report ('b', !opts.reportall && !blocked);
+
+  STOP_SIMPLIFIER (block, BLOCK);
+
+  return blocked;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_ccadical.cpp b/src/sat/cadical/cadical_ccadical.cpp
new file mode 100644
index 000000000..ae5c1093f
--- /dev/null
+++ b/src/sat/cadical/cadical_ccadical.cpp
@@ -0,0 +1,211 @@
+#include "global.h"
+
+#include "cadical.hpp"
+
+#include <cstdlib>
+#include <cstring>
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+struct Wrapper : Learner, Terminator {
+
+  Solver *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;
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+#include "ccadical.h"
+
+ABC_NAMESPACE_IMPL_START
+
+using namespace CaDiCaL;
+
+const char *ccadical_signature (void) { return Solver::signature (); }
+
+CCaDiCaL *ccadical_init (void) { return (CCaDiCaL *) new Wrapper (); }
+
+void ccadical_release (CCaDiCaL *wrapper) { delete (Wrapper *) wrapper; }
+
+void ccadical_constrain (CCaDiCaL *wrapper, int lit) {
+  ((Wrapper *) wrapper)->solver->constrain (lit);
+}
+
+int ccadical_constraint_failed (CCaDiCaL *wrapper) {
+  return ((Wrapper *) wrapper)->solver->constraint_failed ();
+}
+
+void ccadical_set_option (CCaDiCaL *wrapper, const char *name, int val) {
+  ((Wrapper *) wrapper)->solver->set (name, val);
+}
+
+void ccadical_limit (CCaDiCaL *wrapper, const char *name, int val) {
+  ((Wrapper *) wrapper)->solver->limit (name, val);
+}
+
+int ccadical_get_option (CCaDiCaL *wrapper, const char *name) {
+  return ((Wrapper *) wrapper)->solver->get (name);
+}
+
+void ccadical_add (CCaDiCaL *wrapper, int lit) {
+  ((Wrapper *) wrapper)->solver->add (lit);
+}
+
+void ccadical_assume (CCaDiCaL *wrapper, int lit) {
+  ((Wrapper *) wrapper)->solver->assume (lit);
+}
+
+int ccadical_solve (CCaDiCaL *wrapper) {
+  return ((Wrapper *) wrapper)->solver->solve ();
+}
+
+int ccadical_simplify (CCaDiCaL *wrapper) {
+  return ((Wrapper *) wrapper)->solver->simplify ();
+}
+
+int ccadical_val (CCaDiCaL *wrapper, int lit) {
+  return ((Wrapper *) wrapper)->solver->val (lit);
+}
+
+int ccadical_failed (CCaDiCaL *wrapper, int lit) {
+  return ((Wrapper *) wrapper)->solver->failed (lit);
+}
+
+void ccadical_print_statistics (CCaDiCaL *wrapper) {
+  ((Wrapper *) wrapper)->solver->statistics ();
+}
+
+void ccadical_terminate (CCaDiCaL *wrapper) {
+  ((Wrapper *) wrapper)->solver->terminate ();
+}
+
+int64_t ccadical_active (CCaDiCaL *wrapper) {
+  return ((Wrapper *) wrapper)->solver->active ();
+}
+
+int64_t ccadical_irredundant (CCaDiCaL *wrapper) {
+  return ((Wrapper *) wrapper)->solver->irredundant ();
+}
+
+int ccadical_fixed (CCaDiCaL *wrapper, int lit) {
+  return ((Wrapper *) wrapper)->solver->fixed (lit);
+}
+
+void ccadical_set_terminate (CCaDiCaL *ptr, void *state,
+                             int (*terminate) (void *)) {
+  Wrapper *wrapper = (Wrapper *) ptr;
+  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);
+}
+
+void ccadical_melt (CCaDiCaL *ptr, int lit) {
+  ((Wrapper *) ptr)->solver->melt (lit);
+}
+
+int ccadical_frozen (CCaDiCaL *ptr, int lit) {
+  return ((Wrapper *) ptr)->solver->frozen (lit);
+}
+
+int ccadical_trace_proof (CCaDiCaL *ptr, FILE *file, const char *path) {
+  return ((Wrapper *) ptr)->solver->trace_proof (file, path);
+}
+
+void ccadical_close_proof (CCaDiCaL *ptr) {
+  ((Wrapper *) ptr)->solver->close_proof_trace ();
+}
+
+void ccadical_conclude (CCaDiCaL *ptr) {
+  ((Wrapper *) ptr)->solver->conclude ();
+}
+
+int ccadical_vars (CCaDiCaL *ptr) {
+  return ((Wrapper *) ptr)->solver->vars ();
+}
+
+int ccadical_reserve_difference (CCaDiCaL *ptr, int number_of_vars) {
+  return ((Wrapper *) ptr)->solver->reserve_difference (number_of_vars);
+}
+
+void ccadical_reserve(CCaDiCaL *ptr, int min_max_var) {
+  ((Wrapper *) ptr)->solver->reserve(min_max_var);
+}
+
+int ccadical_is_inconsistent(CCaDiCaL *ptr) {
+  return ((Wrapper *) ptr)->solver->inconsistent ();
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_checker.cpp b/src/sat/cadical/cadical_checker.cpp
new file mode 100644
index 000000000..63a5f2b10
--- /dev/null
+++ b/src/sat/cadical/cadical_checker.cpp
@@ -0,0 +1,654 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+inline unsigned Checker::l2u (int lit) {
+  CADICAL_assert (lit);
+  CADICAL_assert (lit != INT_MIN);
+  unsigned res = 2 * (abs (lit) - 1);
+  if (lit < 0)
+    res++;
+  return res;
+}
+
+inline signed char Checker::val (int lit) {
+  CADICAL_assert (lit);
+  CADICAL_assert (lit != INT_MIN);
+  CADICAL_assert (abs (lit) < size_vars);
+  CADICAL_assert (vals[lit] == -vals[-lit]);
+  return vals[lit];
+}
+
+signed char &Checker::mark (int lit) {
+  const unsigned u = l2u (lit);
+  CADICAL_assert (u < marks.size ());
+  return marks[u];
+}
+
+inline CheckerWatcher &Checker::watcher (int lit) {
+  const unsigned u = l2u (lit);
+  CADICAL_assert (u < watchers.size ());
+  return watchers[u];
+}
+
+/*------------------------------------------------------------------------*/
+
+CheckerClause *Checker::new_clause () {
+  const size_t size = simplified.size ();
+  CADICAL_assert (size > 1), CADICAL_assert (size <= UINT_MAX);
+  const size_t bytes = sizeof (CheckerClause) + (size - 2) * sizeof (int);
+  CheckerClause *res = (CheckerClause *) new char[bytes];
+  DeferDeleteArray<char> delete_res ((char *) res);
+  res->next = 0;
+  res->hash = last_hash;
+  res->size = size;
+  int *literals = res->literals, *p = literals;
+  for (const auto &lit : simplified)
+    *p++ = lit;
+  num_clauses++;
+
+  // First two literals are used as watches and should not be false.
+  //
+  for (unsigned i = 0; i < 2; i++) {
+    int lit = literals[i];
+    if (!val (lit))
+      continue;
+    for (unsigned j = i + 1; j < size; j++) {
+      int other = literals[j];
+      if (val (other))
+        continue;
+      swap (literals[i], literals[j]);
+      break;
+    }
+  }
+  CADICAL_assert (!val (literals[0]));
+  CADICAL_assert (!val (literals[1]));
+  watcher (literals[0]).push_back (CheckerWatch (literals[1], res));
+  watcher (literals[1]).push_back (CheckerWatch (literals[0], res));
+
+  delete_res.release ();
+  return res;
+}
+
+void Checker::delete_clause (CheckerClause *c) {
+  if (c->size) {
+    CADICAL_assert (c->size > 1);
+    CADICAL_assert (num_clauses);
+    num_clauses--;
+  } else {
+    CADICAL_assert (num_garbage);
+    num_garbage--;
+  }
+  delete[] (char *) c;
+}
+
+void Checker::enlarge_clauses () {
+  CADICAL_assert (num_clauses == size_clauses);
+  const uint64_t new_size_clauses = size_clauses ? 2 * size_clauses : 1;
+  LOG ("CHECKER enlarging clauses of checker from %" PRIu64 " to %" PRIu64,
+       (uint64_t) size_clauses, (uint64_t) new_size_clauses);
+  CheckerClause **new_clauses;
+  new_clauses = new CheckerClause *[new_size_clauses];
+  clear_n (new_clauses, new_size_clauses);
+  for (uint64_t i = 0; i < size_clauses; i++) {
+    for (CheckerClause *c = clauses[i], *next; c; c = next) {
+      next = c->next;
+      const uint64_t h = reduce_hash (c->hash, new_size_clauses);
+      c->next = new_clauses[h];
+      new_clauses[h] = c;
+    }
+  }
+  delete[] clauses;
+  clauses = new_clauses;
+  size_clauses = new_size_clauses;
+}
+
+bool Checker::clause_satisfied (CheckerClause *c) {
+  for (unsigned i = 0; i < c->size; i++)
+    if (val (c->literals[i]) > 0)
+      return true;
+  return false;
+}
+
+// The main reason why we have an explicit garbage collection phase is that
+// removing clauses from watcher lists eagerly might lead to an accumulated
+// quadratic algorithm.  Thus we delay removing garbage clauses from watcher
+// lists until garbage collection (even though we remove garbage clauses on
+// the fly during propagation too).  We also remove satisfied clauses.
+//
+void Checker::collect_garbage_clauses () {
+
+  stats.collections++;
+
+  for (size_t i = 0; i < size_clauses; i++) {
+    CheckerClause **p = clauses + i, *c;
+    while ((c = *p)) {
+      if (clause_satisfied (c)) {
+        c->size = 0; // mark as garbage
+        *p = c->next;
+        c->next = garbage;
+        garbage = c;
+        num_garbage++;
+        CADICAL_assert (num_clauses);
+        num_clauses--;
+      } else
+        p = &c->next;
+    }
+  }
+
+  LOG ("CHECKER collecting %" PRIu64 " garbage clauses %.0f%%", num_garbage,
+       percent (num_garbage, num_clauses));
+
+  for (int lit = -size_vars + 1; lit < size_vars; lit++) {
+    if (!lit)
+      continue;
+    CheckerWatcher &ws = watcher (lit);
+    const auto end = ws.end ();
+    auto j = ws.begin (), i = j;
+    for (; i != end; i++) {
+      CheckerWatch &w = *i;
+      if (w.clause->size)
+        *j++ = w;
+    }
+    if (j == ws.end ())
+      continue;
+    if (j == ws.begin ())
+      erase_vector (ws);
+    else
+      ws.resize (j - ws.begin ());
+  }
+
+  for (CheckerClause *c = garbage, *next; c; c = next)
+    next = c->next, delete_clause (c);
+
+  CADICAL_assert (!num_garbage);
+  garbage = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+Checker::Checker (Internal *i)
+    : internal (i), size_vars (0), vals (0), inconsistent (false),
+      num_clauses (0), num_garbage (0), size_clauses (0), clauses (0),
+      garbage (0), next_to_propagate (0), last_hash (0) {
+
+  // Initialize random number table for hash function.
+  //
+  Random random (42);
+  for (unsigned n = 0; n < num_nonces; n++) {
+    uint64_t nonce = random.next ();
+    if (!(nonce & 1))
+      nonce++;
+    CADICAL_assert (nonce), CADICAL_assert (nonce & 1);
+    nonces[n] = nonce;
+  }
+
+  memset (&stats, 0, sizeof (stats)); // Initialize statistics.
+}
+
+void Checker::connect_internal (Internal *i) {
+  internal = i;
+  LOG ("CHECKER connected to internal");
+}
+
+Checker::~Checker () {
+  LOG ("CHECKER delete");
+  vals -= size_vars;
+  delete[] vals;
+  for (size_t i = 0; i < size_clauses; i++)
+    for (CheckerClause *c = clauses[i], *next; c; c = next)
+      next = c->next, delete_clause (c);
+  for (CheckerClause *c = garbage, *next; c; c = next)
+    next = c->next, delete_clause (c);
+  delete[] clauses;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The simplicity for accessing 'vals' and 'watchers' directly through a
+// signed integer literal, comes with the price of slightly more complex
+// code in deleting and enlarging the checker data structures.
+
+void Checker::enlarge_vars (int64_t idx) {
+
+  CADICAL_assert (0 < idx), CADICAL_assert (idx <= INT_MAX);
+
+  int64_t new_size_vars = size_vars ? 2 * size_vars : 2;
+  while (idx >= new_size_vars)
+    new_size_vars *= 2;
+  LOG ("CHECKER enlarging variables of checker from %" PRId64 " to %" PRId64
+       "",
+       size_vars, new_size_vars);
+
+  signed char *new_vals;
+  new_vals = new signed char[2 * new_size_vars];
+  clear_n (new_vals, 2 * new_size_vars);
+  new_vals += new_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;
+  size_vars = new_size_vars;
+
+  watchers.resize (2 * new_size_vars);
+  marks.resize (2 * new_size_vars);
+
+  CADICAL_assert (idx < new_size_vars);
+}
+
+inline void Checker::import_literal (int lit) {
+  CADICAL_assert (lit);
+  CADICAL_assert (lit != INT_MIN);
+  int idx = abs (lit);
+  if (idx >= size_vars)
+    enlarge_vars (idx);
+  simplified.push_back (lit);
+  unsimplified.push_back (lit);
+}
+
+void Checker::import_clause (const vector<int> &c) {
+  for (const auto &lit : c)
+    import_literal (lit);
+}
+
+struct lit_smaller {
+  bool operator() (int a, int b) const {
+    int c = abs (a), d = abs (b);
+    if (c < d)
+      return true;
+    if (c > d)
+      return false;
+    return a < b;
+  }
+};
+
+bool Checker::tautological () {
+  sort (simplified.begin (), simplified.end (), lit_smaller ());
+  const auto end = simplified.end ();
+  auto j = simplified.begin ();
+  int prev = 0;
+  for (auto i = j; i != end; i++) {
+    int lit = *i;
+    if (lit == prev)
+      continue; // duplicated literal
+    if (lit == -prev)
+      return true; // tautological clause
+    const signed char tmp = val (lit);
+    if (tmp > 0)
+      return true; // satisfied literal and clause
+    *j++ = prev = lit;
+  }
+  simplified.resize (j - simplified.begin ());
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+uint64_t Checker::reduce_hash (uint64_t hash, uint64_t size) {
+  CADICAL_assert (size > 0);
+  unsigned shift = 32;
+  uint64_t res = hash;
+  while ((((uint64_t) 1) << shift) > size) {
+    res ^= res >> shift;
+    shift >>= 1;
+  }
+  res &= size - 1;
+  CADICAL_assert (res < size);
+  return res;
+}
+
+uint64_t Checker::compute_hash () {
+  unsigned j = last_id % num_nonces;
+  uint64_t tmp = nonces[j] * last_id;
+  return last_hash = tmp;
+}
+
+CheckerClause **Checker::find () {
+  stats.searches++;
+  CheckerClause **res, *c;
+  const uint64_t hash = compute_hash ();
+  const unsigned size = simplified.size ();
+  const uint64_t h = reduce_hash (hash, size_clauses);
+  for (const auto &lit : simplified)
+    mark (lit) = true;
+  for (res = clauses + h; (c = *res); res = &c->next) {
+    if (c->hash == hash && c->size == size) {
+      bool found = true;
+      const int *literals = c->literals;
+      for (unsigned i = 0; found && i != size; i++)
+        found = mark (literals[i]);
+      if (found)
+        break;
+    }
+    stats.collisions++;
+  }
+  for (const auto &lit : simplified)
+    mark (lit) = false;
+  return res;
+}
+
+void Checker::insert () {
+  stats.insertions++;
+  if (num_clauses == size_clauses)
+    enlarge_clauses ();
+  const uint64_t h = reduce_hash (compute_hash (), size_clauses);
+  CheckerClause *c = new_clause ();
+  c->next = clauses[h];
+  clauses[h] = c;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void Checker::assign (int lit) {
+  CADICAL_assert (!val (lit));
+  vals[lit] = 1;
+  vals[-lit] = -1;
+  trail.push_back (lit);
+}
+
+inline void Checker::assume (int lit) {
+  signed char tmp = val (lit);
+  if (tmp > 0)
+    return;
+  CADICAL_assert (!tmp);
+  stats.assumptions++;
+  assign (lit);
+}
+
+void Checker::backtrack (unsigned previously_propagated) {
+
+  CADICAL_assert (previously_propagated <= trail.size ());
+
+  while (trail.size () > previously_propagated) {
+    int lit = trail.back ();
+    CADICAL_assert (val (lit) > 0);
+    CADICAL_assert (val (-lit) < 0);
+    vals[lit] = vals[-lit] = 0;
+    trail.pop_back ();
+  }
+
+  trail.resize (previously_propagated);
+  next_to_propagate = previously_propagated;
+  CADICAL_assert (trail.size () == next_to_propagate);
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is a standard propagation routine without using blocking literals
+// nor without saving the last replacement position.
+
+bool Checker::propagate () {
+  bool res = true;
+  while (res && next_to_propagate < trail.size ()) {
+    int lit = trail[next_to_propagate++];
+    stats.propagations++;
+    CADICAL_assert (val (lit) > 0);
+    CADICAL_assert (abs (lit) < size_vars);
+    CheckerWatcher &ws = watcher (-lit);
+    const auto end = ws.end ();
+    auto j = ws.begin (), i = j;
+    for (; res && i != end; i++) {
+      CheckerWatch &w = *j++ = *i;
+      const int blit = w.blit;
+      CADICAL_assert (blit != -lit);
+      const signed char blit_val = val (blit);
+      if (blit_val > 0)
+        continue;
+      const unsigned size = w.size;
+      if (size == 2) { // not precise since
+        if (blit_val < 0)
+          res = false; // clause might be garbage
+        else
+          assign (w.blit); // but still sound
+      } else {
+        CADICAL_assert (size > 2);
+        CheckerClause *c = w.clause;
+        if (!c->size) {
+          j--;
+          continue;
+        } // skip garbage clauses
+        CADICAL_assert (size == c->size);
+        int *lits = c->literals;
+        int other = lits[0] ^ lits[1] ^ (-lit);
+        CADICAL_assert (other != -lit);
+        signed char other_val = val (other);
+        if (other_val > 0) {
+          j[-1].blit = other;
+          continue;
+        }
+        lits[0] = other, lits[1] = -lit;
+        unsigned k;
+        int replacement = 0;
+        signed char replacement_val = -1;
+        for (k = 2; k < size; k++)
+          if ((replacement_val = val (replacement = lits[k])) >= 0)
+            break;
+        if (replacement_val >= 0) {
+          watcher (replacement).push_back (CheckerWatch (-lit, c));
+          swap (lits[1], lits[k]);
+          j--;
+        } else if (!other_val)
+          assign (other);
+        else
+          res = false;
+      }
+    }
+    while (i != end)
+      *j++ = *i++;
+    ws.resize (j - ws.begin ());
+  }
+  return res;
+}
+
+bool Checker::check () {
+  stats.checks++;
+  if (inconsistent)
+    return true;
+  unsigned previously_propagated = next_to_propagate;
+  for (const auto &lit : simplified)
+    assume (-lit);
+  bool res = !propagate ();
+  backtrack (previously_propagated);
+  return res;
+}
+
+bool Checker::check_blocked () {
+  for (const auto &lit : unsimplified) {
+    mark (-lit) = true;
+  }
+  vector<int> not_blocked;
+  for (size_t i = 0; i < size_clauses; i++) {
+    for (CheckerClause *c = clauses[i], *next; c; c = next) {
+      next = c->next;
+      unsigned count = 0;
+      int first;
+      for (int *i = c->literals; i < c->literals + c->size; i++) {
+        const int lit = *i;
+        if (val (lit) > 0) {
+          LOG (c->literals, c->size, "satisfied clause");
+          count = 2;
+          break;
+        }
+        if (mark (lit)) {
+          count++;
+          LOG (c->literals, c->size, "clause");
+          first = lit;
+        }
+      }
+      if (count == 1)
+        not_blocked.push_back (first);
+    }
+  }
+  for (const auto &lit : not_blocked) {
+    mark (lit) = false;
+  }
+  bool blocked = false;
+  for (const auto &lit : unsimplified) {
+    if (mark (-lit))
+      blocked = true;
+    mark (-lit) = false;
+  }
+  return blocked;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Checker::add_clause (const char *type) {
+#ifndef LOGGING
+  (void) type;
+#endif
+
+  // If there are enough garbage clauses collect them first.
+  if (num_garbage > 0.5 * max ((size_t) size_clauses, (size_t) size_vars))
+    collect_garbage_clauses ();
+
+  int unit = 0;
+  for (const auto &lit : simplified) {
+    const signed char tmp = val (lit);
+    if (tmp < 0)
+      continue;
+    CADICAL_assert (!tmp);
+    if (unit) {
+      unit = INT_MIN;
+      break;
+    }
+    unit = lit;
+  }
+
+  if (simplified.empty ()) {
+    LOG ("CHECKER added empty %s clause", type);
+    inconsistent = true;
+  }
+  if (!unit) {
+    LOG ("CHECKER added and checked falsified %s clause", type);
+    inconsistent = true;
+  } else if (unit != INT_MIN) {
+    LOG ("CHECKER added and checked %s unit clause %d", type, unit);
+    assign (unit);
+    stats.units++;
+    if (!propagate ()) {
+      LOG ("CHECKER inconsistent after propagating %s unit", type);
+      inconsistent = true;
+    }
+  } else
+    insert ();
+}
+
+void Checker::add_original_clause (int64_t id, bool, const vector<int> &c,
+                                   bool) {
+  if (inconsistent)
+    return;
+  START (checking);
+  LOG (c, "CHECKER addition of original clause");
+  stats.added++;
+  stats.original++;
+  import_clause (c);
+  last_id = id;
+  if (tautological ())
+    LOG ("CHECKER ignoring satisfied original clause");
+  else
+    add_clause ("original");
+  simplified.clear ();
+  unsimplified.clear ();
+  STOP (checking);
+}
+
+void Checker::add_derived_clause (int64_t id, bool, const vector<int> &c,
+                                  const vector<int64_t> &) {
+  if (inconsistent)
+    return;
+  START (checking);
+  LOG (c, "CHECKER addition of derived clause");
+  stats.added++;
+  stats.derived++;
+  import_clause (c);
+  last_id = id;
+  if (tautological ())
+    LOG ("CHECKER ignoring satisfied derived clause");
+  else if (!check () && !check_blocked ()) { // needed for ER proof support
+    fatal_message_start ();
+    fputs ("failed to check derived clause:\n", stderr);
+    for (const auto &lit : unsimplified)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fatal_message_end ();
+  } else
+    add_clause ("derived");
+  simplified.clear ();
+  unsimplified.clear ();
+  STOP (checking);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Checker::delete_clause (int64_t id, bool, const vector<int> &c) {
+  if (inconsistent)
+    return;
+  START (checking);
+  LOG (c, "CHECKER checking deletion of clause");
+  stats.deleted++;
+  simplified.clear ();   // Can be non-empty if clause allocation fails.
+  unsimplified.clear (); // Can be non-empty if clause allocation fails.
+  import_clause (c);
+  last_id = id;
+  if (!tautological ()) {
+    CheckerClause **p = find (), *d = *p;
+    if (d) {
+      CADICAL_assert (d->size > 1);
+      // Remove from hash table, mark as garbage, connect to garbage list.
+      num_garbage++;
+      CADICAL_assert (num_clauses);
+      num_clauses--;
+      *p = d->next;
+      d->next = garbage;
+      garbage = d;
+      d->size = 0;
+    } else {
+      fatal_message_start ();
+      fputs ("deleted clause not in proof:\n", stderr);
+      for (const auto &lit : unsimplified)
+        fprintf (stderr, "%d ", lit);
+      fputc ('0', stderr);
+      fatal_message_end ();
+    }
+  }
+  simplified.clear ();
+  unsimplified.clear ();
+  STOP (checking);
+}
+
+void Checker::add_assumption_clause (int64_t id, const vector<int> &c,
+                                     const vector<int64_t> &chain) {
+  add_derived_clause (id, true, c, chain);
+  delete_clause (id, true, c);
+}
+
+/*------------------------------------------------------------------------*/
+
+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");
+    }
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_clause.cpp b/src/sat/cadical/cadical_clause.cpp
new file mode 100644
index 000000000..1c84994a6
--- /dev/null
+++ b/src/sat/cadical/cadical_clause.cpp
@@ -0,0 +1,649 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Signed marking or unmarking of a clause or the global 'clause'.
+
+void Internal::mark (Clause *c) {
+  for (const auto &lit : *c)
+    mark (lit);
+}
+
+void Internal::mark2 (Clause *c) {
+  for (const auto &lit : *c)
+    mark2 (lit);
+}
+
+void Internal::unmark (Clause *c) {
+  for (const auto &lit : *c)
+    unmark (lit);
+}
+
+void Internal::mark_clause () {
+  for (const auto &lit : clause)
+    mark (lit);
+}
+
+void Internal::unmark_clause () {
+  for (const auto &lit : clause)
+    unmark (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Mark the variables of an irredundant clause to 'have been removed', which
+// will trigger these variables to be considered again in the next bounded
+// variable elimination phase.  This is called from 'mark_garbage' below.
+// Note that 'mark_removed (int lit)' will also mark the blocking flag of
+// '-lit' to trigger reconsidering blocking clauses on '-lit'.
+
+void Internal::mark_removed (Clause *c, int except) {
+  LOG (c, "marking removed");
+  CADICAL_assert (!c->redundant);
+  for (const auto &lit : *c)
+    if (lit != except)
+      mark_removed (lit);
+}
+
+// Mark the variables of a (redundant or irredundant) clause to 'have been
+// added', which triggers clauses with such a variables, to be considered
+// both as a subsumed or subsuming clause in the next subsumption phase.
+// This function is called from 'new_clause' below as well as in situations
+// where a clause is shrunken (and thus needs to be at least considered
+// again to subsume a larger clause).  We also use this to tell
+// 'ternary' preprocessing reconsider clauses on an added literal as well as
+// trying to block clauses on it.
+
+inline void Internal::mark_added (int lit, int size, bool redundant) {
+  mark_subsume (lit);
+  if (size == 3)
+    mark_ternary (lit);
+  if (!redundant)
+    mark_block (lit);
+  if (!redundant || size == 2)
+    mark_factor (lit);
+}
+
+void Internal::mark_added (Clause *c) {
+  LOG (c, "marking added");
+  CADICAL_assert (likely_to_be_kept_clause (c));
+  for (const auto &lit : *c)
+    mark_added (lit, c->size, c->redundant);
+}
+
+/*------------------------------------------------------------------------*/
+
+Clause *Internal::new_clause (bool red, int glue) {
+
+  CADICAL_assert (clause.size () <= (size_t) INT_MAX);
+  const int size = (int) clause.size ();
+  CADICAL_assert (size >= 2);
+
+  if (glue > size)
+    glue = size;
+
+  size_t bytes = Clause::bytes (size);
+  Clause *c = (Clause *) new char[bytes];
+  DeferDeleteArray<char> clause_delete ((char *) c);
+
+  c->id = ++clause_id;
+
+  c->conditioned = false;
+  c->covered = false;
+  c->enqueued = false;
+  c->frozen = false;
+  c->garbage = false;
+  c->gate = false;
+  c->hyper = false;
+  c->instantiated = false;
+  c->moved = false;
+  c->reason = false;
+  c->redundant = red;
+  c->transred = false;
+  c->subsume = false;
+  c->swept = false;
+  c->flushed = false;
+  c->vivified = false;
+  c->vivify = false;
+  c->used = 0;
+
+  c->glue = glue;
+  c->size = size;
+  c->pos = 2;
+
+  for (int i = 0; i < size; i++)
+    c->literals[i] = clause[i];
+
+  // Just checking that we did not mess up our sophisticated memory layout.
+  // This might be compiler dependent though. Crucial for correctness.
+  //
+  CADICAL_assert (c->bytes () == bytes);
+
+  stats.current.total++;
+  stats.added.total++;
+
+  if (red) {
+    stats.current.redundant++;
+    stats.added.redundant++;
+  } else {
+    stats.irrlits += size;
+    stats.current.irredundant++;
+    stats.added.irredundant++;
+  }
+
+  clauses.push_back (c);
+  clause_delete.release ();
+  LOG (c, "new pointer %p", (void *) c);
+
+  if (likely_to_be_kept_clause (c))
+    mark_added (c);
+
+  return c;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::promote_clause (Clause *c, int new_glue) {
+  CADICAL_assert (c->redundant);
+  const int tier1limit = tier1[false];
+  const int tier2limit = max (tier1limit, tier2[false]);
+  if (!c->redundant)
+    return;
+  if (c->hyper)
+    return;
+  int old_glue = c->glue;
+  if (new_glue >= old_glue)
+    return;
+  if (old_glue > tier1limit && new_glue <= tier1limit) {
+    LOG (c, "promoting with new glue %d to tier1", new_glue);
+    stats.promoted1++;
+    c->used = max_used;
+  } else if (old_glue > tier2limit && new_glue <= tier2limit) {
+    LOG (c, "promoting with new glue %d to tier2", new_glue);
+    stats.promoted2++;
+  } else if (old_glue <= tier2limit)
+    LOG (c, "keeping with new glue %d in tier2", new_glue);
+  else
+    LOG (c, "keeping with new glue %d in tier3", new_glue);
+  stats.improvedglue++;
+  c->glue = new_glue;
+}
+/*------------------------------------------------------------------------*/
+
+void Internal::promote_clause_glue_only (Clause *c, int new_glue) {
+  CADICAL_assert (c->redundant);
+  if (c->hyper)
+    return;
+  int old_glue = c->glue;
+  const int tier1limit = tier1[false];
+  const int tier2limit = max (tier1limit, tier2[false]);
+  if (new_glue >= old_glue)
+    return;
+  if (new_glue <= tier1limit) {
+    LOG (c, "promoting with new glue %d to tier1", new_glue);
+    stats.promoted1++;
+    c->used = max_used;
+  } else if (old_glue > tier2limit && new_glue <= tier2limit) {
+    LOG (c, "promoting with new glue %d to tier2", new_glue);
+    stats.promoted2++;
+  } else if (old_glue <= tier2limit)
+    LOG (c, "keeping with new glue %d in tier2", new_glue);
+  else
+    LOG (c, "keeping with new glue %d in tier3", new_glue);
+  stats.improvedglue++;
+  c->glue = new_glue;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Shrinking a clause, e.g., removing one or more literals, requires to fix
+// the 'pos' field, if it exists and points after the new last literal. We
+// also have adjust the global statistics counter of irredundant literals
+// for irredundant clauses, and also adjust the glue value of redundant
+// clauses if the size becomes smaller than the glue.  Also mark the
+// literals in the resulting clause as 'added'.  The result is the number of
+// (aligned) removed bytes, resulting from shrinking the clause.
+//
+size_t Internal::shrink_clause (Clause *c, int new_size) {
+  if (opts.check && is_external_forgettable (c->id))
+    mark_garbage_external_forgettable (c->id);
+  CADICAL_assert (new_size >= 2);
+  int old_size = c->size;
+  CADICAL_assert (new_size < old_size);
+#ifndef CADICAL_NDEBUG
+  for (int i = c->size; i < new_size; i++)
+    c->literals[i] = 0;
+#endif
+
+  if (c->pos >= new_size)
+    c->pos = 2;
+
+  size_t old_bytes = c->bytes ();
+  c->size = new_size;
+  size_t new_bytes = c->bytes ();
+  size_t res = old_bytes - new_bytes;
+
+  if (c->redundant)
+    promote_clause_glue_only (c, min (c->size - 1, c->glue));
+  else {
+    int delta_size = old_size - new_size;
+    CADICAL_assert (stats.irrlits >= delta_size);
+    stats.irrlits -= delta_size;
+  }
+
+  if (likely_to_be_kept_clause (c))
+    mark_added (c);
+
+  return res;
+}
+
+// This is the 'raw' deallocation of a clause.  If the clause is in the
+// arena nothing happens.  If the clause is not in the arena its memory is
+// reclaimed immediately.
+
+void Internal::deallocate_clause (Clause *c) {
+  char *p = (char *) c;
+  if (arena.contains (p))
+    return;
+  LOG (c, "deallocate pointer %p", (void *) c);
+  delete[] p;
+}
+
+void Internal::delete_clause (Clause *c) {
+  LOG (c, "delete pointer %p", (void *) c);
+  size_t bytes = c->bytes ();
+  stats.collected += bytes;
+  if (c->garbage) {
+    CADICAL_assert (stats.garbage.bytes >= (int64_t) bytes);
+    stats.garbage.bytes -= bytes;
+    CADICAL_assert (stats.garbage.clauses > 0);
+    stats.garbage.clauses--;
+    CADICAL_assert (stats.garbage.literals >= c->size);
+    stats.garbage.literals -= c->size;
+
+    // See the discussion in 'propagate' on avoiding to eagerly trace binary
+    // clauses as deleted (produce 'd ...' lines) as soon they are marked
+    // garbage.  We avoid this and only trace them as deleted when they are
+    // actually deleted here.  This allows the solver to propagate binary
+    // garbage clauses without producing incorrect 'd' lines.  The effect
+    // from the proof perspective is that the deletion of these binary
+    // clauses occurs later in the proof file.
+    //
+    if (proof && c->size == 2 && !c->flushed) {
+      proof->delete_clause (c);
+    }
+  }
+  deallocate_clause (c);
+}
+
+// We want to eagerly update statistics as soon clauses are marked garbage.
+// Otherwise 'report' for instance gives wrong numbers after 'subsume'
+// before the next 'reduce'.  Thus we factored out marking and accounting
+// for garbage clauses.
+//
+// Eagerly deleting clauses instead is problematic, since references to
+// these clauses need to be flushed, which is too costly to do eagerly.
+//
+// We also update garbage statistics at this point.  This helps to
+// determine whether the garbage collector should be called during for
+// instance bounded variable elimination, which usually generates lots of
+// garbage clauses.
+//
+// In order not to miss any update to these clause statistics we call
+// 'check_clause_stats' after garbage collection in debugging mode.
+//
+void Internal::mark_garbage (Clause *c) {
+
+  CADICAL_assert (!c->garbage);
+
+  // Delay tracing deletion of binary clauses.  See the discussion above in
+  // 'delete_clause' and also in 'propagate'.
+  //
+  if (proof && (c->size != 2 || !watching ())) {
+    c->flushed = true;
+    proof->delete_clause (c);
+  }
+
+  // Because of the internal model checking, external forgettable clauses
+  // must be marked as removed already upon mark_garbage, can not wait until
+  // actual deletion.
+  if (opts.check && is_external_forgettable (c->id))
+    mark_garbage_external_forgettable (c->id);
+
+  CADICAL_assert (stats.current.total > 0);
+  stats.current.total--;
+
+  size_t bytes = c->bytes ();
+  if (c->redundant) {
+    CADICAL_assert (stats.current.redundant > 0);
+    stats.current.redundant--;
+  } else {
+    CADICAL_assert (stats.current.irredundant > 0);
+    stats.current.irredundant--;
+    CADICAL_assert (stats.irrlits >= c->size);
+    stats.irrlits -= c->size;
+    mark_removed (c);
+  }
+  stats.garbage.bytes += bytes;
+  stats.garbage.clauses++;
+  stats.garbage.literals += c->size;
+  c->garbage = true;
+  c->used = 0;
+
+  LOG (c, "marked garbage pointer %p", (void *) c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Almost the same function as 'search_assign' except that we do not pretend
+// to learn a new unit clause (which was confusing in log files).
+
+void Internal::assign_original_unit (int64_t id, int lit) {
+  CADICAL_assert (!level || opts.chrono);
+  CADICAL_assert (!unsat);
+  const int idx = vidx (lit);
+  CADICAL_assert (!vals[idx]);
+  CADICAL_assert (!flags (idx).eliminated ());
+  Var &v = var (idx);
+  v.level = 0;
+  v.trail = (int) trail.size ();
+  v.reason = 0;
+  const signed char tmp = sign (lit);
+  set_val (idx, tmp);
+  trail.push_back (lit);
+  num_assigned++;
+  const unsigned uidx = vlit (lit);
+  if (lrat || frat)
+    unit_clauses (uidx) = id;
+  LOG ("original unit assign %d", lit);
+  CADICAL_assert (num_assigned == trail.size () || level);
+  mark_fixed (lit);
+  if (level)
+    return;
+  if (propagate ())
+    return;
+  CADICAL_assert (conflict);
+  LOG ("propagation of original unit results in conflict");
+  learn_empty_clause ();
+}
+
+// New clause added through the API, e.g., while parsing a DIMACS file.
+// Also used by external_propagate in various different modes.
+// clause, original, lrat_chain and external->eclause are set.
+// from_propagator and force_no_backtrack change the behaviour.
+// sometimes the pointer to the new clause is needed, therefore it is
+// made sure that newest_clause points to the new clause upon return.
+//
+// TODO: Find another name for 'tainted' in the context of ilb, tainted
+// is reconstruction related already and they should not mix.
+void Internal::add_new_original_clause (int64_t id) {
+
+  if (!from_propagator && level && !opts.ilb) {
+    backtrack ();
+  } else if (tainted_literal) {
+    CADICAL_assert (val (tainted_literal));
+    int new_level = var (tainted_literal).level - 1;
+    CADICAL_assert (new_level >= 0);
+    backtrack (new_level);
+  }
+  CADICAL_assert (!tainted_literal);
+  LOG (original, "original clause");
+  CADICAL_assert (clause.empty ());
+  bool skip = false;
+  unordered_set<int> learned_levels;
+  size_t unassigned = 0;
+  newest_clause = 0;
+  if (unsat) {
+    LOG ("skipping clause since formula is already inconsistent");
+    skip = true;
+  } else {
+    CADICAL_assert (clause.empty ());
+    for (const auto &lit : original) {
+      int tmp = marked (lit);
+      if (tmp > 0) {
+        LOG ("removing duplicated literal %d", lit);
+      } else if (tmp < 0) {
+        LOG ("tautological since both %d and %d occur", -lit, lit);
+        skip = true;
+      } else {
+        mark (lit);
+        tmp = fixed (lit);
+        if (tmp < 0) {
+          LOG ("removing falsified literal %d", lit);
+          if (lrat) {
+            int elit = externalize (lit);
+            unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
+            if (!external->ext_units[eidx]) {
+              int64_t uid = unit_id (-lit);
+              lrat_chain.push_back (uid);
+            }
+          }
+        } else if (tmp > 0) {
+          LOG ("satisfied since literal %d true", lit);
+          skip = true;
+        } else {
+          clause.push_back (lit);
+          CADICAL_assert (flags (lit).status != Flags::UNUSED);
+          tmp = val (lit);
+          if (tmp)
+            learned_levels.insert (var (lit).level);
+          else
+            unassigned++;
+        }
+      }
+    }
+    for (const auto &lit : original)
+      unmark (lit);
+  }
+  if (skip) {
+    if (from_propagator) {
+      stats.ext_prop.elearn_conf++;
+
+      // In case it was a skipped external forgettable, we need to mark it
+      // immediately as removed
+
+      if (opts.check && is_external_forgettable (id))
+        mark_garbage_external_forgettable (id);
+    }
+    if (proof) {
+      proof->delete_external_original_clause (id, false, external->eclause);
+    }
+  } else {
+    int64_t new_id = id;
+    const size_t size = clause.size ();
+    if (original.size () > size) {
+      new_id = ++clause_id;
+      if (proof) {
+        if (lrat)
+          lrat_chain.push_back (id);
+        proof->add_derived_clause (new_id, false, clause, lrat_chain);
+        proof->delete_external_original_clause (id, false,
+                                                external->eclause);
+      }
+      external->check_learned_clause ();
+
+      if (from_propagator) {
+        // The original form of the added clause is immediately forgotten
+        // TODO: shall we save and check the simplified form? (one with
+        // new_id)
+        if (opts.check && is_external_forgettable (id))
+          mark_garbage_external_forgettable (id);
+      }
+    }
+    external->eclause.clear ();
+    lrat_chain.clear ();
+    if (!size) {
+      if (from_propagator)
+        stats.ext_prop.elearn_conf++;
+      CADICAL_assert (!unsat);
+      if (!original.size ())
+        VERBOSE (1, "found empty original clause");
+      else
+        VERBOSE (1, "found falsified original clause");
+      unsat = true;
+      conflict_id = new_id;
+      marked_failed = true;
+      conclusion.push_back (new_id);
+    } else if (size == 1) {
+      if (force_no_backtrack) {
+        CADICAL_assert (level);
+        const int idx = vidx (clause[0]);
+        CADICAL_assert (val (clause[0]) >= 0);
+        CADICAL_assert (!flags (idx).eliminated ());
+        Var &v = var (idx);
+        CADICAL_assert (val (clause[0]));
+        v.level = 0;
+        v.reason = 0;
+        const unsigned uidx = vlit (clause[0]);
+        if (lrat || frat)
+          unit_clauses (uidx) = new_id;
+        mark_fixed (clause[0]);
+      } else {
+        const int lit = clause[0];
+        CADICAL_assert (!val (lit) || var (lit).level);
+        if (val (lit) < 0)
+          backtrack (var (lit).level - 1);
+        CADICAL_assert (val (lit) >= 0);
+        handle_external_clause (0);
+        assign_original_unit (new_id, lit);
+      }
+    } else {
+      move_literals_to_watch ();
+#ifndef CADICAL_NDEBUG
+      check_watched_literal_invariants ();
+#endif
+      int glue = (int) (learned_levels.size () + unassigned);
+      CADICAL_assert (glue <= (int) clause.size ());
+      bool clause_redundancy = from_propagator && ext_clause_forgettable;
+      Clause *c = new_clause (clause_redundancy, glue);
+      c->id = new_id;
+      clause_id--;
+      watch_clause (c);
+      clause.clear ();
+      original.clear ();
+      handle_external_clause (c);
+      newest_clause = c;
+    }
+  }
+  clause.clear ();
+  lrat_chain.clear ();
+}
+
+// Add learned new clause during conflict analysis and watch it. Requires
+// that the clause is at least of size 2, and the first two literals
+// are assigned at the highest decision level.
+//
+Clause *Internal::new_learned_redundant_clause (int glue) {
+  CADICAL_assert (clause.size () > 1);
+#ifndef CADICAL_NDEBUG
+  for (size_t i = 2; i < clause.size (); i++)
+    CADICAL_assert (var (clause[0]).level >= var (clause[i]).level),
+        CADICAL_assert (var (clause[1]).level >= var (clause[i]).level);
+#endif
+  external->check_learned_clause ();
+  Clause *res = new_clause (true, glue);
+  if (proof) {
+    proof->add_derived_clause (res, lrat_chain);
+  }
+  CADICAL_assert (watching ());
+  watch_clause (res);
+  return res;
+}
+
+// Add hyper binary resolved clause during 'probing'.
+//
+Clause *Internal::new_hyper_binary_resolved_clause (bool red, int glue) {
+  external->check_learned_clause ();
+  Clause *res = new_clause (red, glue);
+  if (proof) {
+    proof->add_derived_clause (res, lrat_chain);
+  }
+  CADICAL_assert (watching ());
+  watch_clause (res);
+  return res;
+}
+
+// Add hyper ternary resolved clause during 'ternary'.
+//
+Clause *Internal::new_hyper_ternary_resolved_clause (bool red) {
+  external->check_learned_clause ();
+  size_t size = clause.size ();
+  Clause *res = new_clause (red, size);
+  if (proof) {
+    proof->add_derived_clause (res, lrat_chain);
+  }
+  CADICAL_assert (!watching ());
+  return res;
+}
+
+Clause *Internal::new_factor_clause () {
+  external->check_learned_clause ();
+  stats.factor_added++;
+  stats.literals_factored += clause.size ();
+  Clause *res = new_clause (false, 0);
+  if (proof) {
+    proof->add_derived_clause (res, lrat_chain);
+  }
+  CADICAL_assert (!watching ());
+  CADICAL_assert (occurring ());
+  for (const auto &lit : *res) {
+    occs (lit).push_back (res);
+  }
+  return res;
+}
+
+// Add hyper ternary resolved clause during 'congruence' and watch it
+//
+Clause *
+Internal::new_hyper_ternary_resolved_clause_and_watch (bool red,
+                                                       bool full_watching) {
+  external->check_learned_clause ();
+  size_t size = clause.size ();
+  Clause *res = new_clause (red, size);
+  if (proof) {
+    proof->add_derived_clause (res, lrat_chain);
+  }
+  if (full_watching) {
+    CADICAL_assert (watching ());
+    watch_clause (res);
+  }
+  return res;
+}
+
+// Add a new clause with same glue and redundancy as 'orig' but literals are
+// assumed to be in 'clause' in 'decompose' and 'vivify'.
+//
+Clause *Internal::new_clause_as (const Clause *orig) {
+  external->check_learned_clause ();
+  const int new_glue = orig->glue;
+  Clause *res = new_clause (orig->redundant, new_glue);
+  if (proof) {
+    proof->add_derived_clause (res, lrat_chain);
+  }
+  CADICAL_assert (watching ());
+  watch_clause (res);
+  return res;
+}
+
+// Add resolved clause during resolution, e.g., bounded variable
+// elimination, but do not connect its occurrences here.
+//
+Clause *Internal::new_resolved_irredundant_clause () {
+  external->check_learned_clause ();
+  if (proof) {
+    proof->add_derived_clause (clause_id + 1, false, clause, lrat_chain);
+  }
+  Clause *res = new_clause (false);
+  CADICAL_assert (!watching ());
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_collect.cpp b/src/sat/cadical/cadical_collect.cpp
new file mode 100644
index 000000000..c36e063b2
--- /dev/null
+++ b/src/sat/cadical/cadical_collect.cpp
@@ -0,0 +1,551 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Returns the positive number '1' ( > 0) if the given clause is root level
+// satisfied or the negative number '-1' ( < 0) if it is not root level
+// satisfied but contains a root level falsified literal. Otherwise, if it
+// contains neither a satisfied nor falsified literal, then '0' is returned.
+
+int Internal::clause_contains_fixed_literal (Clause *c) {
+  int satisfied = 0, falsified = 0;
+  for (const auto &lit : *c) {
+    const int tmp = fixed (lit);
+    if (tmp > 0) {
+      LOG (c, "root level satisfied literal %d in", lit);
+      satisfied++;
+    }
+    if (tmp < 0) {
+      LOG (c, "root level falsified literal %d in", lit);
+      falsified++;
+    }
+  }
+  if (satisfied)
+    return 1;
+  else if (falsified)
+    return -1;
+  else
+    return 0;
+}
+
+// Assume that the clause is not root level satisfied but contains a literal
+// set to false (root level falsified literal), so it can be shrunken.  The
+// clause data is not actually reallocated at this point to avoid dealing
+// with issues of special policies for watching binary clauses or whether a
+// clause is extended or not. Only its size field is adjusted accordingly
+// after flushing out root level falsified literals.
+
+void Internal::remove_falsified_literals (Clause *c) {
+  const const_literal_iterator end = c->end ();
+  const_literal_iterator i;
+  int num_non_false = 0;
+  for (i = c->begin (); num_non_false < 2 && i != end; i++)
+    if (fixed (*i) >= 0)
+      num_non_false++;
+  if (num_non_false < 2)
+    return;
+  if (proof) {
+    // Flush changes the clause id, external forgettables need to be
+    // marked here (or the new id could be used instead of old one)
+    if (opts.check && is_external_forgettable (c->id))
+      mark_garbage_external_forgettable (c->id);
+    proof->flush_clause (c);
+  }
+  literal_iterator j = c->begin ();
+  for (i = j; i != end; i++) {
+    const int lit = *j++ = *i, tmp = fixed (lit);
+    CADICAL_assert (tmp <= 0);
+    if (tmp >= 0)
+      continue;
+    LOG ("flushing %d", lit);
+    j--;
+  }
+  stats.collected += shrink_clause (c, j - c->begin ());
+}
+
+// If there are new units (fixed variables) since the last garbage
+// collection we go over all clauses, mark satisfied ones as garbage and
+// flush falsified literals.  Otherwise if no new units have been generated
+// since the last garbage collection just skip this step.
+
+void Internal::mark_satisfied_clauses_as_garbage () {
+
+  if (last.collect.fixed >= stats.all.fixed)
+    return;
+  last.collect.fixed = stats.all.fixed;
+
+  LOG ("marking satisfied clauses and removing falsified literals");
+
+  for (const auto &c : clauses) {
+    if (c->garbage)
+      continue;
+    const int tmp = clause_contains_fixed_literal (c);
+    if (tmp > 0)
+      mark_garbage (c);
+    else if (tmp < 0)
+      remove_falsified_literals (c);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// 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");
+  CADICAL_assert (!protected_reasons);
+#ifdef LOGGING
+  size_t count = 0;
+#endif
+  for (const auto &lit : trail) {
+    if (!active (lit))
+      continue;
+    CADICAL_assert (val (lit));
+    Var &v = var (lit);
+    CADICAL_assert (v.level > 0);
+    Clause *reason = v.reason;
+    if (!reason)
+      continue;
+    if (reason == external_reason)
+      continue;
+    LOG (reason, "protecting assigned %d reason %p", lit, (void *) reason);
+    CADICAL_assert (!reason->reason);
+    reason->reason = true;
+#ifdef LOGGING
+    count++;
+#endif
+  }
+  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");
+  CADICAL_assert (protected_reasons);
+#ifdef LOGGING
+  size_t count = 0;
+#endif
+  for (const auto &lit : trail) {
+    if (!active (lit))
+      continue;
+    CADICAL_assert (val (lit));
+    Var &v = var (lit);
+    CADICAL_assert (v.level > 0);
+    Clause *reason = v.reason;
+    if (!reason)
+      continue;
+    if (reason == external_reason)
+      continue;
+    LOG (reason, "unprotecting assigned %d reason %p", lit,
+         (void *) reason);
+    CADICAL_assert (reason->reason);
+    reason->reason = false;
+#ifdef LOGGING
+    count++;
+#endif
+  }
+  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
+// the number of non-garbage clauses.
+
+size_t Internal::flush_occs (int lit) {
+  Occs &os = occs (lit);
+  const const_occs_iterator end = os.end ();
+  occs_iterator j = os.begin ();
+  const_occs_iterator i;
+  size_t res = 0;
+  Clause *c;
+  for (i = j; i != end; i++) {
+    c = *i;
+    if (c->collect ())
+      continue;
+    *j++ = c->moved ? c->copy : c;
+    // CADICAL_assert (!c->redundant); // -> not true in sweeping
+    res++;
+  }
+  os.resize (j - os.begin ());
+  shrink_occs (os);
+  return res;
+}
+
+// Update watch lists before deleting garbage clauses in the context of
+// 'reduce' where we watch and no occurrence lists.  We have to protect
+// reason clauses not be collected and thus we have this additional check
+// hidden in 'Clause.collect', which for the root level context of
+// preprocessing is actually redundant.
+
+inline void Internal::flush_watches (int lit, Watches &saved) {
+  CADICAL_assert (saved.empty ());
+  Watches &ws = watches (lit);
+  const const_watch_iterator end = ws.end ();
+  watch_iterator j = ws.begin ();
+  const_watch_iterator i;
+  for (i = j; i != end; i++) {
+    Watch w = *i;
+    Clause *c = w.clause;
+    if (c->collect ())
+      continue;
+    if (c->moved)
+      c = w.clause = c->copy;
+    w.size = c->size;
+    const int new_blit_pos = (c->literals[0] == lit);
+    LOG (c, "clause in flush_watch starting from %d", lit);
+    CADICAL_assert (c->literals[!new_blit_pos] == lit); /*FW1*/
+    w.blit = c->literals[new_blit_pos];
+    if (w.binary ())
+      *j++ = w;
+    else
+      saved.push_back (w);
+  }
+  ws.resize (j - ws.begin ());
+  for (const auto &w : saved)
+    ws.push_back (w);
+  saved.clear ();
+  shrink_vector (ws);
+}
+
+void Internal::flush_all_occs_and_watches () {
+  if (occurring ())
+    for (auto idx : vars)
+      flush_occs (idx), flush_occs (-idx);
+
+  if (watching ()) {
+    Watches tmp;
+    for (auto idx : vars)
+      flush_watches (idx, tmp), flush_watches (-idx, tmp);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::update_reason_references () {
+  LOG ("update assigned reason references");
+#ifdef LOGGING
+  size_t count = 0;
+#endif
+  for (auto &lit : trail) {
+    if (!active (lit))
+      continue;
+    Var &v = var (lit);
+    Clause *c = v.reason;
+    if (!c)
+      continue;
+    if (c == external_reason)
+      continue;
+    LOG (c, "updating assigned %d reason", lit);
+    CADICAL_assert (c->reason);
+    CADICAL_assert (c->moved);
+    Clause *d = c->copy;
+    v.reason = d;
+#ifdef LOGGING
+    count++;
+#endif
+  }
+  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
+// which are likely accessed after each other.
+
+void Internal::delete_garbage_clauses () {
+
+  flush_all_occs_and_watches ();
+
+  LOG ("deleting garbage clauses");
+#ifndef CADICAL_QUIET
+  int64_t collected_bytes = 0, collected_clauses = 0;
+#endif
+  const auto end = clauses.end ();
+  auto j = clauses.begin (), i = j;
+  while (i != end) {
+    Clause *c = *j++ = *i++;
+    if (!c->collect ())
+      continue;
+#ifndef CADICAL_QUIET
+    collected_bytes += c->bytes ();
+    collected_clauses++;
+#endif
+    delete_clause (c);
+    j--;
+  }
+  clauses.resize (j - clauses.begin ());
+  shrink_vector (clauses);
+
+  PHASE ("collect", stats.collections,
+         "collected %" PRId64 " bytes of %" PRId64 " garbage clauses",
+         collected_bytes, collected_clauses);
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the start of the copying garbage collector using the arena.  At
+// the core is the following function, which copies a clause to the 'to'
+// space of the arena.  Be careful if this clause is a reason of an
+// assignment.  In that case update the reason reference.
+//
+void Internal::copy_clause (Clause *c) {
+  LOG (c, "moving");
+  CADICAL_assert (!c->moved);
+  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, (void *) c,
+       (void *) c->copy);
+}
+
+// This is the moving garbage collector.
+
+void Internal::copy_non_garbage_clauses () {
+
+  size_t collected_clauses = 0, collected_bytes = 0;
+  size_t moved_clauses = 0, moved_bytes = 0;
+
+  // First determine 'moved_bytes' and 'collected_bytes'.
+  //
+  for (const auto &c : clauses)
+    if (!c->collect ())
+      moved_bytes += c->bytes (), moved_clauses++;
+    else
+      collected_bytes += c->bytes (), collected_clauses++;
+
+  PHASE ("collect", stats.collections,
+         "moving %zd bytes %.0f%% of %zd non garbage clauses", moved_bytes,
+         percent (moved_bytes, collected_bytes + moved_bytes),
+         moved_clauses);
+  (void) moved_clauses, (void) collected_clauses, (void) collected_bytes;
+  // Prepare 'to' space of size 'moved_bytes'.
+  //
+  arena.prepare (moved_bytes);
+
+  // Keep clauses in arena in the same order.
+  //
+  if (opts.arenacompact)
+    for (const auto &c : clauses)
+      if (!c->collect () && arena.contains (c))
+        copy_clause (c);
+
+  if (opts.arenatype == 1 || !watching ()) {
+
+    // Localize according to current clause order.
+
+    // If the option 'opts.arenatype == 1' is set, then this means the
+    // solver uses the original order of clauses.  If there are no watches,
+    // we can not use the watched based copying policies below.  This
+    // happens if garbage collection is triggered during bounded variable
+    // elimination.
+
+    // Copy clauses according to the order of calling 'copy_clause', which
+    // in essence just gives a compacting garbage collector, since their
+    // relative order is kept, and actually already gives the largest
+    // benefit due to better cache locality.
+
+    for (const auto &c : clauses)
+      if (!c->moved && !c->collect ())
+        copy_clause (c);
+
+  } else if (opts.arenatype == 2) {
+
+    // Localize according to (original) variable order.
+
+    // This is almost the version used by MiniSAT and descendants.
+    // Our version uses saved phases too.
+
+    for (int sign = -1; sign <= 1; sign += 2)
+      for (auto idx : vars)
+        for (const auto &w : watches (sign * likely_phase (idx)))
+          if (!w.clause->moved && !w.clause->collect ())
+            copy_clause (w.clause);
+
+  } else {
+
+    // Localize according to decision queue order.
+
+    // This is the default for search. It allocates clauses in the order of
+    // the decision queue and also uses saved phases.  It seems faster than
+    // the MiniSAT version and thus we keep 'opts.arenatype == 3'.
+
+    CADICAL_assert (opts.arenatype == 3);
+
+    for (int sign = -1; sign <= 1; sign += 2)
+      for (int idx = queue.last; idx; idx = link (idx).prev)
+        for (const auto &w : watches (sign * likely_phase (idx)))
+          if (!w.clause->moved && !w.clause->collect ())
+            copy_clause (w.clause);
+  }
+
+  // Do not forget to move clauses which are not watched, which happened in
+  // a rare situation, and now is only left as defensive code.
+  //
+  for (const auto &c : clauses)
+    if (!c->collect () && !c->moved)
+      copy_clause (c);
+
+  flush_all_occs_and_watches ();
+  update_reason_references ();
+
+  // Replace and flush clause references in 'clauses'.
+  //
+  const auto end = clauses.end ();
+  auto j = clauses.begin (), i = j;
+  for (; i != end; i++) {
+    Clause *c = *i;
+    if (c->collect ())
+      delete_clause (c);
+    else
+      CADICAL_assert (c->moved), *j++ = c->copy, deallocate_clause (c);
+  }
+  clauses.resize (j - clauses.begin ());
+  if (clauses.size () < clauses.capacity () / 2)
+    shrink_vector (clauses);
+
+  if (opts.arenasort)
+    rsort (clauses.begin (), clauses.end (), pointer_rank ());
+
+  // Release 'from' space completely and then swap 'to' with 'from'.
+  //
+  arena.swap ();
+
+  PHASE ("collect", stats.collections,
+         "collected %zd bytes %.0f%% of %zd garbage clauses",
+         collected_bytes,
+         percent (collected_bytes, collected_bytes + moved_bytes),
+         collected_clauses);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Maintaining clause statistics is complex and error prone but necessary
+// for proper scheduling of garbage collection, particularly during bounded
+// variable elimination.  With this function we can check whether these
+// statistics are updated correctly.
+
+void Internal::check_clause_stats () {
+#ifndef CADICAL_NDEBUG
+  int64_t irredundant = 0, redundant = 0, total = 0, irrlits = 0;
+  for (const auto &c : clauses) {
+    if (c->garbage)
+      continue;
+    if (c->redundant)
+      redundant++;
+    else
+      irredundant++;
+    if (!c->redundant)
+      irrlits += c->size;
+    total++;
+  }
+  CADICAL_assert (stats.current.irredundant == irredundant);
+  CADICAL_assert (stats.current.redundant == redundant);
+  CADICAL_assert (stats.current.total == total);
+  CADICAL_assert (stats.irrlits == irrlits);
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+// only delete binary clauses from watch list that are already mark as
+// deleted.
+void Internal::remove_garbage_binaries () {
+  if (unsat)
+    return;
+  START (collect);
+
+  if (!protected_reasons)
+    protect_reasons ();
+  int backtrack_level = level + 1;
+  Watches saved;
+  for (auto v : vars) {
+    for (auto lit : {-v, v}) {
+      CADICAL_assert (saved.empty ());
+      Watches &ws = watches (lit);
+      const const_watch_iterator end = ws.end ();
+      watch_iterator j = ws.begin ();
+      const_watch_iterator i;
+      for (i = j; i != end; i++) {
+        Watch w = *i;
+        *j++ = w;
+        Clause *c = w.clause;
+        COVER (!w.binary () && c->size == 2);
+        if (!w.binary ())
+          continue;
+        if (c->reason && c->garbage) {
+          COVER (true);
+          CADICAL_assert (c->size == 2);
+          backtrack_level =
+              min (backtrack_level, var (c->literals[0]).level);
+          LOG ("need to backtrack to before level %d", backtrack_level);
+          --j;
+          continue;
+        }
+        if (!c->collect ())
+          continue;
+        LOG (c, "removing from watch list");
+        --j;
+      }
+      ws.resize (j - ws.begin ());
+      shrink_vector (ws);
+    }
+  }
+  delete_garbage_clauses ();
+  unprotect_reasons ();
+  if (backtrack_level - 1 < level)
+    backtrack (backtrack_level - 1);
+  STOP (collect);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::arenaing () { return opts.arena && (stats.collections > 1); }
+
+void Internal::garbage_collection () {
+  if (unsat)
+    return;
+  START (collect);
+  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);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_compact.cpp b/src/sat/cadical/cadical_compact.cpp
new file mode 100644
index 000000000..6747218cb
--- /dev/null
+++ b/src/sat/cadical/cadical_compact.cpp
@@ -0,0 +1,557 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Compacting removes holes generated by inactive variables (fixed,
+// eliminated, substituted or pure) by mapping active variables indices down
+// to a contiguous interval of indices.
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::compacting () {
+  if (level)
+    return false;
+  if (!opts.compact)
+    return false;
+  if (stats.conflicts < lim.compact)
+    return false;
+  int inactive = max_var - active ();
+  CADICAL_assert (inactive >= 0);
+  if (!inactive)
+    return false;
+  if (inactive < opts.compactmin)
+    return false;
+  return inactive >= (1e-3 * opts.compactlim) * max_var;
+}
+
+/*------------------------------------------------------------------------*/
+
+struct Mapper {
+
+  Internal *internal;
+  int new_max_var;             // New 'max_var' after compacting.
+  int *table;                  // Old variable index to new literal map.
+  int first_fixed;             // First fixed variable index.
+  int map_first_fixed;         // Mapped literal of first fixed variable.
+  signed char first_fixed_val; // Value of first fixed variable.
+  size_t new_vsize;
+
+  /*----------------------------------------------------------------------*/
+  // We produce a compacting garbage collector like map of old 'src' to
+  // new 'dst' variables.  Inactive variables are just skipped except for
+  // fixed ones which will be mapped to the first fixed variable (in the
+  // appropriate phase).  This avoids to handle the case 'fixed value'
+  // separately as it is done in Lingeling, where fixed variables are
+  // mapped to the internal variable '1'.
+  //
+  Mapper (Internal *i)
+      : internal (i), new_max_var (0), first_fixed (0), map_first_fixed (0),
+        first_fixed_val (0) {
+    table = new int[internal->max_var + 1u];
+    clear_n (table, internal->max_var + 1u);
+
+    CADICAL_assert (!internal->level);
+
+    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)
+        table[first_fixed = src] = map_first_fixed = ++new_max_var;
+    }
+
+    first_fixed_val = first_fixed ? internal->val (first_fixed) : 0;
+    new_vsize = new_max_var + 1u;
+  }
+
+  ~Mapper () { delete[] table; }
+
+  /*----------------------------------------------------------------------*/
+  // Map old variable indices.  A result of zero means not mapped.
+  //
+  int map_idx (int src) {
+    CADICAL_assert (0 < src);
+    CADICAL_assert (src <= internal->max_var);
+    const int res = table[src];
+    CADICAL_assert (res <= new_max_var);
+    return res;
+  }
+
+  /*----------------------------------------------------------------------*/
+  // The 'map_idx' above is just a look-up into the 'table'.  Here we have
+  // to care about signedness of 'src', and in addition that fixed variables
+  // have all to be mapped to the first fixed variable 'first_fixed'.
+  //
+  int map_lit (int src) {
+    int res = map_idx (abs (src));
+    if (!res) {
+      const signed char tmp = internal->val (src);
+      if (tmp) {
+        CADICAL_assert (first_fixed);
+        res = map_first_fixed;
+        if (tmp != first_fixed_val)
+          res = -res;
+      }
+    } else if ((src) < 0)
+      res = -res;
+    CADICAL_assert (abs (res) <= new_max_var);
+    return res;
+  }
+
+  /*----------------------------------------------------------------------*/
+  // Map positive variable indices in vector.
+  //
+  template <class T> void map_vector (vector<T> &v) {
+    for (auto src : internal->vars) {
+      const int dst = map_idx (src);
+      if (!dst)
+        continue;
+      CADICAL_assert (0 < dst);
+      CADICAL_assert (dst <= src);
+      v[dst] = v[src];
+    }
+    v.resize (new_vsize);
+    shrink_vector (v);
+  }
+
+  /*----------------------------------------------------------------------*/
+  // Map positive and negative variable indices in two-sided vector.
+  //
+  template <class T> void map2_vector (vector<T> &v) {
+    for (auto src : internal->vars) {
+      const int dst = map_idx (src);
+      if (!dst)
+        continue;
+      CADICAL_assert (0 < dst);
+      CADICAL_assert (dst <= src);
+      v[2 * dst] = v[2 * src];
+      v[2 * dst + 1] = v[2 * src + 1];
+    }
+    v.resize (2 * new_vsize);
+    shrink_vector (v);
+  }
+
+  /*----------------------------------------------------------------------*/
+  // Map a vector of literals, flush inactive literals, then resize and
+  // shrink it to fit the new size after flushing.
+  //
+  void map_flush_and_shrink_lits (vector<int> &v) {
+    const auto end = v.end ();
+    auto j = v.begin (), i = j;
+    for (; i != end; i++) {
+      const int src = *i;
+      int dst = map_idx (abs (src));
+      CADICAL_assert (abs (dst) <= abs (src));
+      if (!dst)
+        continue;
+      if (src < 0)
+        dst = -dst;
+      *j++ = dst;
+    }
+    v.resize (j - v.begin ());
+    shrink_vector (v);
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+static signed char *ignore_clang_analyze_memory_leak_warning;
+
+void Internal::compact () {
+
+  START (compact);
+
+  CADICAL_assert (active () < max_var);
+
+  stats.compacts++;
+
+  CADICAL_assert (!level);
+  CADICAL_assert (!unsat);
+  CADICAL_assert (!conflict);
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (levels.empty ());
+  CADICAL_assert (analyzed.empty ());
+  CADICAL_assert (minimized.empty ());
+  CADICAL_assert (control.size () == 1);
+  CADICAL_assert (propagated == trail.size ());
+
+  garbage_collection ();
+
+  Mapper mapper (this);
+
+  if (mapper.first_fixed)
+    LOG ("found first fixed %d",
+         sign (mapper.first_fixed_val) * mapper.first_fixed);
+  else
+    LOG ("no variable fixed");
+
+  if (!assumptions.empty ()) {
+    CADICAL_assert (!external->assumptions.empty ());
+    LOG ("temporarily reset internal assumptions");
+    reset_assumptions ();
+  }
+
+  const bool is_constraint = !constraint.empty ();
+  if (is_constraint) {
+    CADICAL_assert (!external->constraint.empty ());
+    LOG ("temporarily reset internal constraint");
+    reset_constraint ();
+  }
+
+  /*======================================================================*/
+  // In this first part we only map stuff without reallocation / shrinking.
+  /*======================================================================*/
+
+  // Flush the external indices.  This has to occur before we map 'vals'.
+  // Also fixes external units.
+  //
+  for (auto eidx : external->vars) {
+    int src = external->e2i[eidx];
+    if (!src) {
+      continue;
+    }
+    if (lrat || frat) {
+      CADICAL_assert (eidx > 0);
+      CADICAL_assert (external->ext_units.size () >= (size_t) 2 * eidx + 1);
+      int64_t id1 = external->ext_units[2 * eidx];
+      int64_t id2 = external->ext_units[2 * eidx + 1];
+      CADICAL_assert (!id1 || !id2);
+      if (!id1 && !id2) {
+        int64_t new_id1 = unit_clauses (2 * src);
+        int64_t new_id2 = unit_clauses (2 * src + 1);
+        external->ext_units[2 * eidx] = new_id1;
+        external->ext_units[2 * eidx + 1] = new_id2;
+      }
+    }
+    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;
+  }
+
+  // Delete garbage units. Needs to occur before resizing unit_clauses
+  //
+  if (lrat || frat) {
+    for (auto src : internal->vars) {
+      const int dst = mapper.map_idx (src);
+      CADICAL_assert (dst <= src);
+      const signed char tmp = internal->val (src);
+      if (!dst && !tmp) {
+        unit_clauses (2 * src) = 0;
+        unit_clauses (2 * src + 1) = 0;
+        continue;
+      }
+      if (!tmp || src == mapper.first_fixed) {
+        CADICAL_assert (0 < dst);
+        if (dst == src)
+          continue;
+        CADICAL_assert (!unit_clauses (2 * dst) && !unit_clauses (2 * dst + 1));
+        unit_clauses (2 * dst) = unit_clauses (2 * src);
+        unit_clauses (2 * dst + 1) = unit_clauses (2 * src + 1);
+        unit_clauses (2 * src) = 0;
+        unit_clauses (2 * src + 1) = 0;
+        continue;
+      }
+      int64_t id = unit_clauses (2 * src);
+      int lit = src;
+      if (!id) {
+        id = unit_clauses (2 * src + 1);
+        lit = -lit;
+      }
+      unit_clauses (2 * src) = 0;
+      unit_clauses (2 * src + 1) = 0;
+      CADICAL_assert (id);
+    }
+    unit_clauses_idx.resize (2 * mapper.new_vsize);
+    shrink_vector (unit_clauses_idx);
+  }
+  // Map the literals in all clauses.
+  //
+  for (const auto &c : clauses) {
+    CADICAL_assert (!c->garbage);
+    for (auto &src : *c) {
+      CADICAL_assert (!val (src));
+      int dst;
+      dst = mapper.map_lit (src);
+      CADICAL_assert (dst || c->garbage);
+      src = dst;
+    }
+  }
+
+  // Map the blocking literals in all watches.
+  //
+  if (!wtab.empty ())
+    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'.
+  {
+    int prev = 0, mapped_prev = 0, next;
+    for (int idx = queue.first; idx; idx = next) {
+      next = links[idx].next;
+      if (idx == mapper.first_fixed)
+        continue;
+      const int dst = mapper.map_idx (idx);
+      if (!dst)
+        continue;
+      CADICAL_assert (active (idx));
+      if (prev)
+        links[prev].next = dst;
+      else
+        queue.first = dst;
+      links[idx].prev = mapped_prev;
+      mapped_prev = dst;
+      prev = idx;
+    }
+    if (prev)
+      links[prev].next = 0;
+    else
+      queue.first = 0;
+    queue.unassigned = queue.last = mapped_prev;
+  }
+
+  /*======================================================================*/
+  // In the second part we map, flush and shrink arrays.
+  /*======================================================================*/
+
+  CADICAL_assert (trail.size () == num_assigned);
+  mapper.map_flush_and_shrink_lits (trail);
+  propagated = trail.size ();
+  num_assigned = trail.size ();
+  if (mapper.first_fixed) {
+    CADICAL_assert (trail.size () == 1);
+    var (mapper.first_fixed).trail = 0; // before mapping 'vtab'
+  } else
+    CADICAL_assert (trail.empty ());
+
+  if (!probes.empty ())
+    mapper.map_flush_and_shrink_lits (probes);
+
+  if (!sweep_schedule.empty ())
+    mapper.map_flush_and_shrink_lits (sweep_schedule);
+
+  /*======================================================================*/
+  // In the third part we map stuff and also reallocate memory.
+  /*======================================================================*/
+
+  // Now we continue in reverse order of allocated bytes, e.g., see
+  // '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);
+  mapper.map_vector (phases.min);
+
+  // Special code for 'frozentab'.
+  //
+  for (auto src : vars) {
+    const int dst = abs (mapper.map_lit (src));
+    if (!dst)
+      continue;
+    if (src == dst)
+      continue;
+    CADICAL_assert (dst < src);
+    if ((size_t) src >= frozentab.size ())
+      break;
+    if ((size_t) dst >= frozentab.size ())
+      break;
+    frozentab[dst] += frozentab[src];
+    frozentab[src] = 0;
+  }
+  frozentab.resize (min (frozentab.size (), mapper.new_vsize));
+  shrink_vector (frozentab);
+
+  // Special code for 'relevanttab'.
+  //
+  if (external) {
+    for (auto src : vars) {
+      const int dst = abs (mapper.map_lit (src));
+      if (!dst)
+        continue;
+      if (src == dst)
+        continue;
+      CADICAL_assert (dst < src);
+
+      relevanttab[dst] += relevanttab[src];
+      relevanttab[src] = 0;
+    }
+    relevanttab.resize (mapper.new_vsize);
+    shrink_vector (relevanttab);
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  if (!external->assumptions.empty ()) {
+
+    for (const auto &elit : external->assumptions) {
+      CADICAL_assert (elit);
+      CADICAL_assert (elit != INT_MIN);
+      int eidx = abs (elit);
+      CADICAL_assert (eidx <= external->max_var);
+      int ilit = external->e2i[eidx];
+      CADICAL_assert (ilit); // Because we froze all!!!
+      if (elit < 0)
+        ilit = -ilit;
+      assume (ilit);
+    }
+
+    PHASE ("compact", stats.compacts, "reassumed %zd external assumptions",
+           external->assumptions.size ());
+  }
+
+  // Special case for 'val' as for 'val' we trade branch less code for
+  // memory and always allocated an [-maxvar,...,maxvar] array.
+  {
+    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 (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;
+    delete[] vals;
+    vals = new_vals;
+    vsize = mapper.new_vsize;
+  }
+
+  // 'constrain' uses 'val', so this code has to be after remapping that
+  if (is_constraint) {
+    CADICAL_assert (!level);
+    CADICAL_assert (!external->constraint.back ());
+    for (auto elit : external->constraint) {
+      CADICAL_assert (elit != INT_MIN);
+      int eidx = abs (elit);
+      CADICAL_assert (eidx <= external->max_var);
+      int ilit = external->e2i[eidx];
+      CADICAL_assert (!ilit == !elit);
+      if (elit < 0)
+        ilit = -ilit;
+      LOG ("re adding lit external %d internal %d to constraint", elit,
+           ilit);
+      constrain (ilit);
+    }
+    PHASE ("compact", stats.compacts,
+           "added %zd external literals to constraint",
+           external->constraint.size () - 1);
+  }
+
+  mapper.map_vector (i2e);
+  mapper.map2_vector (ptab);
+  mapper.map_vector (btab);
+  mapper.map_vector (gtab);
+  mapper.map_vector (links);
+  mapper.map_vector (vtab);
+  if (!ntab.empty ())
+    mapper.map2_vector (ntab);
+  if (!wtab.empty ())
+    mapper.map2_vector (wtab);
+  if (!otab.empty ())
+    mapper.map2_vector (otab);
+  if (!rtab.empty ())
+    mapper.map2_vector (rtab);
+  if (!big.empty ())
+    mapper.map2_vector (big);
+
+  /*======================================================================*/
+  // In the fourth part we map the binary heap for scores.
+  /*======================================================================*/
+
+  // The simplest way to map a binary heap is to get all elements from the
+  // heap and reinsert them.  This could be slightly improved in terms of
+  // speed if we add a 'flush (int * map)' function to 'Heap', but that is
+  // pretty complicated and would require that the 'Heap' knows that mapped
+  // elements with 'zero' destination should be flushed.
+
+  vector<int> saved;
+  CADICAL_assert (saved.empty ());
+  if (!scores.empty ()) {
+    while (!scores.empty ()) {
+      const int src = scores.front ();
+      scores.pop_front ();
+      const int dst = mapper.map_idx (src);
+      if (!dst)
+        continue;
+      if (src == mapper.first_fixed)
+        continue;
+      saved.push_back (dst);
+    }
+    scores.erase ();
+  }
+  mapper.map_vector (stab);
+  if (!saved.empty ()) {
+    for (const auto idx : saved)
+      scores.push_back (idx);
+    scores.shrink ();
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  PHASE ("compact", stats.compacts,
+         "reducing internal variables from %d to %d", max_var,
+         mapper.new_max_var);
+
+  /*----------------------------------------------------------------------*/
+
+  // Need to adjust the target and best assigned counters too.
+
+  size_t new_target_assigned = 0, new_best_assigned = 0;
+
+  for (auto idx : Range (mapper.new_max_var)) {
+    if (phases.target[idx])
+      new_target_assigned++;
+    if (phases.best[idx])
+      new_best_assigned++;
+  }
+
+  LOG ("reset target assigned from %zd to %zd", target_assigned,
+       new_target_assigned);
+  LOG ("reset best assigned from %zd to %zd", best_assigned,
+       new_best_assigned);
+
+  target_assigned = new_target_assigned;
+  best_assigned = new_best_assigned;
+  no_conflict_until = 0;
+  notified = 0;
+
+  INIT_EMA (averages.current.trail.fast, opts.ematrailfast);
+  INIT_EMA (averages.current.trail.slow, opts.ematrailslow);
+
+  /*----------------------------------------------------------------------*/
+
+  max_var = mapper.new_max_var;
+
+  stats.unused = 0;
+  stats.inactive = stats.now.fixed = mapper.first_fixed ? 1 : 0;
+  stats.now.substituted = stats.now.eliminated = stats.now.pure = 0;
+
+  check_var_stats ();
+
+  int64_t delta = opts.compactint * (stats.compacts + 1);
+  lim.compact = stats.conflicts + delta;
+
+  PHASE ("compact", stats.compacts,
+         "new compact limit %" PRId64 " after %" PRId64 " conflicts",
+         lim.compact, delta);
+
+  STOP (compact);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_condition.cpp b/src/sat/cadical/cadical_condition.cpp
new file mode 100644
index 000000000..8c2f72cf7
--- /dev/null
+++ b/src/sat/cadical/cadical_condition.cpp
@@ -0,0 +1,946 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Globally blocked clause elimination (which we call here 'conditioning')
+// is described first in the PhD thesis of Benjamin Kiesl from 2019.  An
+// extended version, which in particular describes the algorithm implemented
+// below is in our invited ATVA'19 paper [KieslHeuleBiere-ATVA'19].  This
+// accordingly needs witnesses consisting potentially of more than one
+// literal.  It is the first technique implemented in CaDiCaL with this
+// feature (PR clause elimination thus should work in principle too).
+
+// Basically globally blocked clauses are like set blocked clauses, except
+// that the witness cube (of literals to be flipped during reconstruction)
+// can contain variables which are not in the blocked clause.  This
+// can simulate some interesting global optimizations like 'headlines' from
+// the FAN algorithm for ATPG.  The technique was actually motivated to
+// simulate this optimization.  It turns out that globally blocked clauses
+// can be seen as 'conditional autarkies', where in essence the condition
+// cube is the negation of the globally blocked redundant clause (it
+// needs to contain one autarky literal though) and the autarky part
+// represents the witness.
+
+/*------------------------------------------------------------------------*/
+
+// Elimination of globally blocked clauses is first tried in regular
+// intervals in terms of the number of conflicts.  Then the main heuristics
+// is to trigger 'condition' if the decision level is above the current
+// moving average of the back jump level.
+
+// TODO We might need to consider less frequent conditioning.
+
+bool Internal::conditioning () {
+
+  if (!opts.condition)
+    return false;
+  if (!preprocessing && !opts.inprocessing)
+    return false;
+  if (preprocessing)
+    CADICAL_assert (lim.preprocessing);
+
+  // Triggered in regular 'opts.conditionint' conflict intervals.
+  //
+  if (lim.condition > stats.conflicts)
+    return false;
+
+  if (!level)
+    return false; // One decision necessary.
+
+  if (level <= averages.current.jump)
+    return false; // Main heuristic.
+
+  if (!stats.current.irredundant)
+    return false;
+  double remain = active ();
+  if (!remain)
+    return false;
+  double ratio = stats.current.irredundant / remain;
+  return ratio <= opts.conditionmaxrat;
+}
+
+/*------------------------------------------------------------------------*/
+
+// We start with the current assignment and then temporarily unassign
+// literals.  They are reassigned afterwards.  The global state of the CDCL
+// solver should not change though.  Thus we copied from 'search_unassign'
+// in 'backtrack.cpp' what is needed to unassign literals and then from
+// 'search_assign' in 'propagate.cpp' what is needed for reassigning
+// literals, but restricted the copied code to only updating the actual
+// assignment (in 'vals') and not changing anything else.
+
+// We use temporarily unassigning for two purposes.  First, if a conditional
+// literal does not occur negated in a candidate clause it is unassigned.
+// Second, as a minor optimization, we first unassign all root-level
+// assigned (fixed) literals, to avoid checking the decision level of
+// literals during the procedure.
+
+void Internal::condition_unassign (int lit) {
+  LOG ("condition unassign %d", lit);
+  CADICAL_assert (val (lit) > 0);
+  set_val (lit, 0);
+}
+
+void Internal::condition_assign (int lit) {
+  LOG ("condition assign %d", lit);
+  CADICAL_assert (!val (lit));
+  set_val (lit, 1);
+}
+
+/*------------------------------------------------------------------------*/
+
+// The current partition into conditional part and autarky part during
+// refinement is represented through a conditional bit in 'marks'.
+
+inline bool Internal::is_conditional_literal (int lit) const {
+  return val (lit) > 0 && getbit (lit, 0);
+}
+
+inline bool Internal::is_autarky_literal (int lit) const {
+  return val (lit) > 0 && !getbit (lit, 0);
+}
+
+inline void Internal::mark_as_conditional_literal (int lit) {
+  LOG ("marking %d as conditional literal", lit);
+  CADICAL_assert (val (lit) > 0);
+  setbit (lit, 0);
+  CADICAL_assert (is_conditional_literal (lit));
+  CADICAL_assert (!is_autarky_literal (lit));
+}
+
+inline void Internal::unmark_as_conditional_literal (int lit) {
+  LOG ("unmarking %d as conditional literal", lit);
+  CADICAL_assert (is_conditional_literal (lit));
+  unsetbit (lit, 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+// 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.
+
+inline bool Internal::is_in_candidate_clause (int lit) const {
+  return marked67 (lit) > 0;
+}
+
+inline void Internal::mark_in_candidate_clause (int lit) {
+  LOG ("marking %d as literal of the candidate clause", lit);
+  mark67 (lit);
+  CADICAL_assert (is_in_candidate_clause (lit));
+  CADICAL_assert (!is_in_candidate_clause (-lit));
+}
+
+inline void Internal::unmark_in_candidate_clause (int lit) {
+  LOG ("unmarking %d as literal of the candidate clause", lit);
+  CADICAL_assert (is_in_candidate_clause (lit));
+  unmark67 (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+struct less_conditioned {
+  bool operator() (Clause *a, Clause *b) {
+    return !a->conditioned && b->conditioned;
+  }
+};
+
+// This is the function for eliminating globally blocked clauses.  It is
+// triggered during CDCL search according to 'conditioning' above and uses
+// the current assignment as basis to find globally blocked clauses.
+
+long Internal::condition_round (long delta) {
+
+  long limit;
+#ifndef CADICAL_QUIET
+  long props = 0;
+#endif
+  if (LONG_MAX - delta < stats.condprops)
+    limit = LONG_MAX;
+  else
+    limit = stats.condprops + delta;
+
+  size_t initial_trail_level = trail.size ();
+  int initial_level = level;
+
+  LOG ("initial trail level %zd", initial_trail_level);
+
+  protect_reasons ();
+
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+  int additionally_assigned = 0;
+#endif
+
+  for (auto idx : vars) {
+    const signed char tmp = val (idx);
+    Var &v = var (idx);
+    if (tmp) {
+      if (v.level) {
+        const int lit = tmp < 0 ? -idx : idx;
+        if (!active (idx)) {
+          LOG ("temporarily unassigning inactive literal %d", lit);
+          condition_unassign (lit);
+        }
+        if (frozen (idx)) {
+          LOG ("temporarily unassigning frozen literal %d", lit);
+          condition_unassign (lit);
+        }
+      }
+    } else if (frozen (idx)) {
+      LOG ("keeping frozen literal %d unassigned", idx);
+    } else if (!active (idx)) {
+      LOG ("keeping inactive literal %d unassigned", idx);
+    } else { // if (preprocessing) {
+      if (initial_level == level) {
+        level++;
+        LOG ("new condition decision level");
+      }
+      const int lit = decide_phase (idx, true);
+      condition_assign (lit);
+      v.level = level;
+      trail.push_back (lit);
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+      additionally_assigned++;
+#endif
+    }
+  }
+  LOG ("assigned %d additional literals", additionally_assigned);
+
+  // We compute statistics about the size of the assignments.
+  //
+  // The initial assignment consists of the non-root-level assigned literals
+  // split into a conditional and an autarky part.  The conditional part
+  // consists of literals assigned true and occurring negated in a clause
+  // (touch the clause), which does not contain another literal assigned to
+  // true.  This initial partition is the same for all refinements used in
+  // checking whether a candidate clause is globally blocked.
+  //
+  // For each candidate clause some of the conditional literals have to be
+  // unassigned, and the autarky is shrunken by turning some of the autarky
+  // literals into conditional literals (which might get unassigned in a
+  // later refinement though).
+  //
+  // The fix-point of this procedure produces a final assignment, which
+  // consists of the remaining assigned literals, again split into a
+  // conditional and an autarky part.
+  //
+  struct {
+    size_t assigned, conditional, autarky;
+  } initial, remain;
+
+  initial.assigned = 0;
+  for (auto idx : vars) {
+    const signed char tmp = val (idx);
+    if (!tmp)
+      continue;
+    if (!var (idx).level)
+      continue;
+    LOG ("initial assignment %ds", tmp < 0 ? -idx : idx);
+    initial.assigned++;
+  }
+
+  PHASE ("condition", stats.conditionings, "initial assignment of size %zd",
+         initial.assigned);
+
+  // For each candidate clause we refine the assignment (monotonically),
+  // by unassigning some conditional literals and turning some autarky
+  // literals into conditionals.
+  //
+  // As the conditional part is usually smaller than the autarky part our
+  // implementation only explicitly maintains the initial conditional part,
+  // with conditional bit set to true through 'mark_as_conditional_literal'.
+  // The autarky part consists of all literals assigned true which do not
+  // have their conditional bit set to true.  Since in both cases the
+  // literal has to be assigned true, we only need a single bit for both the
+  // literal as well as its negation (it does not have to be 'signed').
+  //
+  vector<int> conditional;
+
+  vector<Clause *> candidates; // Gather candidate clauses.
+#ifndef CADICAL_QUIET
+  size_t watched = 0; // Number of watched clauses.
+#endif
+
+  initial.autarky = initial.assigned; // Initially all are in autarky
+  initial.conditional = 0;            // and none in conditional part.
+
+  // Upper bound on the number of watched clauses. In principle one could
+  // use 'SIZE_MAX' but this is not available by default (yet).
+  //
+  const size_t size_max = clauses.size () + 1;
+
+  // Initialize additional occurrence lists.
+  //
+  init_occs ();
+
+  // Number of previously conditioned and unconditioned candidates.
+  //
+  size_t conditioned = 0, unconditioned = 0;
+
+  // Now go over all (non-garbage) irredundant clauses and check whether
+  // they are candidates, have to be watched, or whether they force the
+  // negation of some of their literals to be conditional initially.
+  //
+  for (const auto &c : clauses) {
+    if (c->garbage)
+      continue; // Can already be ignored.
+    if (c->redundant)
+      continue; // Ignore redundant clauses too.
+
+    // First determine the following numbers for the candidate clause
+    // (restricted to non-root-level assignments).
+    //
+    int positive = 0; // Number true literals.
+    int negative = 0; // Number false literals.
+    int watch = 0;    // True Literal to watch.
+    //
+    size_t minsize = size_max; // Number of occurrences of 'watch'.
+    //
+    // But also ignore root-level satisfied but not yet garbage clauses.
+    //
+    bool satisfied = false; // Root level satisfied.
+    //
+    for (const_literal_iterator l = c->begin ();
+         !satisfied && l != c->end (); l++) {
+      const int lit = *l;
+      const signed char tmp = val (lit);
+      if (tmp && !var (lit).level)
+        satisfied = (tmp > 0);
+      else if (tmp < 0)
+        negative++;
+      else if (tmp > 0) {
+        const size_t size = occs (lit).size ();
+        if (size < minsize)
+          watch = lit, minsize = size;
+        positive++;
+      }
+    }
+    if (satisfied) {    // Ignore root-level satisfied clauses.
+      mark_garbage (c); // But mark them as garbage already now.
+      continue;         // ... with next clause 'c'.
+    }
+
+    // Candidates are clauses with at least a positive literal in it.
+    //
+    if (positive > 0) {
+      LOG (c, "found %d positive literals in candidate", positive);
+      candidates.push_back (c);
+      if (c->conditioned)
+        conditioned++;
+      else
+        unconditioned++;
+    }
+
+    // Only one positive literal in each clauses with also at least one
+    // negative literal has to be watched in occurrence lists.  These
+    // watched clauses will be checked to contain only negative literals as
+    // soon such a positive literal is unassigned.  If this is the case
+    // these false literals have to be unassigned and potentially new
+    // conditional literals have to be determined.
+    //
+    // Note that only conditional literals are unassigned. However it does
+    // not matter that we might also watch autarky literals, because either
+    // such an autarky literal remains a witness that the clause is
+    // satisfied as long it remains an autarky literal. Otherwise at one
+    // point it becomes conditional and is unassigned, but then a
+    // replacement watch will be searched.
+    //
+    if (negative > 0 && positive > 0) {
+      LOG (c, "found %d negative literals in candidate", negative);
+      CADICAL_assert (watch);
+      CADICAL_assert (val (watch) > 0);
+      Occs &os = occs (watch);
+      CADICAL_assert (os.size () == minsize);
+      os.push_back (c);
+#ifndef CADICAL_QUIET
+      watched++;
+#endif
+      LOG (c, "watching %d with %zd occurrences in", watch, minsize);
+    }
+
+    // The initial global conditional part for the current assignment is
+    // extracted from clauses with only negative literals.  It is the same
+    // for all considered candidate clauses. These negative literals make up
+    // the global conditional part, are marked here.
+    //
+    if (negative > 0 && !positive) {
+
+      size_t new_conditionals = 0;
+
+      for (const_literal_iterator l = c->begin (); l != c->end (); l++) {
+        const int lit = *l;
+        signed char tmp = val (lit);
+        if (!tmp)
+          continue;
+        CADICAL_assert (tmp < 0);
+        if (!var (lit).level)
+          continue; // Not unassigned yet!
+        if (is_conditional_literal (-lit))
+          continue;
+        mark_as_conditional_literal (-lit);
+        conditional.push_back (-lit);
+        new_conditionals++;
+      }
+      if (new_conditionals > 0)
+        LOG (c, "marked %zu negations of literals as conditional in",
+             new_conditionals);
+
+      initial.conditional += new_conditionals;
+      CADICAL_assert (initial.autarky >= new_conditionals);
+      initial.autarky -= new_conditionals;
+    }
+
+  } // End of loop over all clauses to collect candidates etc.
+
+  PHASE ("condition", stats.conditionings, "found %zd candidate clauses",
+         candidates.size ());
+  PHASE ("condition", stats.conditionings,
+         "watching %zu literals and clauses", watched);
+  PHASE ("condition", stats.conditionings,
+         "initially %zd conditional literals %.0f%%", initial.conditional,
+         percent (initial.conditional, initial.assigned));
+  PHASE ("condition", stats.conditionings,
+         "initially %zd autarky literals %.0f%%", initial.autarky,
+         percent (initial.autarky, initial.assigned));
+#ifdef LOGGING
+  for (size_t i = 0; i < conditional.size (); i++) {
+    LOG ("initial conditional %d", conditional[i]);
+    CADICAL_assert (is_conditional_literal (conditional[i]));
+  }
+  for (size_t i = 0; i < trail.size (); i++)
+    if (is_autarky_literal (trail[i]))
+      LOG ("initial autarky %d", trail[i]);
+#endif
+  CADICAL_assert (initial.conditional == conditional.size ());
+  CADICAL_assert (initial.assigned == initial.conditional + initial.autarky);
+
+  stats.condassinit += initial.assigned;
+  stats.condcondinit += initial.conditional;
+  stats.condautinit += initial.autarky;
+  stats.condassvars += active ();
+
+  // To speed-up and particularly simplify the code we unassign all
+  // root-level variables temporarily, actually all inactive assigned
+  // variables.  This allows us to avoid tests on whether an assigned
+  // literal is actually root-level assigned and thus should be ignored (not
+  // considered to be assigned).  For this to work we have to ignore root
+  // level satisfied clauses as done above.  These are neither candidates
+  // nor have to be watched.  Remaining originally root-level assigned
+  // literals in clauses are only set to false.
+  //
+  for (const auto &lit : trail)
+    if (fixed (lit))
+      condition_unassign (lit);
+
+  // Stack to save temporarily unassigned (conditional) literals.
+  //
+  vector<int> unassigned;
+
+  // 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 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.
+  //
+  // TODO consider computing conditioned and unconditioned over all clauses.
+  //
+  CADICAL_assert (conditioned + unconditioned == candidates.size ());
+  if (conditioned && unconditioned) {
+    stable_sort (candidates.begin (), candidates.end (),
+                 less_conditioned ());
+    PHASE ("condition", stats.conditionings,
+           "focusing on %zd candidates %.0f%% not tried last time",
+           unconditioned, percent (unconditioned, candidates.size ()));
+  } else if (conditioned && !unconditioned) {
+    for (auto const &c : candidates) {
+      CADICAL_assert (c->conditioned);
+      c->conditioned = false; // Reset 'conditioned' bit.
+    }
+    PHASE ("condition", stats.conditionings,
+           "all %zd candidates tried before", conditioned);
+  } else {
+    CADICAL_assert (!conditioned);
+    PHASE ("condition", stats.conditionings, "all %zd candidates are fresh",
+           unconditioned);
+  }
+
+  // TODO prune assignments further!
+  // And thus might result in less watched clauses.
+  // So watching should be done here and not earlier.
+  // Also, see below, we might need to consider the negation of unassigned
+  // literals in candidate clauses as being watched.
+
+  // Now try to block all candidate clauses.
+  //
+  long blocked = 0; // Number of Successfully blocked clauses.
+  //
+#ifndef CADICAL_QUIET
+  size_t untried = candidates.size ();
+#endif
+  for (const auto &c : candidates) {
+
+    if (initial.autarky <= 0)
+      break;
+
+    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);
+      break;
+    }
+#ifndef CADICAL_QUIET
+    untried--;
+#endif
+    CADICAL_assert (!c->garbage);
+    CADICAL_assert (!c->redundant);
+
+    LOG (c, "candidate");
+    c->conditioned = 1; // Next time later.
+
+    // We watch an autarky literal in the clause, and can stop trying to
+    // globally block the clause as soon it turns into a conditional
+    // literal and we can not find another one.  If the fix-point assignment
+    // is reached and we still have an autarky literal left the watched one
+    // is reported as witness for this clause being globally blocked.
+    //
+    int watched_autarky_literal = 0;
+
+    // First mark all true literals in the candidate clause and find an
+    // 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++) {
+      const int lit = *l;
+      mark_in_candidate_clause (lit);
+      if (watched_autarky_literal)
+        continue;
+      if (!is_autarky_literal (lit))
+        continue;
+      watched_autarky_literal = lit;
+
+      // TODO assign non-assigned literals to false?
+      // Which might need to trigger watching additional clauses.
+    }
+
+    if (!watched_autarky_literal) {
+      LOG ("no initial autarky literal found");
+      for (const_literal_iterator l = c->begin (); l != c->end (); l++)
+        unmark_in_candidate_clause (*l);
+      continue;
+    }
+
+    stats.condcands++; // Only now ...
+
+    LOG ("watching first autarky literal %d", watched_autarky_literal);
+
+    // Save assignment sizes for statistics, logging and checking.
+    //
+    remain = initial;
+
+    // Position of next conditional and unassigned literal to process in the
+    // 'conditional' and the 'unassigned' stack.
+    //
+    struct {
+      size_t conditional, unassigned;
+    } next = {0, 0};
+
+    CADICAL_assert (unassigned.empty ());
+    CADICAL_assert (conditional.size () == initial.conditional);
+
+    while (watched_autarky_literal && stats.condprops < limit &&
+           next.conditional < conditional.size ()) {
+
+      CADICAL_assert (next.unassigned == unassigned.size ());
+
+      const int conditional_lit = conditional[next.conditional++];
+      LOG ("processing next conditional %d", conditional_lit);
+      CADICAL_assert (is_conditional_literal (conditional_lit));
+
+      if (is_in_candidate_clause (-conditional_lit)) {
+        LOG ("conditional %d negated in candidate clause", conditional_lit);
+        continue;
+      }
+
+      LOG ("conditional %d does not occur negated in candidate clause",
+           conditional_lit);
+
+      condition_unassign (conditional_lit);
+      CADICAL_assert (!is_conditional_literal (conditional_lit));
+      unassigned.push_back (conditional_lit);
+
+      CADICAL_assert (remain.assigned > 0);
+      CADICAL_assert (remain.conditional > 0);
+      remain.conditional--;
+      remain.assigned--;
+
+      while (watched_autarky_literal && stats.condprops < limit &&
+             next.unassigned < unassigned.size ()) {
+        const int unassigned_lit = unassigned[next.unassigned++];
+        LOG ("processing next unassigned %d", unassigned_lit);
+        CADICAL_assert (!val (unassigned_lit));
+#ifndef CADICAL_QUIET
+        props++;
+#endif
+        stats.condprops++;
+
+        Occs &os = occs (unassigned_lit);
+        if (os.empty ())
+          continue;
+
+        // Traverse all watched clauses of 'unassigned_lit' and find
+        // replacement watches or if none is found turn the negation of all
+        // false autarky literals in that clause into conditional literals.
+        // If one of those autarky literals is the watched autarky literal
+        // in the candidate clause, that one has to be updated too.
+        //
+        // We expect that this loop is a hot-spot for the procedure and thus
+        // are more careful about accessing end points for iterating.
+        //
+        auto i = os.begin (), j = i;
+        for (; watched_autarky_literal && j != os.end (); j++) {
+          Clause *d = *i++ = *j;
+
+          int replacement = 0; // New watched literal in 'd'.
+          int negative = 0;    // Negative autarky literals in 'd'.
+
+          for (const_literal_iterator l = d->begin (); l != d->end ();
+               l++) {
+            const int lit = *l;
+            const signed char tmp = val (lit);
+            if (tmp > 0)
+              replacement = lit;
+            if (tmp < 0 && is_autarky_literal (-lit))
+              negative++;
+          }
+
+          if (replacement) {
+            LOG ("found replacement %d for unassigned %d", replacement,
+                 unassigned_lit);
+            LOG (d, "unwatching %d in", unassigned_lit);
+            i--; // Drop watch!
+            LOG (d, "watching %d in", replacement);
+
+            CADICAL_assert (replacement != unassigned_lit);
+            occs (replacement).push_back (d);
+
+            continue; // ... with next watched clause 'd'.
+          }
+
+          LOG ("no replacement found for unassigned %d", unassigned_lit);
+
+          // Keep watching 'd' by 'unassigned_lit' if no replacement found.
+
+          if (!negative) {
+            LOG (d, "no negative autarky literals left in");
+            continue; // ... with next watched clause 'd'.
+          }
+
+          LOG (d, "found %d negative autarky literals in", negative);
+
+          for (const_literal_iterator l = d->begin ();
+               watched_autarky_literal && l != d->end (); l++) {
+            const int lit = *l;
+            if (!is_autarky_literal (-lit))
+              continue;
+            mark_as_conditional_literal (-lit);
+            conditional.push_back (-lit);
+
+            remain.conditional++;
+            CADICAL_assert (remain.autarky > 0);
+            remain.autarky--;
+
+            if (-lit != watched_autarky_literal)
+              continue;
+
+            LOG ("need to replace autarky literal %d in candidate", -lit);
+            replacement = 0;
+
+            // TODO save starting point because we only move it forward?
+
+            for (const_literal_iterator k = c->begin ();
+                 !replacement && k != c->end (); k++) {
+              const int other = *k;
+              if (is_autarky_literal (other))
+                replacement = other;
+            }
+            watched_autarky_literal = replacement;
+
+            if (replacement) {
+              LOG (c, "watching autarky %d instead %d in candidate",
+                   replacement, watched_autarky_literal);
+              watched_autarky_literal = replacement;
+            } else {
+              LOG ("failed to find an autarky replacement");
+              watched_autarky_literal = 0; // Breaks out of 4 loops!!!!!
+            }
+          } // End of loop of turning autarky literals into conditionals.
+        } // End of loop of all watched clauses of an unassigned literal.
+        //
+        // We might abort the occurrence traversal early but already
+        // removed some watches, thus have to just copy the rest.
+        //
+        if (i < j) {
+          while (j != os.end ())
+            *i++ = *j++;
+          LOG ("flushed %zd occurrences of %d", os.end () - i,
+               unassigned_lit);
+          os.resize (i - os.begin ());
+        }
+      } // End of loop which goes over all unprocessed unassigned literals.
+    } // End of loop which goes over all unprocessed conditional literals.
+
+    // We are still processing the candidate 'c' and now have reached a
+    // final fix-point assignment partitioned into a conditional and an
+    // autarky part, or during unassigned literals figured that there is no
+    // positive autarky literal left in 'c'.
+
+    LOG ("remaining assignment of size %zd", remain.assigned);
+    LOG ("remaining conditional part of size %zd", remain.conditional);
+    LOG ("remaining autarky part of size %zd", remain.autarky);
+    //
+    CADICAL_assert (remain.assigned - remain.conditional == remain.autarky);
+    //
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+    //
+    // This is a sanity check, that the size of our implicit representation
+    // of the autarky part matches our 'remain' counts.  We need the same
+    // code for determining autarky literals as in the loop below which adds
+    // autarky literals to the extension stack.
+    //
+    struct {
+      size_t assigned, conditional, autarky;
+    } check;
+    check.assigned = check.conditional = check.autarky = 0;
+    for (size_t i = 0; i < trail.size (); i++) {
+      const int lit = trail[i];
+      if (val (lit)) {
+        check.assigned++;
+        if (is_conditional_literal (lit)) {
+          LOG ("remaining conditional %d", lit);
+          CADICAL_assert (!is_autarky_literal (lit));
+          check.conditional++;
+        } else {
+          CADICAL_assert (is_autarky_literal (lit));
+          LOG ("remaining autarky %d", lit);
+          check.autarky++;
+        }
+      } else {
+        CADICAL_assert (!is_autarky_literal (lit));
+        CADICAL_assert (!is_conditional_literal (lit));
+      }
+    }
+    CADICAL_assert (remain.assigned == check.assigned);
+    CADICAL_assert (remain.conditional == check.conditional);
+    CADICAL_assert (remain.autarky == check.autarky);
+#endif
+
+    // Success if an autarky literal is left in the clause and
+    // we did not abort the loop too early because the propagation
+    // limit was hit.
+    //
+    if (watched_autarky_literal && stats.condprops < limit) {
+      CADICAL_assert (is_autarky_literal (watched_autarky_literal));
+      CADICAL_assert (is_in_candidate_clause (watched_autarky_literal));
+
+      blocked++;
+      stats.conditioned++;
+      LOG (c, "positive autarky literal %d globally blocks",
+           watched_autarky_literal);
+
+      LOG ("remaining %zd assigned literals %.0f%%", remain.assigned,
+           percent (remain.assigned, initial.assigned));
+      LOG ("remaining %zd conditional literals %.0f%%", remain.conditional,
+           percent (remain.conditional, remain.assigned));
+      LOG ("remaining %zd autarky literals %.0f%%", remain.autarky,
+           percent (remain.autarky, remain.assigned));
+
+      // A satisfying assignment of a formula after removing a globally
+      // blocked clause might not satisfy that clause.  As for variable
+      // elimination and classical blocked clauses, we thus maintain an
+      // extension stack for reconstructing an assignment which both
+      // satisfies the remaining formula as well as the clause.
+      //
+      // For globally blocked clauses we simply have to flip all literals in
+      // the autarky part and thus save the autarky on the extension stack
+      // in addition to the removed clause.  In the classical situation (in
+      // bounded variable elimination etc.) we simply save one literal on
+      // the extension stack.
+      //
+      // TODO find a way to shrink the autarky part or some other way to
+      // avoid pushing too many literals on the extension stack.
+      //
+      external->push_zero_on_extension_stack ();
+      for (const auto &lit : trail)
+        if (is_autarky_literal (lit))
+          external->push_witness_literal_on_extension_stack (lit);
+      if (proof)
+        proof->weaken_minus (c);
+      external->push_clause_on_extension_stack (c);
+
+      mark_garbage (c);
+
+      stats.condassrem += remain.assigned;
+      stats.condcondrem += remain.conditional;
+      stats.condautrem += remain.autarky;
+      stats.condassirem += initial.assigned;
+    }
+
+    // In this last part specific to one candidate clause, we have to get
+    // back to the initial assignment and reset conditionals.  First we
+    // assign all the unassigned literals (if necessary).
+    //
+    if (!unassigned.empty ()) {
+      LOG ("reassigning %zd literals", unassigned.size ());
+      while (!unassigned.empty ()) {
+        const int lit = unassigned.back ();
+        unassigned.pop_back ();
+        condition_assign (lit);
+      }
+    }
+
+    // Then we remove from the conditional stack autarky literals which
+    // became conditional and also reset their 'conditional' bit.
+    //
+    if (initial.conditional < conditional.size ()) {
+      LOG ("flushing %zd autarky literals from conditional stack",
+           conditional.size () - initial.conditional);
+      while (initial.conditional < conditional.size ()) {
+        const int lit = conditional.back ();
+        conditional.pop_back ();
+        unmark_as_conditional_literal (lit);
+      }
+    }
+
+    // Finally unmark all literals in the candidate clause.
+    //
+    for (const_literal_iterator l = c->begin (); l != c->end (); l++)
+      unmark_in_candidate_clause (*l);
+
+  } // End of loop over all candidate clauses.
+
+  PHASE ("condition", stats.conditionings,
+         "globally blocked %ld clauses %.0f%%", blocked,
+         percent (blocked, candidates.size ()));
+
+  // Unmark initial conditional variables.
+  //
+  for (const auto &lit : conditional)
+    unmark_as_conditional_literal (lit);
+
+  erase_vector (unassigned);
+  erase_vector (conditional);
+  erase_vector (candidates);
+
+  // Unassign additionally assigned literals.
+  //
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+  int additionally_unassigned = 0;
+#endif
+  while (trail.size () > initial_trail_level) {
+    int lit = trail.back ();
+    trail.pop_back ();
+    condition_unassign (lit);
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+    additionally_unassigned++;
+#endif
+  }
+  LOG ("unassigned %d additionally assigned literals",
+       additionally_unassigned);
+  CADICAL_assert (additionally_unassigned == additionally_assigned);
+
+  if (level > initial_level) {
+    LOG ("reset condition decision level");
+    level = initial_level;
+  }
+
+  reset_occs ();
+  delete_garbage_clauses ();
+
+  // Reassign previously assigned variables again.
+  //
+  LOG ("reassigning previously assigned variables");
+  for (size_t i = 0; i < initial_trail_level; i++) {
+    const int lit = trail[i];
+    const signed char tmp = val (lit);
+    CADICAL_assert (tmp >= 0);
+    if (!tmp)
+      condition_assign (lit);
+  }
+
+#ifndef CADICAL_NDEBUG
+  for (const auto &lit : trail)
+    CADICAL_assert (!marked (lit));
+#endif
+
+  unprotect_reasons ();
+
+  return blocked;
+}
+
+void Internal::condition (bool update_limits) {
+
+  if (unsat)
+    return;
+  if (!stats.current.irredundant)
+    return;
+
+  START_SIMPLIFIER (condition, CONDITION);
+  stats.conditionings++;
+
+  // Propagation limit to avoid too much work in 'condition'.  We mark
+  // tried candidate clauses after giving up, such that next time we run
+  // 'condition' we can try them.
+  //
+  long limit = stats.propagations.search;
+  limit *= opts.conditioneffort;
+  limit /= 1000;
+  if (limit < opts.conditionmineff)
+    limit = opts.conditionmineff;
+  if (limit > opts.conditionmaxeff)
+    limit = opts.conditionmaxeff;
+  CADICAL_assert (stats.current.irredundant);
+  limit *= 2.0 * active () / (double) stats.current.irredundant;
+  limit = max (limit, 2l * active ());
+
+  PHASE ("condition", stats.conditionings,
+         "started after %" PRIu64 " conflicts limited by %ld propagations",
+         stats.conflicts, limit);
+
+  long blocked = condition_round (limit);
+
+  STOP_SIMPLIFIER (condition, CONDITION);
+  report ('g', !blocked);
+
+  if (!update_limits)
+    return;
+
+  long delta = opts.conditionint * (stats.conditionings + 1);
+  lim.condition = stats.conflicts + delta;
+
+  PHASE ("condition", stats.conditionings,
+         "next limit at %" PRIu64 " after %ld conflicts", lim.condition,
+         delta);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_config.cpp b/src/sat/cadical/cadical_config.cpp
new file mode 100644
index 000000000..d4268790c
--- /dev/null
+++ b/src/sat/cadical/cadical_config.cpp
@@ -0,0 +1,107 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+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[] = {
+    {"elimeffort", 10},
+    {"stabilizeonly", 1},
+    {"subsumeeffort", 60},
+};
+
+static NameVal unsat_config[] = {
+    {"stabilize", 0},
+    {"walk", 0},
+};
+
+/*------------------------------------------------------------------------*/
+
+#define CONFIGS \
+\
+  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) {
+#define CONFIG(N, D) \
+  if (!strcmp (name, #N)) \
+    return true;
+  CONFIGS
+#undef CONFIG
+  return false;
+}
+
+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++) { \
+      CADICAL_assert (Options::has (P->name)); \
+      opts.set (P->name, P->val); \
+    } \
+    return true; \
+  } while (0);
+  CONFIGS
+#undef CONFIG
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Config::usage () {
+#define CONFIG(N, D) printf ("  %-14s " D "\n", "--" #N);
+  CONFIGS
+#undef CONFIG
+}
+
+/*------------------------------------------------------------------------*/
+
+const char **Config::begin () { return configs; }
+const char **Config::end () { return &configs[num_configs]; }
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_congruence.cpp b/src/sat/cadical/cadical_congruence.cpp
new file mode 100644
index 000000000..8fbceee24
--- /dev/null
+++ b/src/sat/cadical/cadical_congruence.cpp
@@ -0,0 +1,7567 @@
+#include "global.h"
+
+#include "congruence.hpp"
+#include "internal.hpp"
+#include <algorithm>
+#include <cstdint>
+#include <iterator>
+#include <utility>
+#include <vector>
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+Closure::Closure (Internal *i)
+    : internal (i), table (128, Hash (nonces))
+#ifdef LOGGING
+      ,
+      fresh_id (internal->clause_id)
+#endif
+{
+}
+
+char &Closure::lazy_propagated (int lit) {
+  return lazy_propagated_idx[internal->vidx (lit)];
+}
+
+void update_ite_flags (Gate *g) {
+  int8_t f = g->degenerated_ite;
+  const int lhs = g->lhs;
+  const int cond = g->rhs [0];
+  const int then_lit = g->rhs[1];
+  const int else_lit = g->rhs[2];
+
+  if (lhs == cond) {
+    f |= Special_ITE_GATE::NO_NEG_THEN;
+    f |= Special_ITE_GATE::NO_PLUS_ELSE;
+  }
+  if (lhs == -cond) {
+    f |= Special_ITE_GATE::NO_PLUS_THEN;
+    f |= Special_ITE_GATE::NO_NEG_ELSE;
+  }
+  if (lhs == then_lit) {
+    f |= Special_ITE_GATE::NO_PLUS_THEN;
+    f |= Special_ITE_GATE::NO_NEG_THEN;
+  }
+  if (lhs == else_lit) {
+    f |= Special_ITE_GATE::NO_PLUS_ELSE;
+    f |= Special_ITE_GATE::NO_NEG_ELSE;
+  }
+  g->degenerated_ite = f;
+  CADICAL_assert (lhs != -then_lit);
+  CADICAL_assert (lhs != -else_lit);
+  CADICAL_assert (cond != then_lit);
+  CADICAL_assert (cond != else_lit);
+  CADICAL_assert (cond != -then_lit);
+  CADICAL_assert (cond != -else_lit);
+}
+
+void check_correct_ite_flags (const Gate *const g) {
+#ifndef CADICAL_NDEBUG
+  const int8_t f = g->degenerated_ite;
+  const int lhs = g->lhs;
+  const int cond = g->rhs [0];
+  const int then_lit = g->rhs[1];
+  const int else_lit = g->rhs[2];
+  CADICAL_assert (g->pos_lhs_ids.size () == 4);
+  if (g->pos_lhs_ids[0].clause == nullptr)
+    CADICAL_assert ((f & Special_ITE_GATE::NO_PLUS_THEN));
+  if (g->pos_lhs_ids[1].clause == nullptr)
+    CADICAL_assert (f & Special_ITE_GATE::NO_NEG_THEN);
+  if (g->pos_lhs_ids[2].clause == nullptr)
+    CADICAL_assert (f & Special_ITE_GATE::NO_PLUS_ELSE);
+  if (g->pos_lhs_ids[3].clause == nullptr)
+    CADICAL_assert (f & Special_ITE_GATE::NO_NEG_ELSE);
+  if (lhs == cond) {
+    CADICAL_assert (f & Special_ITE_GATE::NO_NEG_THEN);
+    CADICAL_assert (f & Special_ITE_GATE::NO_PLUS_ELSE);
+  }
+  if (lhs == -cond) {
+    CADICAL_assert (f & Special_ITE_GATE::NO_PLUS_THEN);
+    CADICAL_assert (f & Special_ITE_GATE::NO_NEG_ELSE);
+  }
+  if (lhs == then_lit) {
+    CADICAL_assert (f & Special_ITE_GATE::NO_PLUS_THEN);
+    CADICAL_assert (f & Special_ITE_GATE::NO_NEG_THEN);
+  }
+  if (lhs == else_lit) {
+    CADICAL_assert (f & Special_ITE_GATE::NO_PLUS_ELSE);
+    CADICAL_assert (f & Special_ITE_GATE::NO_NEG_ELSE);
+  }
+  CADICAL_assert (lhs != -then_lit);
+  CADICAL_assert (lhs != -else_lit);
+  CADICAL_assert (cond != then_lit);
+  CADICAL_assert (cond != else_lit);
+  CADICAL_assert (cond != -then_lit);
+  CADICAL_assert (cond != -else_lit);
+#else
+  (void)g;
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+static size_t hash_lits (std::array<int, 16> &nonces,
+                         const vector<int> &lits) {
+  size_t hash = 0;
+  const auto end_nonces = end (nonces);
+  const auto begin_nonces = begin (nonces);
+  auto n = begin_nonces;
+  for (auto lit : lits) {
+    hash += lit;
+    hash *= *n++;
+    hash = (hash << 4) | (hash >> 60);
+    if (n == end_nonces)
+      n = begin_nonces;
+  }
+  hash ^= hash >> 32;
+  return hash;
+}
+
+size_t Hash::operator() (const Gate *const g) const {
+  CADICAL_assert (hash_lits (nonces, g->rhs) == g->hash);
+  return g->hash;
+}
+
+bool gate_contains (Gate *g, int lit) {
+  return find (begin (g->rhs), end (g->rhs), lit) != end (g->rhs);
+}
+/*------------------------------------------------------------------------*/
+struct compact_binary_rank {
+  typedef uint64_t Type;
+  uint64_t operator() (const CompactBinary &a) {
+    return ((uint64_t) a.lit1 << 32) + a.lit2;
+  };
+};
+
+struct compact_binary_order {
+  bool operator() (const CompactBinary &a, const CompactBinary &b) {
+    return compact_binary_rank () (a) < compact_binary_rank () (b);
+  };
+};
+
+bool Closure::find_binary (int lit, int other) const {
+  const auto offsize =
+      offsetsize[internal->vlit (lit)]; // in C++17: [offset, size] =
+  const auto offset = offsize.first;
+  const auto size = offsize.second;
+  const auto begin = std::begin (binaries) + offset;
+  const auto end = std::begin (binaries) + size;
+  CADICAL_assert (end <= std::end (binaries));
+  const CompactBinary target = CompactBinary (nullptr, 0, lit, other);
+  auto it = std::lower_bound (begin, end, target, compact_binary_order ());
+  // search_binary only returns a bool
+  bool found = (it != end && it->lit1 == lit && it->lit2 == other);
+  if (found) {
+    LOG ("found binary [%zd] %d %d", it->id, lit, other);
+    if (internal->lrat)
+      lrat_chain.push_back (it->id);
+  }
+  return found;
+}
+
+void Closure::extract_binaries () {
+  if (!internal->opts.congruencebinaries)
+    return;
+  START (extractbinaries);
+  offsetsize.resize (internal->max_var * 2 + 3, make_pair (0, 0));
+
+  // in kissat this is done during watch clearing. TODO: consider doing this
+  // too.
+  for (Clause *c : internal->clauses) {
+    if (c->garbage)
+      continue;
+    if (c->redundant && c->size != 2)
+      continue;
+    if (c->size > 2)
+      continue;
+    CADICAL_assert (c->size == 2);
+    const int lit = c->literals[0];
+    const int other = c->literals[1];
+    const bool already_sorted =
+        internal->vlit (lit) < internal->vlit (other);
+    binaries.push_back (CompactBinary (c, c->id,
+                                       already_sorted ? lit : other,
+                                       already_sorted ? other : lit));
+  }
+
+  MSORT (internal->opts.radixsortlim, begin (binaries), end (binaries),
+         compact_binary_rank (), compact_binary_order ());
+
+  {
+    const size_t size = binaries.size ();
+    size_t i = 0;
+    while (i < size) {
+      CompactBinary bin = binaries[i];
+      const int lit = bin.lit1;
+      size_t j = i;
+      while (j < size && binaries[j].lit1 == lit) {
+        ++j;
+      }
+      CADICAL_assert (j >= i);
+      CADICAL_assert (j <= size);
+      offsetsize[internal->vlit (lit)] = make_pair (i, j);
+      i = j;
+    }
+  }
+
+  size_t extracted = 0, already_present = 0, duplicated = 0;
+
+  const size_t size = internal->clauses.size ();
+  for (size_t i = 0; i < size; ++i) {
+    Clause *d = internal->clauses[i]; // binary clauses are appended, so
+                                      // reallocation possible
+    if (d->garbage)
+      continue;
+    if (d->redundant)
+      continue;
+    if (d->size != 3)
+      continue;
+    const int *lits = d->literals;
+    const int a = lits[0];
+    const int b = lits[1];
+    const int c = lits[2]; // obfuscating d->literals[2] which triggers an error in pedandic mode
+    if (internal->val (a))
+      continue;
+    if (internal->val (b))
+      continue;
+    if (internal->val (c))
+      continue;
+    int l = 0, k = 0;
+    if (find_binary (-a, b) || find_binary (-a, c)) {
+      l = b, k = c;
+    } else if (find_binary (-b, a) || find_binary (-b, c)) {
+      l = a, k = c;
+    } else if (find_binary (-c, a) || find_binary (-c, b)) {
+      l = a, k = b;
+    } else
+      continue;
+    LOG (d, "strengthening");
+    if (!find_binary (l, k)) {
+      if (internal->lrat)
+        lrat_chain.push_back (d->id);
+      add_binary_clause (l, k);
+      ++extracted;
+    } else {
+      ++already_present;
+      if (internal->lrat)
+        lrat_chain.clear ();
+    }
+  }
+  lrat_chain.clear ();
+
+  offsetsize.clear ();
+
+  // kissat has code to remove duplicates, which we have already removed
+  // before starting congruence
+  MSORT (internal->opts.radixsortlim, begin (binaries), end (binaries),
+         compact_binary_rank (), compact_binary_order ());
+  const size_t new_size = binaries.size ();
+  {
+    size_t i = 0;
+    for (size_t j = 1; j < new_size; ++j) {
+      CADICAL_assert (i < j);
+      if (binaries[i].lit1 == binaries[j].lit1 &&
+          binaries[i].lit2 == binaries[j].lit2) {
+        // subsuming later clause
+        subsume_clause (binaries[i].clause,
+                        binaries[j].clause); // the local one is specialized
+        ++duplicated;
+      } else {
+        binaries[++i] = binaries[j];
+      }
+    }
+    CADICAL_assert (i <= new_size);
+    binaries.resize (i);
+  }
+  binaries.clear ();
+  STOP (extractbinaries);
+  LOG ("extracted %zu binaries (plus %zu already present and %zu "
+       "duplicates)",
+       extracted, already_present, duplicated);
+}
+
+/*------------------------------------------------------------------------*/
+// marking structure for congruence closure, by reference
+signed char &Closure::marked (int lit) {
+  CADICAL_assert (internal->vlit (lit) < marks.size ());
+  return marks[internal->vlit (lit)];
+}
+
+void Closure::unmark_all () {
+  for (auto lit : internal->analyzed) {
+    CADICAL_assert (marked (lit));
+    marked (lit) = 0;
+  }
+  internal->analyzed.clear ();
+}
+
+void Closure::set_mu1_reason (int lit, Clause *c) {
+  CADICAL_assert (marked (lit) & 1);
+  LOG (c, "mu1 %d -> %zd", lit, c->id);
+  mu1_ids[internal->vlit (lit)] = LitClausePair (lit, c);
+}
+
+void Closure::set_mu2_reason (int lit, Clause *c) {
+  CADICAL_assert (marked (lit) & 2);
+  if (!internal->lrat)
+    return;
+  LOG (c, "mu2 %d -> %zd", lit, c->id);
+  mu2_ids[internal->vlit (lit)] = LitClausePair (lit, c);
+}
+
+void Closure::set_mu4_reason (int lit, Clause *c) {
+  CADICAL_assert (marked (lit) & 4);
+  if (!internal->lrat)
+    return;
+  LOG (c, "mu4 %d -> %zd", lit, c->id);
+  mu4_ids[internal->vlit (lit)] = LitClausePair (lit, c);
+}
+
+LitClausePair Closure::marked_mu1 (int lit) {
+  return mu1_ids[internal->vlit (lit)];
+}
+
+LitClausePair Closure::marked_mu2 (int lit) {
+  return mu2_ids[internal->vlit (lit)];
+}
+
+LitClausePair Closure::marked_mu4 (int lit) {
+  return mu4_ids[internal->vlit (lit)];
+}
+
+struct sort_literals_by_var_rank {
+  CaDiCaL::Internal *internal;
+  sort_literals_by_var_rank (Internal *i) : internal (i) {}
+
+  typedef uint64_t Type;
+
+  Type operator() (const int &a) const { return internal->vlit (a); }
+};
+struct sort_literals_by_var_rank_except {
+  CaDiCaL::Internal *internal;
+  int lhs;
+  int except;
+  sort_literals_by_var_rank_except (Internal *i, int my_lhs, int except2)
+      : internal (i), lhs (my_lhs), except (except2) {}
+  sort_literals_by_var_rank_except (Internal *i, int my_lhs)
+      : internal (i), lhs (my_lhs), except (0) {}
+  typedef uint64_t Type;
+  Type operator() (const int &a) const {
+    Type res = 0;
+    if (abs (a) == abs (except))
+      res = 1 - (a > 0);
+    else if (abs (a) == abs (lhs))
+      res = 3 - (a > 0);
+    else
+      res = internal->vlit (a) + 2; // probably +2 enough
+    return ~res;
+  }
+};
+
+struct sort_literals_by_var_smaller_except {
+  CaDiCaL::Internal *internal;
+  int lhs;
+  int except;
+  sort_literals_by_var_smaller_except (Internal *i, int my_lhs, int except2)
+      : internal (i), lhs (my_lhs), except (except2) {}
+  sort_literals_by_var_smaller_except (Internal *i, int my_lhs)
+      : internal (i), lhs (my_lhs), except (0) {}
+  bool operator() (const int &a, const int &b) const {
+    return sort_literals_by_var_rank_except (internal, lhs, except) (a) <
+           sort_literals_by_var_rank_except (internal, lhs, except) (b);
+    if (abs (a) == abs (except) && abs (b) != abs (except))
+      return false;
+    if (abs (a) != abs (except) && abs (b) == abs (except))
+      return true;
+    if (abs (a) == abs (lhs) && abs (b) != abs (lhs))
+      return false;
+    if (abs (a) != abs (lhs) && abs (b) == abs (lhs))
+      return true;
+    return sort_literals_by_var_rank (internal) (a) >
+           sort_literals_by_var_rank (internal) (b);
+  }
+};
+struct sort_literals_by_var_smaller {
+  CaDiCaL::Internal *internal;
+  sort_literals_by_var_smaller (Internal *i) : internal (i) {}
+  bool operator() (const int &a, const int &b) const {
+    return sort_literals_by_var_rank (internal) (a) <
+           sort_literals_by_var_rank (internal) (b);
+  }
+};
+
+void Closure::sort_literals_by_var_except (vector<int> &rhs, int lhs,
+                                           int except2) {
+  MSORT (internal->opts.radixsortlim, begin (rhs), end (rhs),
+         sort_literals_by_var_rank_except (internal, lhs, except2),
+         sort_literals_by_var_smaller_except (internal, lhs, except2));
+}
+void Closure::sort_literals_by_var (vector<int> &rhs) {
+  MSORT (internal->opts.radixsortlim, begin (rhs), end (rhs),
+         sort_literals_by_var_rank (internal),
+         sort_literals_by_var_smaller (internal));
+}
+/*------------------------------------------------------------------------*/
+int &Closure::representative (int lit) {
+  CADICAL_assert (internal->vlit (lit) < representant.size ());
+  return representant[internal->vlit (lit)];
+}
+int Closure::representative (int lit) const {
+  CADICAL_assert (internal->vlit (lit) < representant.size ());
+  return representant[internal->vlit (lit)];
+}
+
+int &Closure::eager_representative (int lit) {
+  CADICAL_assert (internal->vlit (lit) < eager_representant.size ());
+  return eager_representant[internal->vlit (lit)];
+}
+
+int Closure::eager_representative (int lit) const {
+  CADICAL_assert (internal->vlit (lit) < eager_representant.size ());
+  return eager_representant[internal->vlit (lit)];
+}
+
+int Closure::find_lrat_representative_with_marks (int lit) {
+  int res = lit;
+  int nxt = lit;
+  do {
+    res = nxt;
+    nxt = representative (nxt);
+    if (nxt != res) {
+      LOG ("%d has reason %" PRIu64, res, representative_id (res));
+      lrat_chain.push_back (representative_id (res));
+    }
+  } while (nxt != res || marked (nxt) || marked (-nxt));
+
+  return nxt;
+}
+int Closure::find_representative (int lit) {
+  int res = lit;
+  int nxt = lit;
+  do {
+    res = nxt;
+    nxt = representative (nxt);
+  } while (nxt != res);
+
+  return res;
+}
+
+int Closure::find_representative_and_compress (int lit, bool update_eager) {
+  LOG ("finding representative of %d", lit);
+  int res = lit;
+  int nxt = lit;
+  int path_length = 0;
+  do {
+    res = nxt;
+    nxt = representative (nxt);
+    ++path_length;
+    LOG ("updating %d -> %d", res, nxt);
+  } while (nxt != res);
+
+  if (path_length > 2) {
+    LOG ("learning new rewriting from %d to %d (current path length: %d)",
+         lit, res, path_length);
+    if (update_eager)
+      eager_representative (lit) = res;
+    if (internal->lrat) {
+      produce_representative_lrat (lit);
+      Clause *equiv = add_tmp_binary_clause (-lit, res);
+
+      if (equiv) {
+        representative_id (lit) = equiv->id;
+        if (update_eager)
+          eager_representative_id (lit) = equiv->id;
+      }
+    }
+    if (internal->lrat)
+      lrat_chain.clear ();
+  } else if (path_length == 2) {
+    if (update_eager) {
+      LOG ("updating information %d -> %d in eager", lit, res);
+      eager_representative (lit) = res;
+      if (internal->lrat)
+        eager_representative_id (lit) = representative_id (lit);
+      CADICAL_assert (!internal->lrat || eager_representative_id (lit));
+    }
+  }
+
+  if (lit != res) {
+    representative (lit) = res;
+  }
+  LOG ("representative of %d is %d", lit, res);
+  return res;
+}
+
+void Closure::push_lrat_unit (int lit) {
+  if (!internal->lrat)
+    return;
+  CADICAL_assert (internal->val (lit) > 0);
+  LRAT_ID id = internal->unit_id (lit);
+  lrat_chain.push_back (id);
+}
+
+int Closure::find_eager_representative (int lit) {
+  int res = lit;
+  int nxt = lit;
+  do {
+    res = nxt;
+    nxt = eager_representative (nxt);
+  } while (nxt != res);
+
+  return res;
+}
+
+int Closure::find_eager_representative_and_compress (int lit) {
+  if (!internal->lrat)
+    return find_representative (lit);
+  int res = lit;
+  int nxt = lit;
+  int path_length = 0;
+  do {
+    res = nxt;
+    nxt = eager_representative (nxt);
+    ++path_length;
+  } while (nxt != res);
+
+  //  CADICAL_assert (res == find_representative (lit));
+  // we have to do path compression to support LRAT proofs
+  if (path_length > 2) {
+    LOG ("learning new rewriting from %d to %d (current path length: %d)",
+         lit, res, path_length);
+    std::vector<LRAT_ID> tmp_lrat_chain;
+    if (internal->lrat) {
+      tmp_lrat_chain = std::move (lrat_chain);
+      lrat_chain.clear ();
+      produce_eager_representative_lrat (lit);
+    }
+    eager_representative (lit) = res;
+    Clause *equiv = add_tmp_binary_clause (-lit, res);
+    equiv->hyper = true;
+
+    if (internal->lrat && equiv) {
+      eager_representative_id (lit) = equiv->id;
+    }
+    if (internal->lrat) {
+      lrat_chain = std::move (tmp_lrat_chain);
+    }
+  } else if (path_length == 2) {
+    LOG ("duplicated information %d -> %d to eager with clause %" PRIu64,
+         lit, res, eager_representative_id (lit));
+    CADICAL_assert (eager_representative (lit) == res);
+    CADICAL_assert (!internal->lrat || eager_representative_id (lit));
+  }
+  CADICAL_assert (internal->clause.empty ());
+  return res;
+}
+
+void Closure::find_representative_and_compress_both (int lit) {
+  find_representative_and_compress (lit, false);
+  find_representative_and_compress (-lit, false);
+}
+
+void Closure::import_lazy_and_find_eager_representative_and_compress_both (
+    int lit) {
+  find_representative_and_compress (lit);
+  find_eager_representative_and_compress (lit);
+  find_representative_and_compress (-lit);
+  find_eager_representative_and_compress (-lit);
+}
+
+void Closure::produce_representative_lrat (int lit) {
+  CADICAL_assert (internal->lrat);
+  LOG ("production of LRAT chain for %d with representative %" PRIu64, lit,
+       representative_id (lit));
+  CADICAL_assert (internal->lrat);
+  CADICAL_assert (lrat_chain.empty ());
+  int res = lit;
+  int nxt = lit;
+  CADICAL_assert (nxt != representative (nxt));
+  do {
+    res = nxt;
+    nxt = representative (nxt);
+    if (nxt != res) {
+      LOG ("%d has reason %" PRIu64, res, representative_id (res));
+      lrat_chain.push_back (representative_id (res));
+    }
+  } while (nxt != res);
+}
+
+void Closure::produce_eager_representative_lrat (int lit) {
+  CADICAL_assert (internal->lrat);
+  LOG ("production of LRAT chain for %d with representative %" PRIu64, lit,
+       eager_representative_id (lit));
+  CADICAL_assert (internal->lrat);
+  CADICAL_assert (lrat_chain.empty ());
+  int res = lit;
+  int nxt = lit;
+  CADICAL_assert (nxt != eager_representative (nxt));
+  do {
+    res = nxt;
+    nxt = eager_representative (nxt);
+    if (nxt != res) {
+      LOG ("%d has reason %" PRIu64, res, eager_representative_id (res));
+      lrat_chain.push_back (eager_representative_id (res));
+    }
+  } while (nxt != res);
+}
+
+LRAT_ID Closure::find_representative_lrat (int lit) {
+  if (!internal->lrat)
+    return 0;
+  int res = lit;
+#ifndef CADICAL_NDEBUG
+  int nxt = representative (res);
+  CADICAL_assert (nxt == representative (res));
+#endif
+  LOG ("checking for existing LRAT chain for %d with clause %" PRIu64, lit,
+       eager_representative_id (res));
+  CADICAL_assert (representative_id (res));
+  return representative_id (res);
+}
+
+LRAT_ID Closure::find_eager_representative_lrat (int lit) {
+  if (!internal->lrat)
+    return 0;
+  int res = lit;
+#ifndef CADICAL_NDEBUG
+  int nxt = eager_representative (res);
+  CADICAL_assert (nxt == eager_representative (res));
+#endif
+  LOG ("checking for existing LRAT chain for %d with clause %" PRIu64, lit,
+       eager_representative_id (res));
+  CADICAL_assert (eager_representative_id (res));
+  return eager_representative_id (res);
+}
+
+LRAT_ID &Closure::eager_representative_id (int lit) {
+  CADICAL_assert (internal->vlit (lit) < eager_representant_id.size ());
+  return eager_representant_id[internal->vlit (lit)];
+}
+LRAT_ID Closure::eager_representative_id (int lit) const {
+  CADICAL_assert (internal->vlit (lit) < eager_representant_id.size ());
+  return eager_representant_id[internal->vlit (lit)];
+}
+
+LRAT_ID &Closure::representative_id (int lit) {
+  CADICAL_assert (internal->vlit (lit) < representant_id.size ());
+  return representant_id[internal->vlit (lit)];
+}
+LRAT_ID Closure::representative_id (int lit) const {
+  CADICAL_assert (internal->vlit (lit) < representant_id.size ());
+  return representant_id[internal->vlit (lit)];
+}
+
+void Closure::mark_garbage (Gate *g) {
+  LOG (g, "marking as garbage");
+  CADICAL_assert (!g->garbage);
+  g->garbage = true;
+  garbage.push_back (g);
+}
+
+bool Closure::remove_gate (GatesTable::iterator git) {
+  CADICAL_assert (git != end (table));
+  CADICAL_assert (!internal->unsat);
+  (*git)->indexed = false;
+  LOG ((*git), "removing from hash table");
+  table.erase (git);
+  return true;
+}
+
+bool Closure::remove_gate (Gate *g) {
+  if (!g->indexed)
+    return false;
+  CADICAL_assert (!internal->unsat);
+  CADICAL_assert (table.find (g) != end (table));
+  table.erase (table.find (g));
+  g->indexed = false;
+  LOG (g, "removing from hash table");
+  return true;
+}
+
+void Closure::index_gate (Gate *g) {
+  CADICAL_assert (!g->indexed);
+  CADICAL_assert (!internal->unsat);
+  CADICAL_assert (g->arity () > 1);
+  CADICAL_assert (g->hash == hash_lits (nonces, g->rhs));
+  LOG (g, "adding to hash table");
+  table.insert (g);
+  g->indexed = true;
+}
+
+void Closure::produce_rewritten_clause_lrat_and_clean (
+    std::vector<LitClausePair> &litIds, int except_lhs, bool remove_units) {
+  CADICAL_assert (internal->lrat_chain.empty ());
+  for (auto &litId : litIds) {
+    CADICAL_assert (litId.clause);
+    litId.clause = produce_rewritten_clause_lrat (litId.clause, except_lhs,
+                                                  remove_units);
+    litId.current_lit = find_eager_representative (litId.current_lit);
+  }
+  litIds.erase (
+      std::remove_if (begin (litIds), end (litIds),
+                      [] (const LitClausePair &p) { return !p.clause; }),
+      end (litIds));
+}
+
+void Closure::produce_rewritten_clause_lrat_and_clean (
+    std::vector<LitClausePair> &litIds, int except_lhs,
+    size_t &old_position1, size_t &old_position2, bool remove_units) {
+  CADICAL_assert (internal->lrat_chain.empty ());
+  CADICAL_assert (old_position1 != old_position2);
+  size_t j = 0;
+  for (size_t i = 0; i < litIds.size (); ++i) {
+    CADICAL_assert (j <= i);
+    litIds[j].clause = produce_rewritten_clause_lrat (
+        litIds[i].clause, except_lhs, remove_units);
+    litIds[j].current_lit =
+        find_eager_representative (litIds[i].current_lit);
+    if (i == old_position1) {
+      if (litIds[j].clause)
+        old_position1 = j;
+      else
+        old_position1 = -1;
+    }
+    if (i == old_position2) {
+      if (litIds[j].clause)
+        old_position2 = j;
+      else
+        old_position2 = -1;
+    }
+    if (litIds[j].clause)
+      ++j;
+  }
+  litIds.resize (j);
+}
+
+void Closure::compute_rewritten_clause_lrat_simple (Clause *c, int except) {
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (internal->lrat_chain.empty ());
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (lrat_chain.empty ());
+  bool changed = false;
+  bool tautology = false;
+  for (auto lit : *c) {
+    LOG ("checking if %d is required", lit);
+    if (internal->marked2 (lit)) {
+      continue;
+    }
+    if (internal->marked2 (-lit)) {
+      tautology = true;
+      break;
+    }
+    if (lit == except || lit == -except) {
+      internal->mark2 (lit);
+      clause.push_back (lit);
+      continue;
+    }
+    if (internal->val (lit) < 0) {
+#if 1
+      LOG ("found unit %d, removing it", -lit);
+      LRAT_ID id = internal->unit_id (-lit);
+      lrat_chain.push_back (id);
+      changed = true;
+      continue;
+#else
+      LOG ("found unit %d, but ignoring it", -lit);
+#endif
+    }
+    if (internal->val (lit) > 0) {
+      LOG ("found positive unit, so clause is subsumed by unit");
+      tautology = true;
+    }
+    const int other = find_eager_representative_and_compress (lit);
+    const bool marked = internal->marked2 (other);
+    const bool neg_marked = internal->marked2 (-other);
+    if (!marked)
+      internal->mark2 (other);
+    if (neg_marked) {
+      tautology = true;
+      LOG ("tautology due to %d -> %d", lit, other);
+    } else if (lit == other && marked) {
+      changed = true;
+      LOG ("%d -> %d already in", lit, other);
+    } else if (lit != other) {
+      if (!marked)
+        clause.push_back (other);
+      changed = true;
+      lrat_chain.push_back (eager_representative_id (lit));
+    } else if (!marked)
+      clause.push_back (lit);
+  }
+
+  for (auto lit : *c) {
+    internal->unmark (lit);
+  }
+
+  for (auto lit : clause) {
+    internal->unmark (lit);
+  }
+
+  lrat_chain.push_back (c->id);
+  if (tautology) {
+    LOG ("generated clause is a tautology");
+    lrat_chain.clear ();
+    clause.clear ();
+  } else if (changed && clause.size () == 1) {
+    LOG (lrat_chain, "LRAT chain");
+  } else {
+    LOG (c, "oops this should not happen");
+    CADICAL_assert (false);
+  }
+}
+
+Clause *Closure::new_tmp_clause (std::vector<int> &clause) {
+  CADICAL_assert (internal->lrat);
+  CADICAL_assert (!clause.empty ());
+  CADICAL_assert (!lrat_chain.empty ());
+  bool clear = false;
+
+  LOG (clause, "learn new tmp clause");
+  CADICAL_assert (clause.size () >= 2);
+  internal->external->check_learned_clause ();
+
+  CADICAL_assert (internal->clause.size () <= (size_t) INT_MAX);
+  const int size = (int) clause.size ();
+  CADICAL_assert (size >= 2);
+
+  size_t bytes = Clause::bytes (size);
+  Clause *c = (Clause *) new char[bytes];
+  DeferDeleteArray<char> clause_delete ((char *) c);
+
+  c->id = ++internal->clause_id;
+
+  c->conditioned = false;
+  c->covered = false;
+  c->enqueued = false;
+  c->frozen = false;
+  c->garbage = false;
+  c->gate = false;
+  c->hyper = false;
+  c->instantiated = false;
+  c->moved = false;
+  c->reason = false;
+  c->redundant = false;
+  c->transred = false;
+  c->subsume = false;
+  c->swept = false;
+  c->flushed = false;
+  c->vivified = false;
+  c->vivify = false;
+  c->used = 0;
+
+  c->glue = size;
+  c->size = size;
+  c->pos = 2;
+
+  for (int i = 0; i < size; i++)
+    c->literals[i] = clause[i];
+
+  // Just checking that we did not mess up our sophisticated memory layout.
+  // This might be compiler dependent though. Crucial for correctness.
+  //
+  CADICAL_assert (c->bytes () == bytes);
+
+  clause_delete.release ();
+  LOG (c, "new pointer %p", (void *) c);
+
+  if (clear)
+    clause.clear ();
+
+  if (internal->proof) {
+    internal->proof->add_derived_clause (c, lrat_chain);
+  }
+  extra_clauses.push_back (c);
+  CADICAL_assert (internal->lrat_chain.empty ());
+  return c;
+}
+
+Clause *Closure::new_clause () {
+  CADICAL_assert (internal->clause.empty () || clause.empty ());
+  bool clear = false;
+  if (internal->clause.empty ()) {
+    swap (internal->clause, clause);
+    clear = true;
+  }
+
+  Clause *c = internal->new_clause (false);
+
+  if (clear)
+    internal->clause.clear ();
+
+  if (internal->proof) {
+    internal->proof->add_derived_clause (c, lrat_chain);
+  }
+
+  return c;
+}
+
+// TODO we here duplicate the arguments of push_id_and_rewriting_lrat but we
+// probably do not need that.
+void Closure::produce_rewritten_clause_lrat (
+    std::vector<LitClausePair> &litIds, int except_lhs, bool remove_units) {
+  CADICAL_assert (internal->lrat_chain.empty ());
+  for (auto &litId : litIds) {
+    if (!litId.clause)
+      continue;
+    litId.clause = produce_rewritten_clause_lrat (litId.clause, except_lhs,
+                                                  remove_units);
+    litId.current_lit = find_eager_representative (litId.current_lit);
+  }
+}
+
+Clause *Closure::produce_rewritten_clause_lrat (Clause *c, int except_lhs,
+                                                bool remove_units, bool fail_on_unit) {
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (internal->lrat_chain.empty ());
+  auto tmp_lrat (std::move (lrat_chain));
+  lrat_chain.clear ();
+  LOG (c, "rewriting clause for LRAT proof, except for rewriting %d",
+       except_lhs);
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (lrat_chain.empty ());
+  bool changed = false;
+  bool tautology = false;
+  for (auto lit : *c) {
+    LOG ("checking if %d is required", lit);
+    if (internal->marked2 (lit)) {
+      continue;
+    }
+    if (internal->marked2 (-lit)) {
+      tautology = true;
+      break;
+    }
+    if (lit == except_lhs || lit == -except_lhs) {
+      internal->mark2 (lit);
+      clause.push_back (lit);
+      continue;
+    }
+    if (internal->val (lit) < 0) {
+      if (remove_units || lazy_propagated (lit)) {
+        LOG ("found unit %d, removing it", -lit);
+        LRAT_ID id = internal->unit_id (-lit);
+        lrat_chain.push_back (id);
+        changed = true;
+        continue;
+      } else
+        LOG ("found unit %d, but ignoring it", -lit);
+    }
+    if (internal->val (lit) > 0) {
+      LOG ("found positive unit %d, so clause is subsumed by unit", lit);
+      if (remove_units || lazy_propagated (lit))
+        tautology = true;
+    }
+    const int other = find_eager_representative_and_compress (lit);
+    const bool marked = internal->marked2 (other);
+    const bool neg_marked = internal->marked2 (-other);
+    if (!marked)
+      internal->mark2 (other);
+    if (neg_marked) {
+      tautology = true;
+      LOG ("tautology due to %d -> %d", lit, other);
+    } else if (lit == other && marked) {
+      changed = true;
+      LOG ("%d -> %d already in", lit, other);
+    } else if (lit != other) {
+      if (!marked)
+        clause.push_back (other);
+      changed = true;
+      lrat_chain.push_back (eager_representative_id (lit));
+    } else if (!marked)
+      clause.push_back (lit);
+  }
+
+  for (auto lit : *c) {
+    internal->unmark (lit);
+  }
+
+  for (auto lit : clause) {
+    internal->unmark (lit);
+  }
+
+  lrat_chain.push_back (c->id);
+  Clause *d;
+  CADICAL_assert (internal->clause.empty ());
+  if (tautology) {
+    LOG ("generated clause is a tautology");
+    d = nullptr;
+    lrat_chain.clear ();
+  } else if (changed && clause.size () == 1) {
+    LOG (lrat_chain, "LRAT chain");
+    if (fail_on_unit) {
+      d = nullptr;
+      CADICAL_assert (false && "rewriting produced a unit clause");
+    } else {
+      d = c;
+    }
+  } else if (changed) {
+    LOG (lrat_chain, "LRAT Chain");
+    d = new_tmp_clause (clause);
+    LOG (d, "rewritten clause to");
+  } else {
+    LOG (c, "clause is unchanged, so giving up");
+    lrat_chain.clear ();
+    d = c;
+  }
+  clause.clear ();
+  lrat_chain = std::move (tmp_lrat);
+  CADICAL_assert (internal->clause.empty ());
+  return d;
+}
+
+void Closure::push_id_on_chain (std::vector<LRAT_ID> &chain,
+                                Rewrite rewrite, int lit) {
+  LOG ("adding reason %zd for rewriting %d marked",
+       lit == rewrite.src ? rewrite.id1 : rewrite.id2, lit);
+  chain.push_back (lit == rewrite.src ? rewrite.id1 : rewrite.id2);
+}
+
+void Closure::push_id_and_rewriting_lrat_unit (Clause *c, Rewrite rewrite1,
+                                               std::vector<LRAT_ID> &chain,
+                                               bool insert_id_after,
+                                               Rewrite rewrite2,
+                                               int except_lhs,
+                                               int except_lhs2) {
+  LOG (c,
+       "computing normalized LRAT chain for clause to produce unit, "
+       "rewriting except for %d (%" PRIu64 ", %" PRIu64 ") and %d (%" PRIu64
+       ", %" PRIu64 ") and skipping %d and %d",
+       rewrite1.src, rewrite1.id1, rewrite1.id2, rewrite2.src, rewrite2.id1,
+       rewrite2.id2, except_lhs, except_lhs2);
+  CADICAL_assert (c);
+  std::vector<LRAT_ID> units, rewriting;
+  for (auto other : *c) {
+    // unclear how to achieve this in the simplify context where other ==
+    // g->lhs might be set CADICAL_assert (internal->val (other) <= 0 || other ==
+    // except);
+    if (other == except_lhs || other == -except_lhs) {
+      // do nothing;
+    } else if (other == except_lhs2 || other == -except_lhs2) {
+      // do nothing;
+    } else if (internal->val (other) < 0) {
+      LOG ("found unit %d", -other);
+      LRAT_ID id = internal->unit_id (-other);
+      units.push_back (id);
+    } else if (other == rewrite1.src && rewrite1.id1) {
+      push_id_on_chain (rewriting, rewrite1, other);
+    } else if (other == -rewrite1.src && rewrite1.id2) {
+      push_id_on_chain (rewriting, rewrite1, other);
+    } else if (other == rewrite2.src && rewrite2.id1) {
+      push_id_on_chain (rewriting, rewrite2, other);
+    } else if (other == -rewrite2.src && rewrite2.id2) {
+      push_id_on_chain (rewriting, rewrite2, other);
+    } else if (other != find_eager_representative_and_compress (other)) {
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+      const int rewritten_other = eager_representative (other);
+      CADICAL_assert (other != rewritten_other);
+      LOG ("reason for representative of %d %d is %" PRIu64 "", other,
+           rewritten_other, find_eager_representative_lrat (other));
+#endif
+      rewriting.push_back (find_eager_representative_lrat (other));
+    } else {
+      LOG ("no rewriting needed for %d", other);
+    }
+  }
+  for (auto id : units)
+    chain.push_back (id);
+
+  if (!insert_id_after)
+    chain.push_back (c->id);
+  for (auto id : rewriting)
+    chain.push_back (id);
+
+  if (insert_id_after)
+    chain.push_back (c->id);
+}
+
+// Note: it is important that the Rewrite takes over the normal rewriting,
+// because we can force rewriting that way that have not been done eagerly
+// yet.
+void Closure::push_id_and_rewriting_lrat_full (Clause *c, Rewrite rewrite1,
+                                               std::vector<LRAT_ID> &chain,
+                                               bool insert_id_after,
+                                               Rewrite rewrite2,
+                                               int except_lhs,
+                                               int except_lhs2) {
+  LOG (c,
+       "computing normalized LRAT chain for clause, rewriting except for "
+       "%d (%" PRIu64 ", %" PRIu64 ") and %d (%" PRIu64 ", %" PRIu64
+       ") and skipping %d and %d",
+       rewrite1.src, rewrite1.id1, rewrite1.id2, rewrite2.src, rewrite2.id1,
+       rewrite2.id2, except_lhs, except_lhs2);
+  CADICAL_assert (c);
+  if (!insert_id_after)
+    chain.push_back (c->id);
+  for (auto other : *c) {
+    // unclear how to achieve this in the simplify context where other ==
+    // g->lhs might be set CADICAL_assert (internal->val (other) <= 0 || other ==
+    // except);
+    if (other == except_lhs) {
+      // do nothing;
+    } else if (other == except_lhs2) {
+      // do nothing;
+    } else if (internal->val (other) < 0) {
+      LOG ("found unit %d", -other);
+      LRAT_ID id = internal->unit_id (-other);
+      CADICAL_assert (id);
+      chain.push_back (id);
+    } else if (other == rewrite1.src && rewrite1.id1) {
+      push_id_on_chain (chain, rewrite1, other);
+    } else if (other == -rewrite1.src && rewrite1.id2) {
+      push_id_on_chain (chain, rewrite1, other);
+    } else if (other == rewrite2.src && rewrite2.id1) {
+      push_id_on_chain (chain, rewrite2, other);
+    } else if (other == -rewrite2.src && rewrite2.id2) {
+      push_id_on_chain (chain, rewrite2, other);
+    } else {
+      CADICAL_assert (other == find_eager_representative (other));
+      LOG ("no rewriting needed for %d", other);
+    }
+  }
+  if (insert_id_after)
+    chain.push_back (c->id);
+}
+
+// Note: it is important that the Rewrite takes over the normal rewriting,
+// because we can force rewriting that way that have not been done eagerly
+// yet.
+void Closure::push_id_on_chain (std::vector<LRAT_ID> &chain, Clause *c) {
+  CADICAL_assert (c);
+  chain.push_back (c->id);
+  LOG (lrat_chain, "chain");
+}
+
+void Closure::push_id_on_chain (std::vector<LRAT_ID> &chain,
+                                const std::vector<LitClausePair> &reasons) {
+  for (auto litId : reasons) {
+    LOG (litId.clause, "found lrat in gate %d from %zd", litId.current_lit,
+         litId.clause->id);
+    push_id_on_chain (chain, litId.clause);
+  }
+  LOG (lrat_chain, "chain from %zd reasons", reasons.size ());
+}
+
+void Closure::learn_congruence_unit_when_lhs_set (Gate *g, int src,
+                                                  LRAT_ID id1, LRAT_ID id2,
+                                                  int dst) {
+  if (!internal->lrat)
+    return;
+  LOG ("calculating LRAT chain learn_congruence_unit_when_lhs_set");
+  CADICAL_assert (!g->pos_lhs_ids.empty ());
+  CADICAL_assert (internal->analyzed.empty ());
+  CADICAL_assert (internal->val (g->lhs) < 0);
+  switch (g->tag) {
+  case Gate_Type::And_Gate:
+    LOG (lrat_chain, "lrat");
+    LOG (lrat_chain, "lrat");
+    for (auto litId : g->neg_lhs_ids)
+      push_id_and_rewriting_lrat_unit (
+          litId.clause, Rewrite (src, dst, id1, id2), lrat_chain);
+    LOG (lrat_chain, "lrat");
+    break;
+  default:
+    CADICAL_assert (false);
+  }
+}
+
+// Something very important here: as we are producing a unit, we cannot
+// simplify or rewrite the clauses as this will produce units.
+void Closure::learn_congruence_unit_falsifies_lrat_chain (
+    Gate *g, int src, int dst, int clashing, int falsified, int unit) {
+  if (!internal->lrat)
+    return;
+  CADICAL_assert (!g->pos_lhs_ids.empty ());
+  CADICAL_assert (internal->analyzed.empty ());
+  CADICAL_assert (lrat_chain.empty ());
+  std::vector<LRAT_ID> proof_chain;
+  switch (g->tag) {
+  case Gate_Type::And_Gate:
+    if (clashing) {
+      LOG ("clashing %d where -lhs=%d", clashing, -g->lhs);
+      // Example: -2 = 1&3 and 3=2
+      // The proof consists in taking the binary clause of the clashing
+      // literal
+      if (clashing == -g->lhs) {
+        for (auto litId : g->pos_lhs_ids) {
+          LOG (litId.clause,
+               "found lrat in gate %d from %zd (looking for %d)",
+               litId.current_lit, litId.clause->id, falsified);
+          if (litId.current_lit == clashing) {
+            push_id_and_rewriting_lrat_unit (
+                litId.clause, Rewrite (), proof_chain, true, Rewrite (),
+                g->degenerated_and_neg || g->degenerated_and_pos ? 0 : -g->lhs);
+          }
+        }
+      } else {
+        // Example: 3 = (-1&2) and 2=1
+        // The proof consists in taking the binary clause with the rewrites
+        // Example where the rewrite must be before:
+        // 2: 3v2
+        // 9: -2v1
+        // 6: 3v1
+        // The chain cannot start by 9
+        if (g->degenerated_and_neg || g->degenerated_and_pos) {
+          LOG ("%d %d %d", src, dst, g->lhs);
+          if (src == g->lhs || dst == g->lhs) {
+            LOG ("degenerated AND gate with dst=lhs");
+            for (const auto &litId : g->pos_lhs_ids) {
+              LOG (litId.clause, "definition clause %d ->",
+                   litId.current_lit);
+              if (litId.current_lit == clashing) {
+                push_id_and_rewriting_lrat_unit (litId.clause, Rewrite (),
+                                                 proof_chain, true,
+                                                 Rewrite (), 0);
+                LOG (proof_chain, "produced lrat chain so far");
+              }
+            }
+	    CADICAL_assert (!proof_chain.empty ());
+          } else {
+            LOG ("degenerated AND gate with conflict without LHS");
+            for (const auto &litId : g->pos_lhs_ids) {
+              LOG (litId.clause, "definition clause %d ->",
+                   litId.current_lit);
+              push_id_and_rewriting_lrat_unit (litId.clause, Rewrite (),
+                                               proof_chain, false,
+                                               Rewrite (), -g->lhs);
+              LOG (proof_chain, "produced lrat chain so far");
+            }
+          }
+        } else {
+          LOG ("normal AND gate");
+          for (const auto &litId : g->pos_lhs_ids) {
+            push_id_and_rewriting_lrat_unit (litId.clause, Rewrite (),
+                                             proof_chain, false, Rewrite (),
+                                             g->degenerated_and_neg || g->degenerated_and_pos ? 0 : -g->lhs);
+            LOG (proof_chain, "produced lrat chain so far");
+          }
+        }
+      }
+      LOG (proof_chain, "produced lrat chain");
+    } else if (falsified) {
+      LOG ("falsifies %d", falsified);
+      // Example is 3=(1&2) with 2=false or 3=(1&4) with 4=2 and 2=false
+      // (can happen when the unit was derived in the middle of the
+      // rewriting)
+      for (auto litId : g->pos_lhs_ids) {
+        LOG (litId.clause,
+             "found lrat in gate %d from %zd (looking for %d)",
+             litId.current_lit, litId.clause->id, falsified);
+        if (litId.current_lit == falsified ||
+            (litId.current_lit == src && dst == falsified)) {
+          push_id_and_rewriting_lrat_unit (litId.clause, Rewrite (),
+                                           proof_chain, true, Rewrite (),
+                                           -dst, -g->lhs);
+        }
+      }
+    } else {
+      CADICAL_assert (unit);
+      // Example is 1 = 2&3 where 2 and 3 are false
+      for (auto litId : g->neg_lhs_ids) {
+        push_id_and_rewriting_lrat_unit (litId.clause, Rewrite (),
+                                         proof_chain);
+      }
+      LOG (proof_chain, "produced lrat chain");
+      break;
+    }
+    lrat_chain = std::move (proof_chain);
+    break;
+  default:
+    CADICAL_assert (false);
+  }
+  (void) unit;
+}
+
+bool Closure::fully_propagate () {
+  if (internal->unsat)
+    return false;
+  LOG ("fully propagating");
+  CADICAL_assert (internal->watching ());
+  CADICAL_assert (full_watching);
+  bool no_conflict = internal->propagate ();
+
+  if (no_conflict)
+    return true;
+  internal->learn_empty_clause ();
+  if (internal->lrat)
+    lrat_chain.clear ();
+
+  return false;
+}
+bool Closure::learn_congruence_unit (int lit, bool delay_propagation, bool force_propagation) {
+  if (internal->unsat)
+    return false;
+  const signed char val_lit = internal->val (lit);
+  if (val_lit > 0) {
+    LOG ("already set lit %d", lit);
+    if (internal->lrat)
+      lrat_chain.clear ();
+    if (force_propagation)
+      return fully_propagate();
+    return true;
+  }
+  LOG ("adding unit %s", LOGLIT (lit));
+  ++internal->stats.congruence.units;
+  CADICAL_assert (!internal->lrat || !lrat_chain.empty ());
+  if (val_lit < 0) {
+    if (internal->lrat) {
+      CADICAL_assert (internal->lrat_chain.empty ());
+      LRAT_ID id = internal->unit_id (-lit);
+      internal->lrat_chain.push_back (id);
+      for (auto id : lrat_chain)
+        internal->lrat_chain.push_back (id);
+      lrat_chain.clear ();
+    }
+    internal->learn_empty_clause ();
+    return false;
+  }
+
+  LOG (lrat_chain, "assigning due to LRAT chain");
+  swap (lrat_chain, internal->lrat_chain);
+  internal->assign_unit (lit);
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (internal->lrat_chain.empty ());
+  if (delay_propagation)
+    return false;
+  else return fully_propagate ();
+}
+
+// for merging the literals there are many cases
+// TODO: LRAT does not work if the LHS is not in normal form and if the
+// representative is also in the gate.
+bool Closure::merge_literals_lrat (
+    Gate *g, Gate *h, int lit, int other,
+    const std::vector<LRAT_ID> &extra_reasons_lit,
+    const std::vector<LRAT_ID> &extra_reasons_ulit) {
+  CADICAL_assert (!internal->unsat);
+  CADICAL_assert (g->lhs == lit);
+  CADICAL_assert (g == h || h->lhs == other);
+  (void) g, (void) h;
+  LOG ("merging literals %s and %s", LOGLIT(lit), LOGLIT(other));
+  // TODO: this should not update_eager but still calculate the LRAT chain
+  // below!
+  const int repr_lit = find_representative_and_compress (lit, false);
+  const int repr_other = find_representative_and_compress (other, false);
+  find_representative_and_compress (-lit, false);
+  find_representative_and_compress (-other, false);
+  LOG ("merging literals %d [=%d] and %d [=%d]", lit, repr_lit, other,
+       repr_other);
+
+  if (repr_lit == repr_other) {
+    LOG ("already merged %d and %d", lit, other);
+    if (internal->lrat)
+      lrat_chain.clear ();
+    return false;
+  }
+
+  const int val_lit = internal->val (lit);
+  const int val_other = internal->val (other);
+  if (val_lit) {
+    if (val_lit == val_other) {
+      LOG ("not merging lits %d and %d assigned to same value", lit, other);
+      if (internal->lrat)
+        lrat_chain.clear ();
+      return false;
+    }
+  }
+
+  // For LRAT we need to distinguish more cases for a more regular
+  // reconstruction.
+  //
+  // 1. if lit = -other, then we learn lit and -lit to derive false
+  //
+  // 2. otherwise, we learn the new clauses lit = -other (which are two real
+  // clauses).
+  //
+  //    2a. if repr_lit = -repr_other, we learn the units repr_lit and
+  //    -repr_lit to derive false
+  //
+  //    2b. otherwise, we learn the equivalences repr_lit = -repr_other
+  //    (which are two real clauses)
+  //
+  // Without LRAT this is easier, as we directly learn the conclusion
+  // (either false or the equivalence). The steps can also not be merged
+  // because repr_lit can appear in the gate and hence in the resolution
+  // chain.
+  int smaller_repr = repr_lit;
+  int larger_repr = repr_other;
+  int smaller = lit;
+  int larger = other;
+  const std::vector<LRAT_ID> *smaller_chain = &extra_reasons_ulit;
+  const std::vector<LRAT_ID> *larger_chain = &extra_reasons_lit;
+
+  if (abs (smaller_repr) > abs (larger_repr)) {
+    swap (smaller_repr, larger_repr);
+    swap (smaller, larger);
+    swap (smaller_chain, larger_chain);
+  }
+
+  CADICAL_assert (find_representative (smaller_repr) == smaller_repr);
+  CADICAL_assert (find_representative (larger_repr) == larger_repr);
+  if (lit == -other) {
+    CADICAL_assert (chain.empty ());
+    LOG ("merging clashing %d and %d", lit, other);
+    if (internal->proof) {
+      if (internal->lrat) {
+        for (auto id : *smaller_chain)
+          lrat_chain.push_back (id);
+      }
+      unsimplified.push_back (smaller);
+      LRAT_ID id = simplify_and_add_to_proof_chain (unsimplified);
+
+      if (internal->lrat) {
+        internal->lrat_chain.push_back (id);
+        for (auto id : *larger_chain)
+          internal->lrat_chain.push_back (id);
+        LOG (internal->lrat_chain, "lrat chain");
+      }
+    }
+    internal->learn_empty_clause ();
+    delete_proof_chain ();
+    return false;
+  }
+
+  LOG ("merging %d and %d first and then the equivalences of %d and %d "
+       "with LRAT",
+       lit, other, repr_lit, repr_other);
+  Clause *eq1_tmp = nullptr;
+  if (internal->lrat) {
+    lrat_chain = *smaller_chain;
+    eq1_tmp = add_tmp_binary_clause (-larger, smaller);
+  }
+  CADICAL_assert (!internal->lrat || eq1_tmp);
+
+  Clause *eq2_tmp = nullptr;
+  if (internal->lrat) {
+    lrat_chain = *larger_chain;
+    LOG (lrat_chain, "lrat chain");
+
+    eq2_tmp = add_tmp_binary_clause (larger, -smaller);
+    // the order in the clause is important for the
+    // repr_lit == -repr_other to get the right chain
+  }
+  CADICAL_assert (!internal->lrat || eq2_tmp);
+  if (internal->lrat)
+    lrat_chain.clear ();
+
+  if (repr_lit == -repr_other) {
+    // now derive empty clause
+    Rewrite rew1, rew2;
+    if (internal->lrat) {
+      // no need to calculate push_id_and_rewriting_lrat here because all
+      // the job is done by the arguments already
+      rew1 = Rewrite (lit == repr_lit ? 0 : lit, repr_lit,
+                      lit == repr_lit ? 0 : representative_id (lit),
+                      lit == repr_lit ? 0 : representative_id (-lit));
+      rew2 = Rewrite (other == repr_other ? 0 : other, repr_other,
+                      other == repr_other ? 0 : representative_id (other),
+                      other == repr_other ? 0 : representative_id (-other));
+      push_id_and_rewriting_lrat_unit (eq1_tmp, rew1, lrat_chain, true,
+                                       rew2);
+      swap (lrat_chain, internal->lrat_chain);
+    }
+    internal->assign_unit (-larger_repr);
+    if (internal->lrat) {
+      internal->lrat_chain.clear ();
+
+      if (larger != larger_repr)
+        push_lrat_unit (-larger_repr);
+      push_id_and_rewriting_lrat_unit (
+          eq2_tmp, rew1, lrat_chain, true, rew2,
+          larger != larger_repr ? larger_repr : 0);
+      LOG (lrat_chain, "lrat chain");
+      swap (lrat_chain, internal->lrat_chain);
+    }
+    internal->learn_empty_clause ();
+    if (internal->lrat)
+      internal->lrat_chain.clear ();
+    return false;
+  }
+
+  if (val_lit) {
+    if (val_lit == val_other) {
+      LOG ("not merging lits %d and %d assigned to same value", lit, other);
+      if (internal->lrat)
+        lrat_chain.clear ();
+      return false;
+    }
+    if (val_lit == -val_other) {
+      LOG ("merging lits %d and %d assigned to inconsistent value", lit,
+           other);
+      CADICAL_assert (lrat_chain.empty ());
+      if (internal->lrat) {
+        Clause *c = val_lit ? eq2_tmp : eq1_tmp;
+        int pos = val_lit ? other : lit;
+        int neg = val_lit ? -lit : -other;
+        push_lrat_unit (pos);
+        push_lrat_unit (neg);
+        push_id_on_chain (lrat_chain, c);
+      }
+      internal->learn_empty_clause ();
+      if (internal->lrat)
+        lrat_chain.clear ();
+      return false;
+    }
+
+    CADICAL_assert (!val_other);
+    LOG ("merging assigned %d and unassigned %d", lit, other);
+    CADICAL_assert (lrat_chain.empty ());
+    const int unit = (val_lit < 0) ? -other : other;
+    if (internal->lrat) {
+      Clause *c;
+      if (lit == smaller) {
+        if (val_lit < 0)
+          c = eq1_tmp;
+        else
+          c = eq2_tmp;
+      } else {
+        if (val_lit < 0)
+          c = eq2_tmp;
+        else
+          c = eq1_tmp;
+      }
+      push_id_and_rewriting_lrat_unit (c, Rewrite (), lrat_chain, true,
+                                       Rewrite (), unit);
+    }
+    learn_congruence_unit (unit);
+    if (internal->lrat)
+      lrat_chain.clear ();
+    return false;
+  }
+
+  if (!val_lit && val_other) {
+    LOG ("merging assigned %d and unassigned %d", lit, other);
+    CADICAL_assert (lrat_chain.empty ());
+    const int unit = (val_other < 0) ? -lit : lit;
+    if (internal->lrat) {
+      Clause *c;
+      if (lit == smaller) {
+        if (val_lit < 0)
+          c = eq1_tmp;
+        else
+          c = eq2_tmp;
+      } else {
+        if (val_lit < 0)
+          c = eq2_tmp;
+        else
+          c = eq1_tmp;
+      }
+      push_id_and_rewriting_lrat_unit (c, Rewrite (), lrat_chain, true,
+                                       Rewrite (), lit, unit);
+    }
+    learn_congruence_unit (unit);
+    if (internal->lrat)
+      lrat_chain.clear ();
+    return false;
+  }
+
+  Clause *eq1_repr, *eq2_repr;
+  if (smaller_repr != smaller || larger != larger_repr) {
+    if (internal->lrat) {
+      lrat_chain.clear ();
+      Rewrite rew1 = Rewrite (
+          smaller_repr != smaller ? smaller : 0,
+          smaller_repr != smaller ? smaller_repr : 0,
+          smaller_repr != smaller ? representative_id (smaller) : 0,
+          smaller_repr != smaller ? representative_id (-smaller) : 0);
+      Rewrite rew2 =
+          Rewrite (larger_repr != larger ? larger : 0,
+                   larger_repr != larger ? larger_repr : 0,
+                   larger_repr != larger ? representative_id (larger) : 0,
+                   larger_repr != larger ? representative_id (-larger) : 0);
+      push_id_and_rewriting_lrat_full (eq1_tmp, rew1, lrat_chain, true,
+                                       rew2);
+    }
+    eq1_repr = learn_binary_tmp_or_full_clause (-larger_repr, smaller_repr);
+  } else {
+    if (internal->lrat)
+      eq1_repr = maybe_promote_tmp_binary_clause (eq1_tmp);
+    else
+      eq1_repr = maybe_add_binary_clause (-larger_repr, smaller_repr);
+  }
+
+  if (internal->lrat) {
+    lrat_chain.clear ();
+  }
+
+  if (smaller_repr != smaller || larger != larger_repr) {
+
+    if (internal->lrat) {
+      lrat_chain.clear ();
+      // eq2 = larger, -smaller
+      Rewrite rew1 = Rewrite (
+          smaller_repr != smaller ? smaller : 0,
+          smaller_repr != smaller ? smaller_repr : 0,
+          smaller_repr != smaller ? representative_id (smaller) : 0,
+          smaller_repr != smaller ? representative_id (-smaller) : 0);
+      Rewrite rew2 =
+          Rewrite (larger_repr != larger ? larger : 0,
+                   larger_repr != larger ? larger_repr : 0,
+                   larger_repr != larger ? representative_id (larger) : 0,
+                   larger_repr != larger ? representative_id (-larger) : 0);
+      push_id_and_rewriting_lrat_full (eq2_tmp, rew1, lrat_chain, true,
+                                       rew2);
+    }
+
+    eq2_repr = learn_binary_tmp_or_full_clause (larger_repr, -smaller_repr);
+
+  } else {
+    if (internal->lrat)
+      eq2_repr = maybe_promote_tmp_binary_clause (eq2_tmp);
+    else
+      eq2_repr = maybe_add_binary_clause (larger_repr, -smaller_repr);
+  }
+  lrat_chain.clear ();
+
+  if (internal->lrat) {
+    representative_id (larger_repr) = eq1_repr->id;
+    CADICAL_assert (std::find (begin (*eq1_repr), end (*eq1_repr), -larger_repr) !=
+            end (*eq1_repr));
+    representative_id (-larger_repr) = eq2_repr->id;
+    CADICAL_assert (std::find (begin (*eq2_repr), end (*eq2_repr), larger_repr) !=
+            end (*eq2_repr));
+  }
+  LOG ("updating %d -> %d", larger_repr, smaller_repr);
+  representative (larger_repr) = smaller_repr;
+  representative (-larger_repr) = -smaller_repr;
+  schedule_literal (larger_repr);
+  ++internal->stats.congruence.congruent;
+  CADICAL_assert (lrat_chain.empty ());
+  return true;
+}
+
+// Variant when there are no gates
+// TODO: this is exactly the same as the other function without the gates.
+// Kill the arguments!
+bool Closure::merge_literals_lrat (
+    int lit, int other, const std::vector<LRAT_ID> &extra_reasons_lit,
+    const std::vector<LRAT_ID> &extra_reasons_ulit) {
+  CADICAL_assert (!internal->unsat);
+  LOG ("merging literals %s and %s", LOGLIT (lit), LOGLIT (other));
+  // TODO: this should not update_eager but still calculate the LRAT chain
+  // below!
+  const int repr_lit = find_representative_and_compress (lit, false);
+  const int repr_other = find_representative_and_compress (other, false);
+  find_representative_and_compress (-lit, false);
+  find_representative_and_compress (-other, false);
+  LOG ("merging literals %s [=%d] and %s [=%d]", LOGLIT (lit), repr_lit,
+       LOGLIT (other), repr_other);
+  LOG (lrat_chain, "lrat chain beginning of merge");
+
+  if (repr_lit == repr_other) {
+    LOG ("already merged %s and %s", LOGLIT (lit), LOGLIT (other));
+    if (internal->lrat)
+      lrat_chain.clear ();
+    return false;
+  }
+
+  const int val_lit = internal->val (lit);
+  const int val_other = internal->val (other);
+
+  // For LRAT we need to distinguish more cases for a more regular
+  // reconstruction.
+  //
+  // 1. if lit = -other, then we learn lit and -lit to derive false
+  //
+  // 2. otherwise, we learn the new clauses lit = -other (which are two real
+  // clauses).
+  //
+  //    2a. if repr_lit = -repr_other, we learn the units repr_lit and
+  //    -repr_lit to derive false
+  //
+  //    2b. otherwise, we learn the equivalences repr_lit = -repr_other
+  //    (which are two real clauses)
+  //
+  // Without LRAT this is easier, as we directly learn the conclusion
+  // (either false or the equivalence). The steps can also not be merged
+  // because repr_lit can appear in the gate and hence in the resolution
+  // chain.
+  int smaller_repr = repr_lit;
+  int larger_repr = repr_other;
+  int val_smaller = val_lit;
+  int val_larger = val_other;
+  int smaller = lit;
+  int larger = other;
+  const std::vector<LRAT_ID> *smaller_chain = &extra_reasons_ulit;
+  const std::vector<LRAT_ID> *larger_chain = &extra_reasons_lit;
+
+  if (abs (smaller_repr) > abs (larger_repr)) {
+    swap (smaller_repr, larger_repr);
+    swap (smaller, larger);
+    swap (smaller_chain, larger_chain);
+    swap (val_smaller, val_larger);
+  }
+
+  CADICAL_assert (find_representative (smaller_repr) == smaller_repr);
+  CADICAL_assert (find_representative (larger_repr) == larger_repr);
+  if (lit == -other) {
+    LOG ("merging clashing %d and %d", lit, other);
+    if (!val_smaller) {
+      if (internal->lrat)
+        internal->lrat_chain = *smaller_chain;
+      internal->assign_unit (smaller);
+      if (internal->lrat)
+        internal->lrat_chain.clear ();
+
+      push_lrat_unit (smaller);
+      if (internal->lrat) {
+        CADICAL_assert (internal->lrat_chain.empty ());
+        swap (internal->lrat_chain, lrat_chain);
+        for (auto id : *larger_chain)
+          internal->lrat_chain.push_back (id);
+        LOG (internal->lrat_chain, "lrat chain");
+      }
+      internal->learn_empty_clause ();
+      return false;
+    } else {
+      if (internal->lrat)
+        internal->lrat_chain =
+            (val_smaller < 0 ? *smaller_chain : *larger_chain);
+      if (internal->lrat)
+        internal->lrat_chain.push_back (
+            internal->unit_id (val_smaller > 0 ? smaller : -smaller));
+      internal->learn_empty_clause ();
+      return false;
+    }
+  }
+
+  if (val_lit && val_lit == val_other) {
+    LOG ("not merging lits %d and %d assigned to same value", lit, other);
+    return false;
+  }
+
+  if (val_lit && val_lit == -val_other) {
+    if (internal->lrat) {
+      internal->lrat_chain.push_back (
+          internal->unit_id (val_smaller < 0 ? -smaller : smaller));
+      internal->lrat_chain.push_back (
+				      internal->unit_id (val_larger < 0 ? -larger : larger));
+      for (auto id : (val_smaller < 0 ? *smaller_chain : *larger_chain)) {
+	internal->lrat_chain.push_back(id);
+      }
+    }
+    internal->learn_empty_clause ();
+    return false;
+  }
+
+  LOG ("merging %d and %d first and then the equivalences of %d and %d "
+       "with LRAT",
+       lit, other, repr_lit, repr_other);
+  Clause *eq1_tmp = nullptr;
+  if (internal->lrat) {
+    lrat_chain = *smaller_chain;
+    eq1_tmp = add_tmp_binary_clause (-larger, smaller);
+    CADICAL_assert (eq1_tmp);
+  }
+  CADICAL_assert (!internal->lrat || eq1_tmp);
+
+  Clause *eq2_tmp = nullptr;
+  if (internal->lrat) {
+    lrat_chain = *larger_chain;
+    LOG (lrat_chain, "lrat chain");
+    // the order in the clause is important for the
+    // repr_lit == -repr_other to get the right chain
+    eq2_tmp = add_tmp_binary_clause (larger, -smaller);
+    CADICAL_assert (eq2_tmp);
+  }
+
+  CADICAL_assert (!internal->lrat || eq2_tmp);
+  if (internal->lrat)
+    lrat_chain.clear ();
+
+  if (repr_lit == -repr_other) {
+    // now derive empty clause
+    Rewrite rew1, rew2;
+    if (internal->lrat) {
+      // no need to calculate push_id_and_rewriting_lrat here because all
+      // the job is done by the arguments already
+      rew1 = Rewrite (lit == repr_lit ? 0 : lit, repr_lit,
+                      lit == repr_lit ? 0 : representative_id (lit),
+                      lit == repr_lit ? 0 : representative_id (-lit));
+      rew2 = Rewrite (other == repr_other ? 0 : other, repr_other,
+                      other == repr_other ? 0 : representative_id (other),
+                      other == repr_other ? 0 : representative_id (-other));
+      push_id_and_rewriting_lrat_unit (eq1_tmp, rew1, lrat_chain, true,
+                                       rew2);
+      swap (lrat_chain, internal->lrat_chain);
+    }
+    CADICAL_assert (val_larger == internal->val (larger_repr));
+    if (!val_larger) {
+      // not assigned, first assign one
+      internal->assign_unit (-larger_repr);
+      if (internal->lrat) {
+        internal->lrat_chain.clear ();
+
+        if (larger != larger_repr)
+          push_lrat_unit (-larger_repr);
+        // no need to calculate push_id_and_rewriting_lrat here because all
+        // the job is done by the arguments already
+        push_id_and_rewriting_lrat_unit (
+            eq2_tmp, rew1, lrat_chain, true, rew2,
+            larger != larger_repr ? larger_repr : 0);
+        LOG (lrat_chain, "lrat chain");
+        swap (lrat_chain, internal->lrat_chain);
+      }
+    } else {
+      // otherwise, no need to
+      if (internal->lrat)
+        lrat_chain.push_back (internal->unit_id (larger_repr));
+    }
+    internal->learn_empty_clause ();
+    if (internal->lrat)
+      internal->lrat_chain.clear ();
+    return false;
+  }
+
+  if (val_lit) {
+    if (val_lit == val_other) {
+      LOG ("not merging lits %d and %d assigned to same value", lit, other);
+      if (internal->lrat)
+        lrat_chain.clear ();
+      return false;
+    }
+    if (val_lit == -val_other) {
+      LOG ("merging lits %d and %d assigned to inconsistent value", lit,
+           other);
+      CADICAL_assert (lrat_chain.empty ());
+      if (internal->lrat) {
+        Clause *c = val_lit ? eq2_tmp : eq1_tmp;
+        int pos = val_lit ? other : lit;
+        int neg = val_lit ? -lit : -other;
+        push_lrat_unit (pos);
+        push_lrat_unit (neg);
+        push_id_on_chain (lrat_chain, c);
+      }
+      internal->learn_empty_clause ();
+      if (internal->lrat)
+        lrat_chain.clear ();
+      return false;
+    }
+
+    CADICAL_assert (!val_other);
+    LOG ("merging assigned %d and unassigned %d", lit, other);
+    CADICAL_assert (lrat_chain.empty ());
+    const int unit = (val_lit < 0) ? -other : other;
+    if (internal->lrat) {
+      Clause *c;
+      if (lit == smaller) {
+        if (val_lit < 0)
+          c = eq1_tmp;
+        else
+          c = eq2_tmp;
+      } else {
+        if (val_lit < 0)
+          c = eq2_tmp;
+        else
+          c = eq1_tmp;
+      }
+      push_id_and_rewriting_lrat_unit (c, Rewrite (), lrat_chain, true,
+                                       Rewrite (), unit);
+    }
+    learn_congruence_unit (unit);
+    if (internal->lrat)
+      lrat_chain.clear ();
+    return false;
+  }
+
+  if (!val_lit && val_other) {
+    LOG ("merging assigned %d and unassigned %d", lit, other);
+    CADICAL_assert (lrat_chain.empty ());
+    const int unit = (val_other < 0) ? -lit : lit;
+    if (internal->lrat) {
+      Clause *c;
+      if (lit == smaller) {
+        CADICAL_assert (other == larger);
+        if (val_other > 0)
+          c = eq1_tmp;
+        else
+          c = eq2_tmp;
+      } else {
+        if (val_other > 0)
+          c = eq2_tmp;
+        else
+          c = eq1_tmp;
+      }
+      push_id_and_rewriting_lrat_unit (c, Rewrite (), lrat_chain, true,
+                                       Rewrite (), lit, unit);
+    }
+    learn_congruence_unit (unit);
+    if (internal->lrat)
+      lrat_chain.clear ();
+    return false;
+  }
+
+  Clause *eq1_repr, *eq2_repr;
+  if (smaller_repr != smaller || larger != larger_repr) {
+    if (internal->lrat) {
+      lrat_chain.clear ();
+      Rewrite rew1 = Rewrite (
+          smaller_repr != smaller ? smaller : 0,
+          smaller_repr != smaller ? smaller_repr : 0,
+          smaller_repr != smaller ? representative_id (smaller) : 0,
+          smaller_repr != smaller ? representative_id (-smaller) : 0);
+      Rewrite rew2 =
+          Rewrite (larger_repr != larger ? larger : 0,
+                   larger_repr != larger ? larger_repr : 0,
+                   larger_repr != larger ? representative_id (larger) : 0,
+                   larger_repr != larger ? representative_id (-larger) : 0);
+      push_id_and_rewriting_lrat_full (eq1_tmp, rew1, lrat_chain, true,
+                                       rew2);
+    }
+    eq1_repr = learn_binary_tmp_or_full_clause (-larger_repr, smaller_repr);
+  } else {
+    if (internal->lrat)
+      eq1_repr = maybe_promote_tmp_binary_clause (eq1_tmp);
+    else
+      eq1_repr = maybe_add_binary_clause (-larger_repr, smaller_repr);
+  }
+
+  if (internal->lrat) {
+    lrat_chain.clear ();
+  }
+
+  if (smaller_repr != smaller || larger != larger_repr) {
+
+    if (internal->lrat) {
+      lrat_chain.clear ();
+      // eq2 = larger, -smaller
+      Rewrite rew1 = Rewrite (
+          smaller_repr != smaller ? smaller : 0,
+          smaller_repr != smaller ? smaller_repr : 0,
+          smaller_repr != smaller ? representative_id (smaller) : 0,
+          smaller_repr != smaller ? representative_id (-smaller) : 0);
+      Rewrite rew2 =
+          Rewrite (larger_repr != larger ? larger : 0,
+                   larger_repr != larger ? larger_repr : 0,
+                   larger_repr != larger ? representative_id (larger) : 0,
+                   larger_repr != larger ? representative_id (-larger) : 0);
+      push_id_and_rewriting_lrat_full (eq2_tmp, rew1, lrat_chain, true,
+                                       rew2);
+    }
+    eq2_repr = learn_binary_tmp_or_full_clause (larger_repr, -smaller_repr);
+  } else {
+    if (internal->lrat)
+      eq2_repr = maybe_promote_tmp_binary_clause (eq2_tmp);
+    else
+      eq2_repr = maybe_add_binary_clause (larger_repr, -smaller_repr);
+  }
+  lrat_chain.clear ();
+
+  if (internal->lrat) {
+    representative_id (larger_repr) = eq1_repr->id;
+    CADICAL_assert (std::find (begin (*eq1_repr), end (*eq1_repr), -larger_repr) !=
+            end (*eq1_repr));
+    representative_id (-larger_repr) = eq2_repr->id;
+    check_not_tmp_binary_clause (eq1_repr);
+    check_not_tmp_binary_clause (eq2_repr);
+    CADICAL_assert (std::find (begin (*eq2_repr), end (*eq2_repr), larger_repr) !=
+            end (*eq2_repr));
+  }
+  LOG ("updating %d -> %d", larger_repr, smaller_repr);
+  representative (larger_repr) = smaller_repr;
+  representative (-larger_repr) = -smaller_repr;
+  schedule_literal (larger_repr);
+  ++internal->stats.congruence.congruent;
+  CADICAL_assert (lrat_chain.empty ());
+  return true;
+}
+
+inline void Closure::promote_clause (Clause *c) {
+  if (internal->lrat)
+    check_not_tmp_binary_clause (c);
+  if (!c)
+    return;
+  if (!c->redundant)
+    return;
+  LOG (c, "turning redundant subsuming clause into irredundant clause");
+  c->redundant = false;
+  if (internal->proof)
+    internal->proof->strengthen (c->id);
+  internal->stats.current.irredundant++;
+  internal->stats.added.irredundant++;
+  internal->stats.irrlits += c->size;
+  CADICAL_assert (internal->stats.current.redundant > 0);
+  internal->stats.current.redundant--;
+  CADICAL_assert (internal->stats.added.redundant > 0);
+  internal->stats.added.redundant--;
+  // ... and keep 'stats.added.total'.
+}
+
+// This function is rather tricky for LRAT. If you have 2 = 1 and 3=4 you
+// cannot add 2=3. You really to connect the representatives directly
+// therefore you actually need to learn the clauses 2->3->4 and -2->1 and
+// vice-versa
+bool Closure::merge_literals_equivalence (int lit, int other, Clause *c1,
+                                          Clause *c2) {
+  CADICAL_assert (!internal->unsat);
+  LRAT_ID id1 = c1 ? c1->id : 0;
+  LRAT_ID id2 = c2 ? c2->id : 0;
+  if (internal->lrat) {
+    CADICAL_assert (c1);
+    CADICAL_assert (c2);
+    CADICAL_assert (c1->size == 2);
+    CADICAL_assert (c2->size == 2);
+    CADICAL_assert (c1->literals[0] == lit || c1->literals[1] == lit);
+    CADICAL_assert (c2->literals[0] == other || c2->literals[1] == other);
+    CADICAL_assert (c1->literals[0] == -other || c1->literals[1] == -other);
+    CADICAL_assert (c2->literals[0] == -lit || c2->literals[1] == -lit);
+    check_not_tmp_binary_clause (c1);
+    check_not_tmp_binary_clause (c2);
+  }
+  int repr_lit = find_representative (lit);
+  int repr_other = find_representative (other);
+  find_representative_and_compress_both (lit);
+  find_representative_and_compress_both (other);
+  LOG ("merging literals %d [=%d] and %d [=%d] lrat", lit, repr_lit, other,
+       repr_other);
+
+  if (repr_lit == repr_other) {
+    LOG ("already merged %d and %d", lit, other);
+    return false;
+  }
+  const int val_lit = internal->val (lit);
+  const int val_other = internal->val (other);
+
+  if (val_lit) {
+    if (val_lit == val_other) {
+      LOG ("not merging lits %d and %d assigned to same value", lit, other);
+      return false;
+    }
+    if (val_lit == -val_other) {
+      if (internal->lrat)
+        lrat_chain.push_back (internal->unit_id (lit)),
+            lrat_chain.push_back (internal->unit_id (other));
+      LOG ("merging lits %d and %d assigned to inconsistent value", lit,
+           other);
+      internal->learn_empty_clause ();
+      return false;
+    }
+
+    CADICAL_assert (!val_other);
+    LOG ("merging assigned %d and unassigned %d", lit, other);
+    const int unit = (val_lit < 0) ? -other : other;
+    if (internal->lrat)
+      lrat_chain.push_back (internal->unit_id (unit));
+    if (val_lit < 0)
+      lrat_chain.push_back (c2->id);
+    else
+      lrat_chain.push_back (c1->id);
+    learn_congruence_unit (unit);
+    return false;
+  }
+
+  if (!val_lit && val_other) {
+    LOG ("merging assigned %d and unassigned %d", other, lit);
+    const int unit = (val_other < 0) ? -lit : lit;
+    if (internal->lrat)
+      lrat_chain.push_back (
+          internal->unit_id (val_other < 0 ? -other : other));
+    if (val_lit < 0)
+      lrat_chain.push_back (c1->id);
+    else
+      lrat_chain.push_back (c2->id);
+    learn_congruence_unit (unit);
+    return false;
+  }
+
+  int smaller_repr = repr_lit;
+  int larger_repr = repr_other;
+  int smaller = lit;
+  int larger = other;
+
+  if (abs (smaller_repr) > abs (larger_repr)) {
+    swap (smaller_repr, larger_repr);
+    swap (smaller, larger);
+  }
+
+  CADICAL_assert (find_representative (smaller_repr) == smaller_repr);
+  CADICAL_assert (find_representative (larger_repr) == larger_repr);
+
+  if (repr_lit == -repr_other) {
+    LOG ("merging clashing %d [=%d] and %d[=%d], smaller: %d", lit,
+         repr_lit, other, repr_other, smaller);
+    if (internal->lrat) {
+      Rewrite rew1 =
+          Rewrite (lit, lit == repr_lit ? 0 : repr_lit,
+                   lit == repr_lit ? 0 : find_representative_lrat (lit),
+                   lit == repr_lit ? 0 : find_representative_lrat (-lit));
+      Rewrite rew2 = Rewrite (
+          other, other == repr_other ? 0 : repr_other,
+          other == repr_other ? 0 : find_representative_lrat (other),
+          other == repr_other ? 0 : find_representative_lrat (-other));
+      push_id_and_rewriting_lrat_unit (c1, rew1, lrat_chain, true, rew2);
+      LOG (lrat_chain, "lrat chain");
+      swap (internal->lrat_chain, lrat_chain);
+    }
+    internal->assign_unit (repr_lit);
+    if (internal->lrat) {
+      lrat_chain.clear ();
+      LRAT_ID id = internal->unit_id (repr_lit);
+      CADICAL_assert (id);
+      lrat_chain.push_back (id);
+      if (lit != repr_lit) {
+        const LRAT_ID repr_id2 = find_representative_lrat (-lit);
+        lrat_chain.push_back (repr_id2);
+      }
+      lrat_chain.push_back (id2);
+      if (other != repr_other) {
+        const LRAT_ID repr_larger_id2 = find_representative_lrat (other);
+        lrat_chain.push_back (repr_larger_id2);
+      }
+      LOG (lrat_chain, "lrat chain");
+      swap (internal->lrat_chain, lrat_chain);
+    }
+    internal->learn_empty_clause ();
+    return false;
+  }
+
+  LOG ("merging %d [=%d] and %d [=%d]", lit, repr_lit, other, repr_other);
+  promote_clause (c1), promote_clause (c2);
+  bool learn_clause = (lit != repr_lit) || (other != repr_other);
+  if (learn_clause) {
+    if (internal->lrat) {
+      if (lit != repr_lit) {
+        LOG ("adding chain for lit %d -> %d", lit, repr_lit);
+        lrat_chain.push_back (find_representative_lrat (lit));
+      }
+      if (other != repr_other) {
+        LOG ("adding chain for lit %d -> %d", -other, -repr_other);
+        lrat_chain.push_back (find_representative_lrat (-other));
+      }
+      lrat_chain.push_back (id1);
+    }
+    Clause *eq1 = learn_binary_tmp_or_full_clause (repr_lit, -repr_other);
+
+    if (internal->lrat) {
+      lrat_chain.clear ();
+      if (lit != repr_lit)
+        lrat_chain.push_back (find_representative_lrat (-lit));
+      if (other != repr_other)
+        lrat_chain.push_back (find_representative_lrat (other));
+      lrat_chain.push_back (id2);
+    }
+    Clause *eq2 = learn_binary_tmp_or_full_clause (-repr_lit, repr_other);
+    if (internal->lrat) {
+      lrat_chain.clear ();
+      if (smaller_repr == repr_lit) {
+        CADICAL_assert (larger_repr == repr_other);
+        representative_id (-larger_repr) = eq2->id;
+        CADICAL_assert (std::find (eq2->begin (), eq2->end (), larger_repr) !=
+                eq2->end ());
+        representative_id (larger_repr) = eq1->id;
+        CADICAL_assert (std::find (eq1->begin (), eq1->end (), -larger_repr) !=
+                eq1->end ());
+      } else {
+        CADICAL_assert (larger_repr == repr_lit);
+        representative_id (-larger_repr) = eq1->id;
+        CADICAL_assert (std::find (eq1->begin (), eq1->end (), larger_repr) !=
+                eq1->end ());
+        representative_id (larger_repr) = eq2->id;
+        CADICAL_assert (std::find (eq2->begin (), eq2->end (), -larger_repr) !=
+                eq2->end ());
+      }
+    }
+
+  } else if (internal->lrat) {
+    LOG ("not learning new clause, using already existing one");
+    if (smaller_repr == repr_lit) {
+      LOG ("setting ids of %d: %" PRIu64 "; %d: %" PRIu64 " (case 1)",
+           larger, id1, -larger, id2);
+      representative_id (-larger_repr) = id2;
+      representative_id (larger_repr) = id1;
+    } else {
+      LOG ("setting ids of %d: %" PRIu64 "; %d: %" PRIu64 " (case 2)",
+           larger, id2, -larger, id1);
+      representative_id (-larger_repr) = id1;
+      representative_id (larger_repr) = id2;
+    }
+  }
+
+  LOG ("updating %d -> %d", larger_repr, smaller_repr);
+  representative (larger_repr) = smaller_repr;
+  representative (-larger_repr) = -smaller_repr;
+  schedule_literal (larger_repr);
+  ++internal->stats.congruence.congruent;
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+GOccs &Closure::goccs (int lit) { return gtab[internal->vlit (lit)]; }
+
+void Closure::connect_goccs (Gate *g, int lit) {
+  LOG (g, "connect %d to", lit);
+  // incorrect for ITE
+  // CADICAL_assert (std::find(begin (goccs (lit)), end (goccs (lit)), g) ==
+  // std::end (goccs (lit)));
+  goccs (lit).push_back (g);
+}
+
+uint64_t &Closure::largecount (int lit) {
+  CADICAL_assert (internal->vlit (lit) < glargecounts.size ());
+  return glargecounts[internal->vlit (lit)];
+}
+
+/*------------------------------------------------------------------------*/
+// Initialization
+
+void Closure::init_closure () {
+  representant.resize (2 * internal->max_var + 3);
+  eager_representant.resize (2 * internal->max_var + 3);
+  if (internal->lrat) {
+    eager_representant_id.resize (2 * internal->max_var + 3);
+    representant_id.resize (2 * internal->max_var + 3);
+    lazy_propagated_idx.resize (internal->max_var + 1, false);
+    for (auto lit : internal->trail)
+      lazy_propagated (lit) = true;
+  }
+  marks.resize (2 * internal->max_var + 3);
+  mu1_ids.resize (2 * internal->max_var + 3);
+  if (internal->lrat) {
+    mu2_ids.resize (2 * internal->max_var + 3);
+    mu4_ids.resize (2 * internal->max_var + 3);
+  }
+#ifndef CADICAL_NDEBUG
+  for (auto &it : mu1_ids)
+    it.current_lit = 0, it.clause = nullptr;
+  for (auto &it : mu2_ids)
+    it.current_lit = 0, it.clause = nullptr;
+  for (auto &it : mu4_ids)
+    it.current_lit = 0, it.clause = nullptr;
+#endif
+  scheduled.resize (internal->max_var + 1);
+  gtab.resize (2 * internal->max_var + 3);
+  for (auto v : internal->vars) {
+    representative (v) = v;
+    representative (-v) = -v;
+    eager_representative (v) = v;
+    eager_representative (-v) = -v;
+  }
+  units = internal->propagated;
+  Random rand (internal->stats.congruence.rounds);
+  for (auto &n : nonces) {
+    n = 1 | rand.next ();
+  }
+#ifdef LOGGING
+  fresh_id = internal->clause_id;
+#endif
+  internal->init_noccs ();
+  internal->init_occs ();
+}
+
+void Closure::init_and_gate_extraction () {
+  LOG ("[gate-extraction]");
+  for (Clause *c : internal->clauses) {
+    if (c->garbage)
+      continue;
+    if (c->redundant && c->size != 2)
+      continue;
+    if (c->size > 2)
+      continue;
+    CADICAL_assert (c->size == 2);
+    const int lit = c->literals[0];
+    const int other = c->literals[1];
+    internal->noccs (lit)++;
+    internal->noccs (other)++;
+    internal->watch_clause (c);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+void Closure::check_and_gate_implied (Gate *g) {
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (g->tag == Gate_Type::And_Gate);
+  if (internal->lrat)
+    return;
+  LOG (g, "checking implied");
+  const int lhs = g->lhs;
+  const int not_lhs = -lhs;
+  for (auto other : g->rhs)
+    check_binary_implied (not_lhs, other);
+  internal->clause = g->rhs;
+  check_implied ();
+  internal->clause.clear ();
+}
+
+void Closure::delete_proof_chain () {
+  if (!internal->proof) {
+    CADICAL_assert (chain.empty ());
+    return;
+  }
+  if (chain.empty ())
+    return;
+  LOG ("starting deletion of proof chain");
+  auto &clause = internal->clause;
+  CADICAL_assert (clause.empty ());
+  uint32_t id1 = UINT32_MAX, id2 = UINT32_MAX;
+  LRAT_ID id = 0;
+
+  LOG (chain, "chain:");
+  for (auto lit : chain) {
+    LOG ("reading %d from chain", lit);
+    if (id1 == UINT32_MAX) {
+      id1 = lit;
+      id = (LRAT_ID) id1;
+      continue;
+    }
+    if (id2 == UINT32_MAX) {
+      id2 = lit;
+      id = ((LRAT_ID) id1 << 32) + id2;
+      continue;
+    }
+    if (lit) { // parsing the id first
+      LOG ("found %d as literal in chain", lit);
+      clause.push_back (lit);
+    } else {
+      CADICAL_assert (id);
+      internal->proof->delete_clause (id, false, clause);
+      clause.clear ();
+      id = 0, id1 = UINT32_MAX, id2 = UINT32_MAX;
+    }
+  }
+  CADICAL_assert (clause.empty ());
+  chain.clear ();
+  LOG ("finished deletion of proof chain");
+}
+
+/*------------------------------------------------------------------------*/
+// Simplification
+bool Closure::skip_and_gate (Gate *g) {
+  CADICAL_assert (g->tag == Gate_Type::And_Gate);
+  if (g->garbage)
+    return true;
+  const int lhs = g->lhs;
+  if (internal->val (lhs) > 0) {
+    mark_garbage (g);
+    return true;
+  }
+
+  CADICAL_assert (g->arity () > 1);
+  return false;
+}
+
+bool Closure::skip_xor_gate (Gate *g) {
+  CADICAL_assert (g->tag == Gate_Type::XOr_Gate);
+  if (g->garbage)
+    return true;
+  CADICAL_assert (g->arity () > 1);
+  return false;
+}
+
+void Closure::shrink_and_gate (Gate *g, int falsifies, int clashing) {
+  if (falsifies) {
+    g->rhs.resize (1);
+    g->rhs[0] = falsifies;
+    g->hash = hash_lits (nonces, g->rhs);
+  } else if (clashing) {
+    LOG (g, "gate before clashing on %d", clashing);
+    g->rhs.resize (2);
+    g->rhs[0] = clashing;
+    g->rhs[1] = -clashing;
+    g->hash = hash_lits (nonces, g->rhs);
+    LOG (g, "gate after clashing on %d", clashing);
+  }
+  g->shrunken = true;
+}
+
+void Closure::update_and_gate_unit_build_lrat_chain (
+    Gate *g, int src, LRAT_ID id1, LRAT_ID id2, int dst,
+    std::vector<LRAT_ID> &extra_reasons_lit,
+    std::vector<LRAT_ID> &extra_reasons_ulit) {
+  LOG ("generate chain for gate boiling down to unit");
+  if (g->neg_lhs_ids.size () != 1) {
+
+    if (g->degenerated_and_neg || g->degenerated_and_pos) {
+      // can happen for 4 = AND 3 4 (degenerated with only the clause -4 3)
+      // with a rewriting 4 -> 1 (unchanged clause)
+      // and later 1 -> 3 (unchanged clause)
+      // but you do not know anymore from the gate that it is degenerated
+      CADICAL_assert (g->pos_lhs_ids.size () == 1);
+      push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[0].clause, Rewrite (),
+                                       extra_reasons_ulit, true, Rewrite ());
+      return;
+    }
+    CADICAL_assert (g->lhs == g->rhs[0] || (g->lhs == src && g->rhs[0] == dst));
+    CADICAL_assert (g->pos_lhs_ids.size () <= 1); // either degenerated or empty A = A
+    return;
+  }
+  CADICAL_assert (g->neg_lhs_ids.size () == 1);
+  CADICAL_assert (!g->pos_lhs_ids.empty ());
+
+  const int repr_lit = find_representative (g->lhs);
+  const int repr_other = find_representative (g->rhs[0]);
+  if (repr_lit == repr_other) {
+    LOG ("skipping already merged");
+    return;
+  }
+
+  push_id_and_rewriting_lrat_unit (g->neg_lhs_ids[0].clause, Rewrite (),
+                                   extra_reasons_ulit, true, Rewrite (),
+                                   g->lhs, -dst);
+  LOG (extra_reasons_ulit, "lrat chain for negative side");
+
+  lrat_chain.clear ();
+
+  CADICAL_assert (!g->pos_lhs_ids.empty ());
+  for (auto litId : g->pos_lhs_ids)
+    push_id_and_rewriting_lrat_unit (
+        litId.clause, Rewrite (src, dst, id1, id2), extra_reasons_lit, true,
+        Rewrite (), -g->lhs, dst);
+  LOG (extra_reasons_lit, "lrat chain for positive side");
+}
+
+void Closure::update_and_gate_build_lrat_chain (
+    Gate *g, Gate *h, std::vector<LRAT_ID> &extra_reasons_lit,
+    std::vector<LRAT_ID> &extra_reasons_ulit, bool remove_units) {
+  CADICAL_assert (g != h);
+  LOG (g, "merging");
+  LOG (h, "with");
+  // If the LHS are identical, do not even attempt to build the LRAT chain
+  if (find_representative (g->lhs) == find_representative (h->lhs))
+    return;
+  // set to same value, don't do anything
+  if (internal->val (g->lhs) && internal->val (g->lhs) == internal->val (h->lhs))
+    return;
+  const bool g_tautology = gate_contains (g, g->lhs);
+  const bool h_tautology = gate_contains (h, h->lhs);
+  if (g_tautology && h_tautology) {
+    LOG ("both gates are a tautology");
+    // special case: actually we have an equivalence due to binary clauses
+    // and all gate clauses (except one binary) are actually tautologies
+    for (auto &litId : g->pos_lhs_ids) {
+      if (litId.current_lit == h->lhs) {
+        CADICAL_assert (extra_reasons_lit.empty ());
+        LOG (litId.clause, "binary clause to push into the reason");
+        litId.clause = produce_rewritten_clause_lrat (litId.clause, g->lhs,
+                                                      remove_units);
+        CADICAL_assert (litId.clause);
+        extra_reasons_lit.push_back (litId.clause->id);
+      }
+    }
+    CADICAL_assert (!extra_reasons_lit.empty ());
+    CADICAL_assert (extra_reasons_lit.size () == 1);
+
+    for (auto &litId : h->pos_lhs_ids) {
+      if (litId.current_lit == g->lhs) {
+        CADICAL_assert (extra_reasons_ulit.empty ());
+	CADICAL_assert (litId.clause);
+        LOG (litId.clause, "binary clause to push into the reason");
+        litId.clause = produce_rewritten_clause_lrat (litId.clause, h->lhs,
+                                                      remove_units);
+        CADICAL_assert (litId.clause);
+        extra_reasons_ulit.push_back (litId.clause->id);
+      }
+    }
+    CADICAL_assert (!extra_reasons_ulit.empty ());
+    CADICAL_assert (extra_reasons_ulit.size () == 1);
+    return;
+  }
+  if (g_tautology || h_tautology) {
+    // special case: actually we have an equivalence due to binary clauses
+    // and some of the clauses from the gate are actually tautologies
+    CADICAL_assert (g_tautology != h_tautology);
+    Gate *tauto = (g_tautology ? g : h);
+    Gate *other = (g_tautology ? h : g);
+    LOG (tauto, "one gate is a tautology");
+    CADICAL_assert (tauto != other);
+    CADICAL_assert (tauto == h || tauto == g);
+
+    auto &extra_reasons_tauto =
+        (!g_tautology ? extra_reasons_lit : extra_reasons_ulit);
+    auto &extra_reasons_other =
+        (!g_tautology ? extra_reasons_ulit : extra_reasons_lit);
+
+    // one direction: the binary clause already exists
+    for (auto &litId : other->pos_lhs_ids) {
+      if (litId.current_lit == tauto->lhs) {
+	CADICAL_assert (litId.clause);
+        CADICAL_assert (extra_reasons_tauto.empty ());
+        LOG (litId.clause, "binary clause to push into the reason");
+        litId.clause = produce_rewritten_clause_lrat (
+            litId.clause, other->lhs, remove_units);
+        CADICAL_assert (litId.clause);
+        extra_reasons_tauto.push_back (litId.clause->id);
+      }
+    }
+    CADICAL_assert (!extra_reasons_tauto.empty ());
+
+    // other direction, we have to resolve
+    LOG (tauto, "now the other direction");
+    for (auto &litId : tauto->pos_lhs_ids) {
+      CADICAL_assert (litId.clause);
+      LOG (litId.clause,
+           "binary clause from %d to push into the reason [avoiding %d]",
+           litId.current_lit, tauto->lhs);
+      if (litId.current_lit != tauto->lhs) {
+        LOG (litId.clause, "binary clause to push into the reason");
+	CADICAL_assert (litId.clause);
+        litId.clause = produce_rewritten_clause_lrat (
+            litId.clause, tauto->lhs, remove_units);
+        if (!litId.clause) // degenerated but does not know yet
+	  continue;
+	CADICAL_assert (litId.clause);
+        extra_reasons_other.push_back (litId.clause->id);
+      }
+      tauto->pos_lhs_ids.erase (std::remove_if (begin (tauto->pos_lhs_ids),
+                                            end (tauto->pos_lhs_ids),
+                                            [] (const LitClausePair &p) {
+                                              return !p.clause;
+                                            }),
+                            end (tauto->pos_lhs_ids));
+    }
+    CADICAL_assert (!extra_reasons_other.empty ());
+    produce_rewritten_clause_lrat_and_clean (other->neg_lhs_ids, other->lhs,
+                                             remove_units);
+    push_id_on_chain (extra_reasons_other, other->neg_lhs_ids);
+    CADICAL_assert (!extra_reasons_tauto.empty ());
+    CADICAL_assert (!extra_reasons_other.empty ());
+    return;
+  }
+  // default: resolve all clauses
+  // first rewrite
+  // TODO: do we really need dest as second exclusion?
+  produce_rewritten_clause_lrat_and_clean (h->pos_lhs_ids, -h->lhs,
+                                           remove_units);
+  CADICAL_assert (internal->clause.empty ());
+  produce_rewritten_clause_lrat_and_clean (h->neg_lhs_ids, -h->lhs,
+                                           remove_units);
+  CADICAL_assert (internal->clause.empty ());
+  produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, -g->lhs,
+                                           remove_units);
+  CADICAL_assert (internal->clause.empty ());
+  produce_rewritten_clause_lrat_and_clean (g->neg_lhs_ids, -g->lhs,
+                                           remove_units);
+  CADICAL_assert (internal->clause.empty ());
+
+  push_id_on_chain (extra_reasons_ulit, h->pos_lhs_ids);
+  push_id_on_chain (extra_reasons_ulit, g->neg_lhs_ids[0].clause);
+  lrat_chain.clear ();
+  LOG (extra_reasons_ulit, "lrat chain for negative side");
+
+  push_id_on_chain (extra_reasons_lit, g->pos_lhs_ids);
+  push_id_on_chain (extra_reasons_lit, h->neg_lhs_ids);
+
+  lrat_chain.clear ();
+  LOG (extra_reasons_lit, "lrat chain for positive side");
+  CADICAL_assert (!extra_reasons_lit.empty ());
+  CADICAL_assert (!extra_reasons_ulit.empty ());
+}
+
+void Closure::update_and_gate (Gate *g, GatesTable::iterator it, int src,
+                               int dst, LRAT_ID id1, LRAT_ID id2,
+                               int falsifies, int clashing) {
+  LOG (g, "update and gate of arity %ld", g->arity ());
+  CADICAL_assert (lrat_chain.empty ());
+  bool garbage = true;
+  if (falsifies || clashing) {
+    if (internal->lrat)
+      learn_congruence_unit_falsifies_lrat_chain (g, src, dst, clashing,
+                                                  falsifies, 0);
+    int unit = -g->lhs;
+    if (unit == src)
+      unit = dst;
+    else if (unit == -src)
+      unit = -dst;
+    learn_congruence_unit (unit);
+    if (internal->lrat)
+      lrat_chain.clear ();
+  } else if (g->arity () == 1) {
+    const signed char v = internal->val (g->lhs);
+    if (v > 0) {
+      if (internal->lrat)
+        learn_congruence_unit_falsifies_lrat_chain (g, src, dst, 0, 0,
+                                                    g->lhs);
+      learn_congruence_unit (g->rhs[0]);
+      if (internal->lrat)
+        lrat_chain.clear ();
+    } else if (v < 0) {
+      if (internal->lrat)
+        learn_congruence_unit_when_lhs_set (g, src, id1, id2, dst);
+      learn_congruence_unit (-g->rhs[0]);
+      if (internal->lrat)
+        lrat_chain.clear ();
+    } else {
+      std::vector<LRAT_ID> extra_reasons_lit;
+      std::vector<LRAT_ID> extra_reasons_ulit;
+      if (internal->lrat)
+        update_and_gate_unit_build_lrat_chain (g, src, id1, id2, g->rhs[0],
+                                               extra_reasons_lit,
+                                               extra_reasons_ulit);
+      if (merge_literals_lrat (g, g, g->lhs, g->rhs[0], extra_reasons_lit,
+                               extra_reasons_ulit)) {
+        ++internal->stats.congruence.unaries;
+        ++internal->stats.congruence.unary_and;
+      }
+    }
+  } else {
+    CADICAL_assert (g->arity () > 1);
+    sort_literals_by_var (g->rhs);
+    Gate *h = find_and_lits (g->rhs, g);
+    CADICAL_assert (g != h);
+    if (h) {
+      CADICAL_assert (garbage);
+      std::vector<LRAT_ID> extra_reasons_lit2;
+      std::vector<LRAT_ID> extra_reasons_ulit2;
+      if (internal->lrat)
+        update_and_gate_build_lrat_chain (g, h, extra_reasons_lit2,
+                                          extra_reasons_ulit2);
+      if (merge_literals_lrat (g, h, g->lhs, h->lhs, extra_reasons_lit2,
+                               extra_reasons_ulit2))
+        ++internal->stats.congruence.ands;
+    } else {
+      if (g->indexed) {
+        LOG (g, "removing from table");
+        (void) table.erase (it);
+      }
+      g->hash = hash_lits (nonces, g->rhs);
+      LOG (g, "inserting gate into table");
+      CADICAL_assert (table.count (g) == 0);
+      table.insert (g);
+      g->indexed = true;
+      garbage = false;
+      if (internal->lrat)
+        lrat_chain.clear ();
+    }
+  }
+
+  if (garbage && !internal->unsat)
+    mark_garbage (g);
+}
+
+void Closure::update_xor_gate (Gate *g, GatesTable::iterator git) {
+  CADICAL_assert (g->tag == Gate_Type::XOr_Gate);
+  CADICAL_assert (!internal->unsat && chain.empty ());
+  LOG (g, "updating");
+  bool garbage = true;
+  // TODO Florian LRAT for learn_congruence_unit
+  CADICAL_assert (g->arity () == 0 || internal->clause.empty ());
+  CADICAL_assert (clause.empty ());
+  if (g->arity () == 0) {
+    if (internal->clause.size ()) {
+      CADICAL_assert (!internal->proof || (internal->clause.size () == 1 &&
+                                   internal->clause.back () == -g->lhs));
+      CADICAL_assert (!internal->lrat || lrat_chain.size ());
+      internal->clause.clear ();
+
+    } else if (internal->lrat) {
+      simplify_unit_xor_lrat_clauses (g->pos_lhs_ids, g->lhs);
+      CADICAL_assert (clause.size () && clause.back () == -g->lhs);
+      clause.clear ();
+    }
+
+    if (internal->lrat && internal->val (-g->lhs) < 0) {
+      internal->lrat_chain.push_back (internal->unit_id (g->lhs));
+      for (auto id : lrat_chain)
+        internal->lrat_chain.push_back (id);
+      lrat_chain.clear ();
+      internal->learn_empty_clause();
+    } else
+      learn_congruence_unit (-g->lhs);
+
+    CADICAL_assert (clause.empty ());
+  } else if (g->arity () == 1) {
+    std::vector<LRAT_ID> reasons_implication, reasons_back;
+    if (internal->lrat) {
+      vector<LitClausePair> first;
+      simplify_and_sort_xor_lrat_clauses (g->pos_lhs_ids, first, g->lhs);
+      g->pos_lhs_ids = first;
+      CADICAL_assert (g->pos_lhs_ids.size () == 2);
+      reasons_implication.push_back (g->pos_lhs_ids[0].clause->id);
+      reasons_back.push_back (g->pos_lhs_ids[1].clause->id);
+    }
+    const signed char v = internal->val (g->lhs);
+    if (v > 0) {
+      if (internal->lrat) {
+        push_lrat_unit (g->lhs);
+        lrat_chain.push_back (g->pos_lhs_ids[0].clause->id);
+      }
+      learn_congruence_unit (g->rhs[0]);
+    } else if (v < 0) {
+      if (internal->lrat) {
+        push_lrat_unit (-g->lhs);
+        lrat_chain.push_back (g->pos_lhs_ids[1].clause->id);
+      }
+      learn_congruence_unit (-g->rhs[0]);
+    } else if (merge_literals_lrat (
+                   g->lhs, g->rhs[0], reasons_implication,
+                   reasons_back)) { // TODO Florian merge with LRAT
+      ++internal->stats.congruence.unaries;
+      ++internal->stats.congruence.unary_and;
+    }
+    CADICAL_assert (clause.empty ());
+  } else {
+    Gate *h = find_xor_gate (g);
+    if (h) {
+      CADICAL_assert (garbage);
+      std::vector<LRAT_ID> reasons_implication, reasons_back;
+      add_xor_matching_proof_chain (g, g->lhs, h->pos_lhs_ids, h->lhs,
+                                    reasons_implication, reasons_back);
+      if (merge_literals_lrat (g->lhs, h->lhs, reasons_implication,
+                               reasons_back))
+        ++internal->stats.congruence.xors;
+      delete_proof_chain ();
+    } else {
+      if (g->indexed) {
+        remove_gate (git);
+      }
+      g->hash = hash_lits (nonces, g->rhs);
+      LOG (g, "reinserting in table");
+      table.insert (g);
+      g->indexed = true;
+      CADICAL_assert (table.find (g) != end (table));
+      garbage = false;
+    }
+    CADICAL_assert (clause.empty ());
+  }
+  if (garbage && !internal->unsat)
+    mark_garbage (g);
+  CADICAL_assert (clause.empty ());
+}
+
+void Closure::simplify_and_gate (Gate *g) {
+  if (skip_and_gate (g))
+    return;
+  GatesTable::iterator git = (g->indexed ? table.find (g) : end (table));
+  CADICAL_assert (!g->indexed || git != end (table));
+  LOG (g, "simplifying");
+  int falsifies = 0;
+  std::vector<int>::iterator it = begin (g->rhs);
+  bool ulhs_in_rhs = false;
+  for (auto lit : g->rhs) {
+    const signed char v = internal->val (lit);
+    if (v > 0) {
+      continue;
+    }
+    if (v < 0) {
+      falsifies = lit;
+      continue;
+    }
+    if (lit == -g->lhs)
+      ulhs_in_rhs = true;
+    *it++ = lit;
+    if (lit == g->lhs)
+      g->degenerated_and_pos = true;
+    if (lit == -g->lhs)
+      g->degenerated_and_neg = true;
+  }
+
+  if (internal->lrat) { // updating reasons
+    size_t i = 0, size = g->pos_lhs_ids.size ();
+    for (size_t j = 0; j < size; ++j) {
+      LOG ("looking at %d [%ld %ld]", g->pos_lhs_ids[j].current_lit, i, j);
+      g->pos_lhs_ids[i] = g->pos_lhs_ids[j];
+      if (!g->degenerated_and_pos &&
+          internal->val (g->pos_lhs_ids[i].current_lit) &&
+          g->pos_lhs_ids[i].current_lit != falsifies)
+        continue;
+      LOG ("keeping %d [%ld %ld]", g->pos_lhs_ids[i].current_lit, i, j);
+      ++i;
+    }
+    LOG ("resizing to %ld", i);
+    g->pos_lhs_ids.resize (i);
+  }
+
+  CADICAL_assert (it <= end (g->rhs)); // can be equal when ITE are converted to
+                               // ands leading to
+  CADICAL_assert (it >= begin (g->rhs));
+  LOG (g, "shrunken");
+
+  g->shrunken = true;
+  g->rhs.resize (it - std::begin (g->rhs));
+  g->hash = hash_lits (nonces, g->rhs);
+
+  LOG (g, "shrunken");
+  shrink_and_gate (g, falsifies);
+  std::vector<LRAT_ID> reasons_lrat_src, reasons_lrat_usrc;
+
+  update_and_gate (g, git, 0, 0, 0, 0, falsifies, 0);
+  ++internal->stats.congruence.simplified_ands;
+  ++internal->stats.congruence.simplified;
+
+  if (ulhs_in_rhs) { // missing in Kissat, TODO: port back
+    CADICAL_assert (gate_contains (g, -g->lhs));
+    if (internal->lrat) {
+      for (auto litId : g->pos_lhs_ids) {
+        if (litId.current_lit == g->lhs) {
+          compute_rewritten_clause_lrat_simple (litId.clause, 0);
+          break;
+        }
+      }
+    }
+    learn_congruence_unit (-g->lhs);
+  }
+}
+
+bool Closure::simplify_gate (Gate *g) {
+  switch (g->tag) {
+  case Gate_Type::And_Gate:
+    simplify_and_gate (g);
+    break;
+  case Gate_Type::XOr_Gate:
+    simplify_xor_gate (g);
+    break;
+  case Gate_Type::ITE_Gate:
+    simplify_ite_gate (g);
+    break;
+  default:
+    CADICAL_assert (false);
+    break;
+  }
+  CADICAL_assert (lrat_chain.empty ());
+  return !internal->unsat;
+}
+
+bool Closure::simplify_gates (int lit) {
+  const auto &occs = goccs (lit);
+  for (Gate *g : occs) {
+    CADICAL_assert (lrat_chain.empty ());
+    CADICAL_assert (clause.empty ());
+    if (!simplify_gate (g))
+      return false;
+  }
+  return true;
+}
+/*------------------------------------------------------------------------*/
+// AND gates
+
+Gate *Closure::find_and_lits (const vector<int> &rhs, Gate *except) {
+  CADICAL_assert (is_sorted (begin (rhs), end (rhs),
+                     sort_literals_by_var_smaller (internal)));
+  return find_gate_lits (rhs, Gate_Type::And_Gate, except);
+}
+
+// search for the gate in the hash-table.  We cannot use find, as we might
+// be changing a gate, so there might be 2 gates with the same LHS (the one
+// we are changing and the other we are looking for)
+Gate *Closure::find_gate_lits (const vector<int> &rhs, Gate_Type typ,
+                               Gate *except) {
+  Gate *g = new Gate;
+  g->tag = typ;
+  g->rhs = rhs;
+  g->hash = hash_lits (nonces, g->rhs);
+  g->lhs = 0;
+  g->garbage = false;
+#ifdef LOGGING
+  g->id = 0;
+#endif
+  const auto &its = table.equal_range (g);
+  Gate *h = nullptr;
+  for (auto it = its.first; it != its.second; ++it) {
+    LOG ((*it), "checking gate in the table");
+    if (*it == except)
+      continue;
+    CADICAL_assert ((*it)->lhs != g->lhs);
+    if ((*it)->tag != g->tag)
+      continue;
+    if ((*it)->rhs != g->rhs)
+      continue;
+    h = *it;
+    break;
+  }
+
+  if (h) {
+    LOG (g, "searching");
+    LOG (h, "already existing");
+    delete g;
+    return h;
+  }
+
+  else {
+    LOG (g->rhs, "gate not found in table");
+    delete g;
+    return nullptr;
+  }
+}
+
+Gate *Closure::new_and_gate (Clause *base_clause, int lhs) {
+  rhs.clear ();
+  auto &lits = this->lits;
+
+  for (auto lit : lits) {
+    if (lhs != lit) {
+      CADICAL_assert (lhs != -lit);
+      rhs.push_back (-lit);
+    }
+  }
+
+  CADICAL_assert (rhs.size () + 1 == lits.size ());
+  sort_literals_by_var (this->rhs);
+
+  Gate *h = find_and_lits (this->rhs);
+  Gate *g = new Gate;
+  g->lhs = lhs;
+  g->tag = Gate_Type::And_Gate;
+  if (internal->lrat) {
+    g->neg_lhs_ids.push_back (LitClausePair (lhs, base_clause));
+    for (auto i : lrat_chain_and_gate)
+      g->pos_lhs_ids.push_back (i);
+#ifdef LOGGING
+    std::vector<LRAT_ID> result;
+    transform (begin (g->pos_lhs_ids), end (g->pos_lhs_ids),
+               back_inserter (result),
+               [] (const LitClausePair &x) { return x.clause->id; });
+    LOG (result, "lrat chain positive (%d):", lhs);
+    result.clear ();
+    transform (begin (g->neg_lhs_ids), end (g->neg_lhs_ids),
+               back_inserter (result),
+               [] (const LitClausePair &x) { return x.clause->id; });
+    LOG (result, "lrat chain negative (%d):", lhs);
+#endif
+  }
+
+  if (internal->lrat)
+    lrat_chain_and_gate.clear ();
+
+  if (h) {
+    std::vector<LRAT_ID> reasons_lrat_src, reasons_lrat_usrc;
+    if (internal->lrat)
+      merge_and_gate_lrat_produce_lrat (g, h, reasons_lrat_src,
+                                        reasons_lrat_usrc);
+    if (merge_literals_lrat (g, h, lhs, h->lhs, reasons_lrat_src,
+                             reasons_lrat_usrc)) {
+      LOG ("found merged literals");
+      ++internal->stats.congruence.ands;
+    }
+    return nullptr;
+  } else {
+    g->rhs = {rhs};
+    CADICAL_assert (!internal->lrat ||
+            g->pos_lhs_ids.size () ==
+                g->arity ()); // otherwise we need intermediate clauses
+    g->garbage = false;
+    g->indexed = true;
+    g->shrunken = false;
+    g->hash = hash_lits (nonces, g->rhs);
+
+    table.insert (g);
+    ++internal->stats.congruence.gates;
+#ifdef LOGGING
+    g->id = fresh_id++;
+#endif
+    LOG (g, "creating new");
+    for (auto lit : g->rhs) {
+      connect_goccs (g, lit);
+    }
+  }
+  return g;
+}
+
+Gate *Closure::find_first_and_gate (Clause *base_clause, int lhs) {
+  CADICAL_assert (internal->analyzed.empty ());
+  const int not_lhs = -lhs;
+  LOG ("trying to find AND gate with first LHS %d", (lhs));
+  LOG ("negated LHS %d occurs in %zd binary clauses", (not_lhs),
+       internal->occs (not_lhs).size ());
+  unsigned matched = 0;
+
+  const size_t arity = lits.size () - 1;
+
+  for (auto w : internal->watches (not_lhs)) {
+    LOG (w.clause, "checking clause for candidates");
+    CADICAL_assert (w.binary ());
+    CADICAL_assert (w.clause->size == 2);
+    CADICAL_assert (w.clause->literals[0] == -lhs || w.clause->literals[1] == -lhs);
+    const int other = w.blit;
+    signed char &mark = marked (other);
+    if (mark) {
+      LOG ("marking %d mu2", other);
+      ++matched;
+      CADICAL_assert (~(mark & 2));
+      mark |= 2;
+      internal->analyzed.push_back (other);
+      set_mu2_reason (other, w.clause);
+      if (internal->lrat)
+        lrat_chain_and_gate.push_back (LitClausePair (other, w.clause));
+    }
+  }
+
+  LOG ("found %zd initial LHS candidates", internal->analyzed.size ());
+  if (matched < arity) {
+    if (internal->lrat)
+      lrat_chain_and_gate.clear ();
+    return nullptr;
+  }
+
+  Gate *g = new_and_gate (base_clause, lhs);
+
+  if (internal->lrat) {
+    lrat_chain_and_gate.clear ();
+  }
+  return g;
+}
+
+Clause *Closure::learn_binary_tmp_or_full_clause (int a, int b) {
+  Clause *eq1;
+  if (internal->lrat) {
+    eq1 = add_tmp_binary_clause (a, b);
+    eq1 = maybe_promote_tmp_binary_clause (eq1);
+  } else
+    eq1 = maybe_add_binary_clause (a, b);
+  return eq1;
+}
+
+Clause *Closure::maybe_add_binary_clause (int a, int b) {
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (internal->lrat_chain.empty ());
+  CADICAL_assert (!internal->lrat);
+  CADICAL_assert (lrat_chain.empty ());
+  LOG ("learning binary clause %d %d", a, b);
+  if (internal->unsat)
+    return nullptr;
+  if (a == -b)
+    return nullptr;
+  if (!internal->lrat) {
+    const signed char a_value = internal->val (a);
+    if (a_value > 0)
+      return nullptr;
+    const signed char b_value = internal->val (b);
+    if (b_value > 0)
+      return nullptr;
+    int unit = 0;
+    if (a == b)
+      unit = a;
+    else if (a_value < 0 && !b_value) {
+      unit = b;
+    } else if (!a_value && b_value < 0)
+      unit = a;
+    if (unit) {
+      LOG ("clause reduced to unit %d", unit);
+      learn_congruence_unit (unit);
+      return nullptr;
+    }
+    CADICAL_assert (!a_value), CADICAL_assert (!b_value);
+  }
+  return add_binary_clause (a, b);
+}
+
+Clause *Closure::add_binary_clause (int a, int b) {
+  CADICAL_assert (internal->clause.empty ());
+  internal->clause.push_back (a);
+  internal->clause.push_back (b);
+  if (internal->lrat) {
+    CADICAL_assert (lrat_chain.size () >= 1);
+    CADICAL_assert (internal->lrat_chain.empty ());
+    swap (internal->lrat_chain, lrat_chain);
+  }
+  LOG (internal->lrat_chain, "chain");
+  Clause *res = internal->new_hyper_ternary_resolved_clause_and_watch (
+      false, full_watching);
+  const bool already_sorted = internal->vlit (a) < internal->vlit (b);
+  binaries.push_back (CompactBinary (res, res->id, already_sorted ? a : b,
+                                     already_sorted ? b : a));
+  if (!full_watching)
+    new_unwatched_binary_clauses.push_back (res);
+  LOG (res, "learning clause");
+  internal->clause.clear ();
+  if (internal->lrat) {
+    internal->lrat_chain.clear ();
+  }
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (internal->lrat_chain.empty ());
+  return res;
+}
+
+void Closure::check_not_tmp_binary_clause (Clause *c) {
+#ifndef CADICAL_NDEBUG
+  CADICAL_assert (internal->lrat);
+  CADICAL_assert (internal->lrat_chain.empty ());
+  CADICAL_assert (c->size == 2);
+  if (internal->val (c->literals[0]) || internal->val (c->literals[1]))
+    return;
+  CADICAL_assert (std::find (begin (extra_clauses), end (extra_clauses), c) ==
+          end (extra_clauses));
+#else
+  (void) c;
+#endif
+};
+
+Clause *Closure::maybe_promote_tmp_binary_clause (Clause *c) {
+  CADICAL_assert (internal->lrat);
+  CADICAL_assert (internal->lrat_chain.empty ());
+  CADICAL_assert (c->size == 2);
+  LOG (c, "promoting tmp");
+#ifndef CADICAL_NDEBUG
+  CADICAL_assert (std::find (begin (extra_clauses), end (extra_clauses), c) !=
+          end (extra_clauses));
+#endif
+  if (internal->val (c->literals[0]) || internal->val (c->literals[1]))
+    return c;
+  lrat_chain.push_back (c->id);
+  Clause *res = add_binary_clause (c->literals[0], c->literals[1]);
+  LOG (res, "promoted to");
+  return res;
+};
+
+Clause *Closure::add_tmp_binary_clause (int a, int b) {
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (internal->lrat_chain.empty ());
+  CADICAL_assert (internal->lrat);
+  LOG ("learning tmp binary clause %d %d", a, b);
+  if (internal->unsat)
+    return nullptr;
+  if (a == -b)
+    return nullptr;
+  CADICAL_assert (internal->clause.empty ());
+  internal->clause.push_back (a);
+  internal->clause.push_back (b);
+  if (internal->lrat) {
+    CADICAL_assert (lrat_chain.size () >= 1);
+    CADICAL_assert (internal->lrat_chain.empty ());
+  }
+  LOG (lrat_chain, "chain");
+  Clause *res = new_tmp_clause (internal->clause);
+  internal->clause.clear ();
+  if (internal->lrat) {
+    lrat_chain.clear ();
+  }
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (internal->lrat_chain.empty ());
+  LOG (res, "promoted to");
+  return res;
+}
+
+Gate *Closure::find_remaining_and_gate (Clause *base_clause, int lhs) {
+  const int not_lhs = -lhs;
+
+  if (marked (not_lhs) < 2) {
+    LOG ("skipping no-candidate LHS %d (%d)", lhs, marked (not_lhs));
+    return nullptr;
+  }
+
+  LOG ("trying to find AND gate with remaining LHS %d", (lhs));
+  LOG ("negated LHS %d occurs times in %zd binary clauses", (not_lhs),
+       internal->noccs (-lhs));
+
+  const size_t arity = lits.size () - 1;
+  size_t matched = 0;
+  CADICAL_assert (1 < arity);
+
+  for (auto w : internal->watches (not_lhs)) {
+    CADICAL_assert (w.binary ());
+#ifdef LOGGING
+    Clause *c = w.clause;
+    LOG (c, "checking");
+    CADICAL_assert (c->size == 2);
+    CADICAL_assert (c->literals[0] == not_lhs || c->literals[1] == not_lhs);
+#endif
+    const int other = w.blit;
+    signed char &mark = marked (other);
+    if (!mark)
+      continue;
+    ++matched;
+    if (!(mark & 2)) {
+      lrat_chain_and_gate.push_back (LitClausePair (other, w.clause));
+      LOG ("pushing %d -> %zd", other, w.clause->id);
+      continue;
+    }
+    LOG ("marking %d mu4", other);
+    CADICAL_assert (!(mark & 4));
+    mark |= 4;
+    lrat_chain_and_gate.push_back (LitClausePair (other, w.clause));
+    if (internal->lrat)
+      set_mu4_reason (other, w.clause);
+  }
+
+  {
+    auto q = begin (internal->analyzed);
+    CADICAL_assert (!internal->analyzed.empty ());
+    CADICAL_assert (marked (not_lhs) == 3);
+    for (auto lit : internal->analyzed) {
+      signed char &mark = marked (lit);
+      if (lit == not_lhs) {
+        mark = 1;
+        continue;
+      }
+
+      CADICAL_assert ((mark & 3) == 3);
+      if (mark & 4) {
+        mark = 3;
+        *q = lit;
+        ++q;
+        LOG ("keeping LHS candidate %d", -lit);
+      } else {
+        LOG ("dropping LHS candidate %d", -lit);
+        mark = 1;
+      }
+    }
+    CADICAL_assert (q != end (internal->analyzed));
+    CADICAL_assert (marked (not_lhs) == 1);
+    internal->analyzed.resize (q - begin (internal->analyzed));
+    LOG ("after filtering %zu LHS candidate remain",
+         internal->analyzed.size ());
+  }
+
+  if (matched < arity) {
+    if (internal->lrat)
+      lrat_chain_and_gate.clear ();
+    return nullptr;
+  }
+
+  if (!internal->lrat)
+    lrat_chain_and_gate.clear ();
+  return new_and_gate (base_clause, lhs);
+}
+
+struct congruence_occurrences_rank {
+  Internal *internal;
+  congruence_occurrences_rank (Internal *s) : internal (s) {}
+  typedef uint64_t Type;
+  Type operator() (int a) {
+    uint64_t res = internal->noccs (-a);
+    res <<= 32;
+    res |= a;
+    return res;
+  }
+};
+
+struct congruence_occurrences_larger {
+  Internal *internal;
+  congruence_occurrences_larger (Internal *s) : internal (s) {}
+  bool operator() (const int &a, const int &b) const {
+    return congruence_occurrences_rank (internal) (a) <
+           congruence_occurrences_rank (internal) (b);
+  }
+};
+
+void Closure::extract_and_gates_with_base_clause (Clause *c) {
+  CADICAL_assert (!c->garbage);
+  CADICAL_assert (lrat_chain.empty ());
+  LOG (c, "extracting and gates with clause");
+  unsigned size = 0;
+  const unsigned arity_limit =
+      min (internal->opts.congruenceandarity, MAX_ARITY);
+  const unsigned size_limit = arity_limit + 1;
+  size_t max_negbincount = 0;
+  lits.clear ();
+
+  for (int lit : *c) {
+    signed char v = internal->val (lit);
+    if (v < 0) {
+      // push_lrat_unit (-lit);
+      continue;
+    }
+    if (v > 0) {
+      CADICAL_assert (!internal->level);
+      LOG (c, "found satisfied clause");
+      internal->mark_garbage (c);
+      if (internal->lrat)
+        lrat_chain.clear ();
+      return;
+    }
+    if (++size > size_limit) {
+      LOG (c, "clause is actually too large, thus skipping");
+      if (internal->lrat)
+        lrat_chain.clear ();
+      return;
+    }
+    const size_t count = internal->noccs (-lit);
+    if (!count) {
+      LOG (c,
+           "%d negated does not occur in any binary clause, thus skipping",
+           lit);
+      if (internal->lrat)
+        lrat_chain.clear ();
+      return;
+    }
+
+    if (count > max_negbincount)
+      max_negbincount = count;
+    lits.push_back (lit);
+  }
+
+  if (size < 3) {
+    LOG (c, "is actually too small, thus skipping");
+    if (internal->lrat)
+      lrat_chain.clear ();
+    CADICAL_assert (lrat_chain.empty ());
+    return;
+  }
+
+  const size_t arity = size - 1;
+  if (max_negbincount < arity) {
+    LOG (c,
+         "all literals have less than %lu negated occurrences"
+         "thus skipping",
+         arity);
+    if (internal->lrat)
+      lrat_chain.clear ();
+    return;
+  }
+
+  internal->analyzed.clear ();
+  size_t reduced = 0;
+  const size_t clause_size = lits.size ();
+  for (size_t i = 0; i < clause_size; ++i) {
+    const int lit = lits[i];
+    const unsigned count = internal->noccs (-lit);
+    marked (-lit) = 1;
+    set_mu1_reason (-lit, c);
+    if (count < arity) {
+      if (reduced < i) {
+        lits[i] = lits[reduced];
+        lits[reduced++] = lit;
+      } else if (reduced == i)
+        ++reduced;
+    }
+  }
+  const size_t reduced_size = clause_size - reduced;
+  CADICAL_assert (reduced_size);
+  LOG (c, "trying as base arity %lu AND gate", arity);
+  CADICAL_assert (begin (lits) + reduced_size <= end (lits));
+  MSORT (internal->opts.radixsortlim, begin (lits),
+         begin (lits) + reduced_size,
+         congruence_occurrences_rank (internal),
+         congruence_occurrences_larger (internal));
+  bool first = true;
+  unsigned extracted = 0;
+
+  for (size_t i = 0; i < clause_size; ++i) {
+    CADICAL_assert (lrat_chain.empty ());
+    if (internal->unsat)
+      break;
+    if (c->garbage)
+      break;
+    const int lhs = lits[i];
+    LOG ("trying LHS candidate literal %d with %ld negated occurrences",
+         (lhs), internal->noccs (-lhs));
+
+    if (first) {
+      first = false;
+      CADICAL_assert (internal->analyzed.empty ());
+      if (find_first_and_gate (c, lhs) != nullptr) {
+        CADICAL_assert (lrat_chain.empty ());
+        ++extracted;
+      }
+    } else if (internal->analyzed.empty ()) {
+      LOG ("early abort AND gate search");
+      break;
+    } else if (find_remaining_and_gate (c, lhs)) {
+      CADICAL_assert (lrat_chain.empty ());
+      ++extracted;
+    }
+  }
+
+  unmark_all ();
+  LOG (lits, "finish unmarking");
+  for (auto lit : lits) {
+    marked (-lit) = 0;
+  }
+  lrat_chain_and_gate.clear ();
+  if (extracted)
+    LOG (c, "extracted %u with arity %lu AND base", extracted, arity);
+}
+
+void Closure::reset_and_gate_extraction () {
+  internal->clear_noccs ();
+  internal->clear_watches ();
+}
+
+void Closure::extract_and_gates () {
+  CADICAL_assert (!full_watching);
+  if (!internal->opts.congruenceand)
+    return;
+  START (extractands);
+  marks.resize (internal->max_var * 2 + 3);
+  init_and_gate_extraction ();
+
+  const size_t size = internal->clauses.size ();
+  for (size_t i = 0; i < size && !internal->terminated_asynchronously ();
+       ++i) { // we can learn new binary clauses, but no for loop
+    CADICAL_assert (lrat_chain.empty ());
+    Clause *c = internal->clauses[i];
+    if (c->garbage)
+      continue;
+    if (c->size == 2)
+      continue;
+    if (c->hyper)
+      continue;
+    if (c->redundant)
+      continue;
+    extract_and_gates_with_base_clause (c);
+    CADICAL_assert (lrat_chain.empty ());
+  }
+
+  reset_and_gate_extraction ();
+  STOP (extractands);
+}
+
+/*------------------------------------------------------------------------*/
+// XOR gates
+
+uint64_t &Closure::new_largecounts (int lit) {
+  CADICAL_assert (internal->vlit (lit) < gnew_largecounts.size ());
+  return gnew_largecounts[internal->vlit (lit)];
+}
+
+uint64_t &Closure::largecounts (int lit) {
+  CADICAL_assert (internal->vlit (lit) < glargecounts.size ());
+  return glargecounts[internal->vlit (lit)];
+}
+
+bool parity_lits (const vector<int> &lits) {
+  unsigned res = 0;
+  for (auto lit : lits)
+    res ^= (lit < 0);
+  return res;
+}
+
+void inc_lits (vector<int> &lits) {
+  bool carry = true;
+  for (size_t i = 0; i < lits.size () && carry; ++i) {
+    int lit = lits[i];
+    carry = (lit < 0);
+    lits[i] = -lit;
+  }
+}
+
+void Closure::check_ternary (int a, int b, int c) {
+  CADICAL_assert (internal->clause.empty ());
+  if (internal->lrat)
+    return;
+  auto &clause = internal->clause;
+  CADICAL_assert (clause.empty ());
+  clause.push_back (a);
+  clause.push_back (b);
+  clause.push_back (c);
+  internal->external->check_learned_clause ();
+  if (internal->proof) {
+    const LRAT_ID id = internal->clause_id++;
+    internal->proof->add_derived_clause (id, false, clause, {});
+    internal->proof->delete_clause (id, false, clause);
+  }
+
+  clause.clear ();
+}
+
+void Closure::check_binary_implied (int a, int b) {
+  CADICAL_assert (internal->clause.empty ());
+  if (internal->lrat)
+    return;
+  auto &clause = internal->clause;
+  CADICAL_assert (clause.empty ());
+  clause.push_back (a);
+  clause.push_back (b);
+  check_implied ();
+  clause.clear ();
+}
+
+void Closure::check_implied () {
+  if (internal->lrat)
+    return;
+  internal->external->check_learned_clause ();
+}
+
+void Closure::add_xor_shrinking_proof_chain (Gate *g, int pivot) {
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (clause.empty ());
+  if (!internal->proof)
+    return;
+  LOG (g, "starting XOR shrinking proof chain");
+  vector<LitClausePair> first;
+  vector<LitClausePair> newclauses;
+  if (internal->lrat) {
+    simplify_and_sort_xor_lrat_clauses (g->pos_lhs_ids, first, g->lhs,
+                                        pivot);
+    gate_sort_lrat_reasons (first, pivot, g->lhs);
+  }
+
+  auto &clause = internal->clause;
+
+  const int lhs = g->lhs;
+  clause.push_back (-lhs);
+  for (auto lit : g->rhs)
+    clause.push_back (lit);
+
+  const bool parity = (lhs > 0);
+  CADICAL_assert (parity == parity_lits (clause));
+  const size_t size = clause.size ();
+  const unsigned end = 1u << (size - 1);
+  CADICAL_assert (!internal->lrat || first.size () == 2 * end);
+#ifdef LOGGING
+  for (auto pair : first) {
+    LOG (pair.clause, "key %d", pair.current_lit);
+  }
+#endif
+  // TODO Florian adjust indices of first depending on order...
+  //
+  for (unsigned i = 0; i != end; ++i) {
+    while (i && parity != parity_lits (clause))
+      inc_lits (clause);
+    LOG (clause, "xor shrinking clause");
+    if (!internal->lrat) {
+      clause.push_back (pivot);
+      check_and_add_to_proof_chain (clause);
+      clause.pop_back ();
+      clause.push_back (-pivot);
+      check_and_add_to_proof_chain (clause);
+      clause.pop_back ();
+    }
+    if (internal->lrat) {
+      CADICAL_assert (lrat_chain.empty ());
+      lrat_chain.push_back (first[2 * i].clause->id);
+      lrat_chain.push_back (first[2 * i + 1].clause->id);
+    }
+    if (clause.size () > 1) {
+      if (internal->lrat) {
+        Clause *c = new_tmp_clause (clause);
+        newclauses.push_back (LitClausePair (0, c));
+        lrat_chain.clear ();
+      } else {
+        check_and_add_to_proof_chain (clause);
+      }
+    }
+    if (clause.size () == 1)
+      return;
+    inc_lits (clause);
+  }
+  g->pos_lhs_ids.swap (newclauses);
+
+  clause.clear ();
+}
+
+void Closure::check_xor_gate_implied (Gate const *const g) {
+  CADICAL_assert (internal->clause.empty ());
+  CADICAL_assert (g->tag == Gate_Type::XOr_Gate);
+  if (internal->lrat) {
+    return;
+  }
+  const int lhs = g->lhs;
+  LOG (g, "checking implied");
+  auto &clause = internal->clause;
+  CADICAL_assert (clause.empty ());
+  for (auto other : g->rhs) {
+    CADICAL_assert (other > 0);
+    clause.push_back (other);
+  }
+  clause.push_back (-lhs);
+  const unsigned arity = g->arity ();
+  const unsigned end = 1u << arity;
+  const bool parity = (lhs > 0);
+
+  for (unsigned i = 0; i != end; ++i) {
+    while (i && parity_lits (clause) != parity)
+      inc_lits (clause);
+    internal->external->check_learned_clause ();
+    if (internal->proof) {
+      internal->proof->add_derived_clause (internal->clause_id, false,
+                                           clause, {});
+      internal->proof->delete_clause (internal->clause_id, false, clause);
+    }
+    inc_lits (clause);
+  }
+  clause.clear ();
+}
+
+Gate *Closure::find_xor_lits (const vector<int> &rhs) {
+  CADICAL_assert (is_sorted (begin (rhs), end (rhs),
+                     sort_literals_by_var_smaller (internal)));
+  return find_gate_lits (rhs, Gate_Type::XOr_Gate);
+}
+
+Gate *Closure::find_xor_gate (Gate *g) {
+  CADICAL_assert (g->tag == Gate_Type::XOr_Gate);
+  CADICAL_assert (is_sorted (begin (g->rhs), end (g->rhs),
+                     sort_literals_by_var_smaller (internal)));
+  return find_gate_lits (g->rhs, Gate_Type::XOr_Gate);
+}
+
+void Closure::reset_xor_gate_extraction () { internal->clear_occs (); }
+
+bool Closure::normalize_ite_lits_gate (Gate *g) {
+  auto &rhs = g->rhs;
+  CADICAL_assert (rhs.size () == 3);
+  if (internal->lrat)
+    check_correct_ite_flags (g);
+  LOG (rhs, "RHS = ");
+  if (rhs[0] < 0) {
+    rhs[0] = -rhs[0];
+    std::swap (rhs[1], rhs[2]);
+    if (internal->lrat) {
+      CADICAL_assert (g->pos_lhs_ids.size () == 4);
+      std::swap (g->pos_lhs_ids[0], g->pos_lhs_ids[2]);
+      std::swap (g->pos_lhs_ids[1], g->pos_lhs_ids[3]);
+      const int8_t flag = g->degenerated_ite;
+      const int8_t plus_then = flag & NO_PLUS_THEN;
+      const int8_t neg_then = flag & NO_NEG_THEN;
+      const int8_t plus_else = flag & NO_PLUS_ELSE;
+      const int8_t neg_else = flag & NO_NEG_ELSE;
+      g->degenerated_ite = (plus_then ? Special_ITE_GATE::NO_PLUS_ELSE
+                                      : Special_ITE_GATE::NORMAL) |
+                           (neg_then ? Special_ITE_GATE::NO_NEG_ELSE
+                                     : Special_ITE_GATE::NORMAL) |
+                           (plus_else ? Special_ITE_GATE::NO_PLUS_THEN
+                                      : Special_ITE_GATE::NORMAL) |
+                           (neg_else ? Special_ITE_GATE::NO_NEG_THEN
+                                     : Special_ITE_GATE::NORMAL);
+      CADICAL_assert (g->pos_lhs_ids[0].current_lit == rhs[1]);
+      CADICAL_assert (g->pos_lhs_ids[2].current_lit == rhs[2]);
+      if (internal->lrat)
+        check_correct_ite_flags (g);
+    }
+  }
+  if (rhs[1] > 0)
+    return false;
+  if (internal->lrat)
+    check_correct_ite_flags (g);
+  rhs[1] = -rhs[1];
+  rhs[2] = -rhs[2];
+  LOG (rhs, "RHS = ");
+  if (internal->lrat) {
+    CADICAL_assert (g->pos_lhs_ids.size () == 4);
+    std::swap (g->pos_lhs_ids[0], g->pos_lhs_ids[1]);
+    std::swap (g->pos_lhs_ids[2], g->pos_lhs_ids[3]);
+    const int8_t flag = g->degenerated_ite;
+    const int8_t plus_then = flag & NO_PLUS_THEN;
+    const int8_t neg_then = flag & NO_NEG_THEN;
+    const int8_t plus_else = flag & NO_PLUS_ELSE;
+    const int8_t neg_else = flag & NO_NEG_ELSE;
+    g->degenerated_ite = (plus_then ? Special_ITE_GATE::NO_NEG_THEN
+                                    : Special_ITE_GATE::NORMAL) |
+                         (neg_then ? Special_ITE_GATE::NO_PLUS_THEN
+                                   : Special_ITE_GATE::NORMAL) |
+                         (plus_else ? Special_ITE_GATE::NO_NEG_ELSE
+                                    : Special_ITE_GATE::NORMAL) |
+                         (neg_else ? Special_ITE_GATE::NO_PLUS_ELSE
+                                   : Special_ITE_GATE::NORMAL);
+    CADICAL_assert (g->pos_lhs_ids[0].current_lit == rhs[1]);
+    CADICAL_assert (g->pos_lhs_ids[2].current_lit == rhs[2]);
+    // incorrect as we have not negated the LHS yet!
+    // check_correct_ite_flags (g);
+  }
+
+  LOG (g->rhs, "g/RHS = ");
+  return true;
+}
+
+#ifndef CADICAL_NDEBUG
+bool is_tautological_ite_gate (Gate *g) {
+  CADICAL_assert (g->tag == Gate_Type::ITE_Gate);
+  CADICAL_assert (g->rhs.size () == 3);
+  const int cond_lit = g->rhs[0];
+  const int then_lit = g->rhs[1];
+  const int else_lit = g->rhs[2];
+  return cond_lit == then_lit || cond_lit == else_lit;
+}
+#endif
+
+Gate *Closure::find_ite_gate (Gate *g, bool &negate_lhs) {
+  negate_lhs = normalize_ite_lits_gate (g);
+  LOG (g, "post normalize");
+  return find_gate_lits (g->rhs, Gate_Type::ITE_Gate, g);
+}
+
+LRAT_ID Closure::check_and_add_to_proof_chain (vector<int> &clause) {
+  internal->external->check_learned_clause ();
+  const LRAT_ID id = ++internal->clause_id;
+  if (internal->proof) {
+    if (internal->lrat) {
+      CADICAL_assert (internal->lrat_chain.empty ());
+      CADICAL_assert (lrat_chain.size () >= 1);
+    }
+    internal->proof->add_derived_clause (id, true, clause, lrat_chain);
+    lrat_chain.clear ();
+  }
+  return id;
+}
+
+void Closure::add_clause_to_chain (std::vector<int> unsimplified,
+                                   LRAT_ID id) {
+  const uint32_t id2_higher = (id >> 32);
+  const uint32_t id2_lower = (uint32_t) (id & (LRAT_ID) (uint32_t) (-1));
+  CADICAL_assert (id == ((LRAT_ID) id2_higher << 32) + (LRAT_ID) id2_lower);
+  chain.push_back (id2_higher);
+  chain.push_back (id2_lower);
+  LOG (unsimplified, "pushing to chain");
+  chain.insert (end (chain), begin (unsimplified), end (unsimplified));
+  chain.push_back (0);
+}
+
+LRAT_ID Closure::simplify_and_add_to_proof_chain (vector<int> &unsimplified,
+                                                  LRAT_ID delete_id) {
+  vector<int> &clause = internal->clause;
+  CADICAL_assert (clause.empty ());
+#ifndef CADICAL_NDEBUG
+  for (auto lit : unsimplified) {
+    CADICAL_assert (!(marked (lit) & 4));
+  }
+#endif
+
+  bool trivial = false;
+  for (auto lit : unsimplified) {
+    signed char &lit_mark = marked (lit);
+    if (lit_mark & 4)
+      continue;
+    signed char &not_lit_mark = marked (-lit);
+    if (not_lit_mark & 4) {
+      trivial = true;
+      break;
+    }
+    lit_mark |= 4;
+    clause.push_back (lit);
+  }
+  for (auto lit : clause) {
+    signed char &mark = marked (lit);
+    CADICAL_assert (mark & 4);
+    mark &= ~4u;
+  }
+
+  LRAT_ID id = 0;
+  if (!trivial) {
+    if (delete_id) {
+      if (internal->proof) {
+        internal->proof->delete_clause (delete_id, true, clause);
+        lrat_chain.clear ();
+      }
+    } else {
+      id = check_and_add_to_proof_chain (clause);
+      add_clause_to_chain (clause, id);
+    }
+  } else {
+    LOG ("skipping trivial proof");
+    lrat_chain.clear ();
+  }
+  clause.clear ();
+  return id;
+}
+/*------------------------------------------------------------------------*/
+void Closure::add_ite_turned_and_binary_clauses (Gate *g) {
+  if (!internal->proof)
+    return;
+  if (internal->lrat)
+    return;
+  LOG ("starting ITE turned AND supporting binary clauses");
+  CADICAL_assert (unsimplified.empty ());
+  CADICAL_assert (chain.empty ());
+  int not_lhs = -g->lhs;
+  unsimplified.push_back (not_lhs);
+  unsimplified.push_back (g->rhs[0]);
+  simplify_and_add_to_proof_chain (unsimplified);
+  unsimplified.pop_back ();
+  unsimplified.push_back (g->rhs[1]);
+  simplify_and_add_to_proof_chain (unsimplified);
+  unsimplified.clear ();
+}
+void Closure::simplify_unit_xor_lrat_clauses (
+    const vector<LitClausePair> &source, int lhs) {
+  CADICAL_assert (internal->lrat);
+  for (auto pair : source) {
+    compute_rewritten_clause_lrat_simple (pair.clause, lhs);
+    if (lrat_chain.size ())
+      break;
+  }
+  CADICAL_assert (clause.size () == 1);
+}
+void Closure::simplify_and_sort_xor_lrat_clauses (
+    const vector<LitClausePair> &source, vector<LitClausePair> &target,
+    int lhs, int except2, bool flip) {
+  CADICAL_assert (internal->lrat);
+  for (auto pair : source) {
+    Clause *c = produce_rewritten_clause_lrat (pair.clause, lhs);
+    if (c) {
+      target.push_back (LitClausePair (0, c));
+    }
+  }
+  gate_sort_lrat_reasons (target, lhs, except2, flip);
+}
+void Closure::add_xor_matching_proof_chain (
+    Gate *g, int lhs1, const vector<LitClausePair> &clauses2, int lhs2,
+    vector<LRAT_ID> &to_lrat, vector<LRAT_ID> &back_lrat) {
+  if (lhs1 == lhs2)
+    return;
+  if (!internal->proof)
+    return;
+  CADICAL_assert (unsimplified.empty ());
+  unsimplified = g->rhs;
+  vector<LitClausePair> first;
+  vector<LitClausePair> second;
+  if (internal->lrat) {
+    simplify_and_sort_xor_lrat_clauses (g->pos_lhs_ids, first, lhs1);
+    simplify_and_sort_xor_lrat_clauses (clauses2, second, lhs2, 0, 1);
+    g->pos_lhs_ids = first;
+  }
+  LOG ("starting XOR matching proof");
+  // for lrat
+  vector<LitIdPair> first_ids;
+  vector<LitIdPair> second_ids;
+  for (auto pair : first) {
+    bool first = pair.current_lit & 1;
+    int rest = pair.current_lit >> 1;
+    rest &= ~(1 << (g->rhs.size () - 1));
+    if (first == (lhs1 > 0)) {
+      first_ids.push_back (LitIdPair (rest, pair.clause->id));
+    } else {
+      second_ids.push_back (LitIdPair (rest, pair.clause->id));
+    }
+    LOG (pair.clause, "key %d", pair.current_lit);
+  }
+  for (auto pair : second) {
+    bool first = pair.current_lit & 1;
+    int rest = pair.current_lit >> 1;
+    rest &= ~(1 << (g->rhs.size () - 1));
+    if (first == (lhs2 < 0)) {
+      first_ids.push_back (LitIdPair (rest, pair.clause->id));
+    } else {
+      second_ids.push_back (LitIdPair (rest, pair.clause->id));
+    }
+    LOG (pair.clause, "key %d", pair.current_lit);
+  }
+  // TODO Florian: resort and ids after every round
+  do {
+    vector<LitIdPair> first_tmp;
+    vector<LitIdPair> second_tmp;
+    CADICAL_assert (!unsimplified.empty ());
+    unsimplified.pop_back ();
+    const size_t size = unsimplified.size ();
+    CADICAL_assert (size < 32);
+    const size_t off = 1u << size;
+    for (size_t i = 0; i != off; ++i) {
+      int32_t n = 0;
+      if (internal->lrat) {
+        n = number_from_xor_reason_reversed (unsimplified);
+        CADICAL_assert (lrat_chain.empty ());
+        for (auto pair : first_ids) {
+          if (pair.lit == n)
+            lrat_chain.push_back (pair.id);
+        }
+        CADICAL_assert (lrat_chain.size () == 2);
+      }
+      unsimplified.push_back (-lhs1);
+      unsimplified.push_back (lhs2);
+      const LRAT_ID id1 = simplify_and_add_to_proof_chain (unsimplified);
+      unsimplified.resize (unsimplified.size () - 2);
+      if (internal->lrat) {
+        int32_t rest = n &= ~(1 << (unsimplified.size () - 1));
+        first_tmp.push_back (LitIdPair (rest, id1));
+        n = number_from_xor_reason_reversed (unsimplified);
+        lrat_chain.clear ();
+        for (auto pair : second_ids) {
+          if (pair.lit == n)
+            lrat_chain.push_back (pair.id);
+        }
+        CADICAL_assert (lrat_chain.size () == 2);
+      }
+      unsimplified.push_back (lhs1);
+      unsimplified.push_back (-lhs2);
+      const LRAT_ID id2 = simplify_and_add_to_proof_chain (unsimplified);
+      unsimplified.resize (unsimplified.size () - 2);
+      if (internal->lrat) {
+        lrat_chain.clear ();
+        int32_t rest = n &= ~(1 << (unsimplified.size () - 1));
+        second_tmp.push_back (LitIdPair (rest, id2));
+      }
+      inc_lits (unsimplified);
+    }
+    if (internal->lrat) {
+      first_ids.swap (first_tmp);
+      second_ids.swap (second_tmp);
+    }
+  } while (!unsimplified.empty ());
+  if (internal->lrat) {
+    CADICAL_assert (first_ids.size () == 1);
+    CADICAL_assert (second_ids.size () == 1);
+    to_lrat.push_back (first_ids.back ().id);
+    back_lrat.push_back (second_ids.back ().id);
+  }
+  CADICAL_assert (!internal->lrat || to_lrat.size () == 1);
+  CADICAL_assert (!internal->lrat || back_lrat.size () == 1);
+  LOG ("finished XOR matching proof");
+  CADICAL_assert (unsimplified.empty ());
+}
+
+// this function needs to either put the clauses from
+// lrat_chain_and_gate into g->pos_neg_ids or clear it or do something with
+// it if you merge gates.
+Gate *Closure::new_xor_gate (const vector<LitClausePair> &glauses,
+                             int lhs) {
+  rhs.clear ();
+
+  for (auto lit : lits) {
+    if (lhs != lit && -lhs != lit) {
+      CADICAL_assert (lit > 0);
+      rhs.push_back (lit);
+    }
+  }
+  CADICAL_assert (rhs.size () + 1 == lits.size ());
+  sort_literals_by_var (rhs);
+  Gate *g = find_xor_lits (this->rhs);
+  if (g) {
+    check_xor_gate_implied (g);
+    std::vector<LRAT_ID> reasons_implication, reasons_back;
+    add_xor_matching_proof_chain (g, g->lhs, glauses, lhs,
+                                  reasons_implication, reasons_back);
+    if (merge_literals_lrat (g->lhs, lhs, reasons_implication,
+                             reasons_back)) {
+      ++internal->stats.congruence.xors;
+    }
+    delete_proof_chain ();
+    CADICAL_assert (internal->unsat || chain.empty ());
+  } else {
+    g = new Gate;
+    g->lhs = lhs;
+    g->tag = Gate_Type::XOr_Gate;
+    g->rhs = {rhs};
+    g->garbage = false;
+    g->indexed = true;
+    g->shrunken = false;
+    g->hash = hash_lits (nonces, g->rhs);
+    for (auto pair : glauses)
+      g->pos_lhs_ids.push_back (pair);
+    table.insert (g);
+    ++internal->stats.congruence.gates;
+#ifdef LOGGING
+    g->id = fresh_id++;
+#endif
+    LOG (g, "creating new");
+    check_xor_gate_implied (g);
+    for (auto lit : g->rhs) {
+      connect_goccs (g, lit);
+    }
+  }
+  return g;
+}
+uint32_t
+Closure::number_from_xor_reason_reversed (const std::vector<int> &rhs) {
+  uint32_t n = 0;
+  CADICAL_assert (is_sorted (rhs.rbegin (), rhs.rend (),
+                     sort_literals_by_var_smaller_except (internal, 0, 0)));
+  CADICAL_assert (rhs.size () <= 32);
+  for (auto r = rhs.rbegin (); r != rhs.rend (); r++) {
+    int lit = *r;
+    n *= 2;
+    n += !(lit > 0);
+  }
+  return n;
+}
+
+uint32_t Closure::number_from_xor_reason (const std::vector<int> &rhs,
+                                          int lhs, int except, bool flip) {
+  uint32_t n = 0;
+  CADICAL_assert (is_sorted (
+      begin (rhs), end (rhs),
+      sort_literals_by_var_smaller_except (internal, lhs, except)));
+  (void) lhs, (void) except;
+  CADICAL_assert (rhs.size () <= 32);
+  for (auto lit : rhs) {
+    n *= 2;
+    n += !(lit > 0) ^ flip;
+    flip = 0;
+  }
+  return n;
+}
+
+// this is how I planned to sort it and produce the number
+// Look at this first
+void Closure::gate_sort_lrat_reasons (LitClausePair &litId, int lhs,
+                                      int except2, bool flip) {
+  CADICAL_assert (clause.empty ());
+  std::copy (begin (*litId.clause), end (*litId.clause),
+             back_inserter (clause));
+  sort_literals_by_var_except (clause, lhs, except2);
+  litId.current_lit = number_from_xor_reason (clause, lhs, except2, flip);
+  clause.clear ();
+}
+
+struct smaller_pair_first_rank {
+  typedef size_t Type;
+  Type operator() (const LitClausePair &a) { return a.current_lit; }
+};
+
+// this is how I planned to sort it and produce the number
+// Look at this first
+void Closure::gate_sort_lrat_reasons (std::vector<LitClausePair> &xs,
+                                      int lhs, int except2, bool flip) {
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (!xs.empty ());
+  for (auto &litId : xs) {
+    gate_sort_lrat_reasons (litId, lhs, except2, flip);
+  }
+
+  rsort (begin (xs), end (xs), smaller_pair_first_rank ());
+
+#ifndef CADICAL_NDEBUG
+  std::for_each (begin (xs), end (xs), [&xs] (const LitClausePair &x) {
+    CADICAL_assert (x.clause->size == xs[1].clause->size);
+  });
+#endif
+}
+
+void Closure::init_xor_gate_extraction (std::vector<Clause *> &candidates) {
+  const unsigned arity_limit = internal->opts.congruencexorarity;
+  CADICAL_assert (arity_limit < 32); // we use unsigned int.
+  const unsigned size_limit = arity_limit + 1;
+  glargecounts.resize (2 * internal->vsize, 0);
+
+  for (auto c : internal->clauses) {
+    LOG (c, "considering clause for XOR");
+    if (c->redundant)
+      continue;
+    if (c->garbage)
+      continue;
+    if (c->size < 3)
+      continue;
+    unsigned size = 0;
+    for (auto lit : *c) {
+      const signed char v = internal->val (lit);
+      if (v < 0)
+        continue;
+      if (v > 0) {
+        LOG (c, "satisfied by %d", lit);
+        internal->mark_garbage (c);
+        goto CONTINUE_COUNTING_NEXT_CLAUSE;
+      }
+      if (size == size_limit)
+        goto CONTINUE_COUNTING_NEXT_CLAUSE;
+      ++size;
+    }
+
+    if (size < 3)
+      continue;
+    for (auto lit : *c) {
+      if (internal->val (lit))
+        continue;
+      ++largecounts (lit);
+    }
+
+    LOG (c, "considering clause for XOR as candidate");
+    candidates.push_back (c);
+  CONTINUE_COUNTING_NEXT_CLAUSE:;
+  }
+
+  LOG ("considering %zd out of %zd", candidates.size (),
+       internal->irredundant ());
+  const unsigned rounds = internal->opts.congruencexorcounts;
+#ifdef LOGGING
+  const size_t original_size = candidates.size ();
+#endif
+  LOG ("resizing glargecounts to size %zd", glargecounts.size ());
+  for (unsigned round = 0; round < rounds; ++round) {
+    LOG ("round %d of XOR extraction", round);
+    size_t removed = 0;
+    gnew_largecounts.resize (2 * internal->vsize);
+    unsigned cand_size = candidates.size ();
+    size_t j = 0;
+    for (size_t i = 0; i < cand_size; ++i) {
+      Clause *c = candidates[i];
+      LOG (c, "considering");
+      unsigned size = 0;
+      for (auto lit : *c) {
+        if (!internal->val (lit))
+          ++size;
+      }
+      CADICAL_assert (3 <= size);
+      CADICAL_assert (size <= size_limit);
+      const unsigned arity = size - 1;
+      const unsigned needed_clauses = 1u << (arity - 1);
+      for (auto lit : *c) {
+        if (largecounts (lit) < needed_clauses) {
+          LOG (c, "not enough occurrences, so ignoring");
+          removed++;
+          goto CONTINUE_WITH_NEXT_CANDIDATE_CLAUSE;
+        }
+      }
+      for (auto lit : *c)
+        if (!internal->val (lit))
+          new_largecounts (lit)++;
+      candidates[j++] = candidates[i];
+
+    CONTINUE_WITH_NEXT_CANDIDATE_CLAUSE:;
+    }
+    candidates.resize (j);
+    glargecounts = std::move (gnew_largecounts);
+    gnew_largecounts.clear ();
+    LOG ("moving counts %zd", glargecounts.size ());
+    if (!removed)
+      break;
+
+    LOG ("after round %d, %zd (%ld %%) remain", round, candidates.size (),
+         candidates.size () / (1 + original_size) * 100);
+  }
+
+  for (auto c : candidates) {
+    for (auto lit : *c)
+      internal->occs (lit).push_back (c);
+  }
+}
+
+Clause *Closure::find_large_xor_side_clause (std::vector<int> &lits) {
+  unsigned least_occurring_literal = 0;
+  unsigned count_least_occurring = UINT_MAX;
+  const size_t size_lits = lits.size ();
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+  const unsigned arity = size_lits - 1;
+#endif
+#ifndef CADICAL_NDEBUG
+  const unsigned count_limit = 1u << (arity - 1);
+#endif
+  LOG (lits, "trying to find arity %u XOR side clause", arity);
+  for (auto lit : lits) {
+    CADICAL_assert (!internal->val (lit));
+    marked (lit) = 1;
+    unsigned count = largecount (lit);
+    CADICAL_assert (count_limit <= count);
+    if (count >= count_least_occurring)
+      continue;
+    count_least_occurring = count;
+    least_occurring_literal = lit;
+  }
+  Clause *res = 0;
+  CADICAL_assert (least_occurring_literal);
+  LOG ("searching XOR side clause watched by %d#%u",
+       least_occurring_literal, count_least_occurring);
+  LOG ("searching for size %ld", size_lits);
+  for (auto c : internal->occs (least_occurring_literal)) {
+    LOG (c, "checking");
+    CADICAL_assert (c->size != 2); // TODO kissat has break
+    if (c->garbage)
+      continue;
+    if ((size_t) c->size < size_lits)
+      continue;
+    size_t found = 0;
+    for (auto other : *c) {
+      const signed char value = internal->val (other);
+      if (value < 0)
+        continue;
+      if (value > 0) {
+        LOG (c, "found satisfied %d in", other);
+        internal->mark_garbage (c);
+        CADICAL_assert (c->garbage);
+        break;
+      }
+      if (marked (other))
+        found++;
+      else {
+        LOG ("not marked %d", other);
+        found = 0;
+        break;
+      }
+    }
+    if (found == size_lits && !c->garbage) {
+      res = c;
+      break;
+    } else {
+      LOG ("too few literals");
+    }
+  }
+  for (auto lit : lits)
+    marked (lit) = 0;
+  if (res)
+    LOG (res, "found matching XOR side");
+  else
+    LOG ("no matching XOR side clause found");
+  return res;
+}
+
+void Closure::extract_xor_gates_with_base_clause (Clause *c) {
+  LOG (c, "checking clause");
+  lits.clear ();
+  int smallest = 0;
+  int largest = 0;
+  const unsigned arity_limit = internal->opts.congruencexorarity;
+  const unsigned size_limit = arity_limit + 1;
+  unsigned negated = 0, size = 0;
+  bool first = true;
+  for (auto lit : *c) {
+    const signed char v = internal->val (lit);
+    if (v < 0)
+      continue;
+    if (v > 0) {
+      internal->mark_garbage (c);
+      return;
+    }
+    if (size == size_limit) {
+      LOG (c, "size limit reached");
+      return;
+    }
+
+    if (first) {
+      largest = smallest = lit;
+      first = false;
+    } else {
+      CADICAL_assert (smallest);
+      CADICAL_assert (largest);
+      if (internal->vlit (lit) < internal->vlit (smallest)) {
+        LOG ("new smallest %d", lit);
+        smallest = lit;
+      }
+      if (internal->vlit (lit) > internal->vlit (largest)) {
+        if (largest < 0) {
+          LOG (c, "not largest %d (largest: %d) occurs negated in XOR base",
+               lit, largest);
+          return;
+        }
+        largest = lit;
+      }
+    }
+    if (lit < 0 && internal->vlit (lit) < internal->vlit (largest)) {
+      LOG (c, "negated literal %d not largest in XOR base", lit);
+      return;
+    }
+    if (lit < 0 && negated++) {
+      LOG (c, "more than one negated literal in XOR base");
+      return;
+    }
+    lits.push_back (lit);
+    ++size;
+  }
+  CADICAL_assert (size == lits.size ());
+  if (size < 3) {
+    LOG (c, "short XOR base clause");
+    return;
+  }
+
+  LOG ("double checking if possible");
+  const unsigned arity = size - 1;
+  const unsigned needed_clauses = 1u << (arity - 1);
+  for (auto lit : lits) {
+    for (int sign = 0; sign != 2; ++sign, lit = -lit) {
+      unsigned count = largecount (lit);
+      if (count >= needed_clauses)
+        continue;
+      LOG (c,
+           "literal %d in XOR base clause only occurs %u times in large "
+           "clause thus skipping",
+           lit, count);
+      return;
+    }
+  }
+
+  LOG ("checking for XOR side clauses");
+  CADICAL_assert (smallest && largest);
+  const unsigned end = 1u << arity;
+  CADICAL_assert (negated == parity_lits (lits));
+  unsigned found = 0;
+  vector<LitClausePair> glauses;
+  glauses.push_back (LitClausePair (0, c));
+  for (unsigned i = 0; i != end; ++i) {
+    while (i && parity_lits (lits) != negated)
+      inc_lits (lits);
+    if (i) {
+      // the clause must be stored
+      // you can use `lrat_chain_and_gate` for this
+      Clause *d = find_large_xor_side_clause (lits);
+      if (!d)
+        return;
+      CADICAL_assert (!d->redundant);
+      glauses.push_back (LitClausePair (i, d));
+    } else
+      CADICAL_assert (!c->redundant);
+    inc_lits (lits);
+    ++found;
+  }
+
+  while (parity_lits (lits) != negated)
+    inc_lits (lits);
+  LOG (lits, "found all needed %u matching clauses:", found);
+  CADICAL_assert (found == 1u << arity);
+  if (negated) {
+    auto p = begin (lits);
+    int lit;
+    while ((lit = *p) > 0)
+      p++;
+    LOG ("flipping RHS literal %d", (lit));
+    *p = -lit;
+  }
+  LOG (lits, "normalized negations");
+  unsigned extracted = 0;
+  for (auto lhs : lits) {
+    if (!negated)
+      lhs = -lhs;
+    Gate *g = new_xor_gate (glauses, lhs);
+    if (g)
+      extracted++;
+    if (internal->unsat)
+      break;
+  }
+  if (!extracted)
+    LOG ("no arity %u XOR gate extracted", arity);
+}
+void Closure::extract_xor_gates () {
+  CADICAL_assert (!full_watching);
+  if (!internal->opts.congruencexor)
+    return;
+  START (extractxors);
+  LOG ("starting extracting XOR");
+  std::vector<Clause *> candidates = {};
+  init_xor_gate_extraction (candidates);
+  for (auto c : candidates) {
+    if (internal->unsat)
+      break;
+    if (c->garbage)
+      continue;
+    extract_xor_gates_with_base_clause (c);
+  }
+  reset_xor_gate_extraction ();
+  STOP (extractxors);
+}
+
+/*------------------------------------------------------------------------*/
+void Closure::find_units () {
+  size_t units = 0;
+  for (auto v : internal->vars) {
+  RESTART:
+    if (!internal->flags (v).active ())
+      continue;
+    for (int sgn = -1; sgn < 1; sgn += 2) {
+      int lit = v * sgn;
+      for (auto w : internal->watches (lit)) {
+        if (!w.binary ())
+          continue; // todo check that binaries first
+        const int other = w.blit;
+        if (marked (-other)) {
+          LOG (w.clause, "binary clause %d %d and %d %d give unit %d", lit,
+               other, lit, -other, lit);
+          ++units;
+          if (internal->lrat) {
+            lrat_chain.push_back (w.clause->id);
+            lrat_chain.push_back (marked_mu1 (-other).clause->id);
+          }
+          bool failed = !learn_congruence_unit (lit);
+          unmark_all ();
+          if (failed)
+            return;
+          else
+            goto RESTART;
+        }
+        if (marked (other))
+          continue;
+        marked (other) = 1;
+        set_mu1_reason (other, w.clause);
+        internal->analyzed.push_back (other);
+      }
+      unmark_all ();
+    }
+    CADICAL_assert (internal->analyzed.empty ());
+  }
+  LOG ("found %zd units", units);
+}
+
+void Closure::find_equivalences () {
+  CADICAL_assert (!internal->unsat);
+
+  for (auto v : internal->vars) {
+  RESTART:
+    if (!internal->flags (v).active ())
+      continue;
+    int lit = v;
+    for (auto w : internal->watches (lit)) {
+      if (!w.binary ())
+        break;
+      CADICAL_assert (w.size == 2);
+      const int other = w.blit;
+      if (internal->vlit (lit) > internal->vlit (other))
+        continue;
+      if (marked (other))
+        continue;
+      internal->analyzed.push_back (other);
+      marked (other) = true;
+      set_mu1_reason (other, w.clause);
+    }
+
+    if (internal->analyzed.empty ())
+      continue;
+
+    for (auto w : internal->watches (-lit)) {
+      if (!w.binary ())
+        break; // binary clauses are first
+      const int other = w.blit;
+      if (internal->vlit (-lit) > internal->vlit (other))
+        continue;
+      CADICAL_assert (-lit != other);
+      LOG ("binary clause %d %d", -lit, other);
+      if (marked (-other)) {
+        int lit_repr = find_representative (lit);
+        int other_repr = find_representative (other);
+        LOG ("found equivalence %d %d with %d and %d as the representative",
+             lit, other, lit_repr, other_repr);
+        if (lit_repr != other_repr) {
+          // if (internal->lrat) {
+          //   // This cannot work
+          //   // if you have 2 = 1 and 3=4
+          //   // you cannot add 2=3. You really to connect the
+          //   representatives directly
+          //   // therefore you actually need to learn the clauses 2->3->4
+          //   and -2->1 and vice-versa eager_representative_id (other) =
+          //   marked_mu1 (-other).clause->id; eager_representative_id
+          //   (-other) = w.clause->id; CADICAL_assert (eager_representative_id
+          //   (other) != -1); LOG ("lrat: %d (%zd) %d (%zd)", other,
+          //   eager_representative_id (other), -other,
+          //   eager_representative_id (-other));
+          // }
+          promote_clause (marked_mu1 (-other).clause);
+          promote_clause (w.clause);
+          LOG (w.clause, "merging");
+          LOG (marked_mu1 (-other).clause, "with");
+          if (merge_literals_equivalence (
+                  lit, other,
+                  internal->lrat ? marked_mu1 (-other).clause : nullptr,
+                  w.clause)) {
+            ++internal->stats.congruence.congruent;
+          }
+          unmark_all ();
+          if (internal->unsat)
+            return;
+          else
+            goto RESTART;
+        }
+      }
+    }
+    unmark_all ();
+  }
+  CADICAL_assert (internal->analyzed.empty ());
+  LOG ("found %zd equivalences", schedule.size ());
+}
+
+/*------------------------------------------------------------------------*/
+// Initialization
+
+void Closure::rewrite_and_gate (Gate *g, int dst, int src, LRAT_ID id1,
+                                LRAT_ID id2) {
+  if (skip_and_gate (g))
+    return;
+  if (!gate_contains (g, src))
+    return;
+  if (internal->val (src)) {
+    // In essence the code below does the same thing as simplify_and_gate
+    // but the necessary LRAT chain are different.
+    simplify_and_gate (g);
+    return;
+  }
+  CADICAL_assert (src);
+  CADICAL_assert (dst);
+  CADICAL_assert (internal->val (src) == internal->val (dst));
+  GatesTable::iterator git = (g->indexed ? table.find (g) : end (table));
+  LOG (g, "rewriting %d into %d in", src, dst);
+  int clashing = 0, falsifies = 0;
+  unsigned dst_count = 0, not_dst_count = 0;
+  auto q = begin (g->rhs);
+  for (int &lit : g->rhs) {
+    if (lit == src)
+      lit = dst;
+    if (lit == -g->lhs) {
+      LOG ("found negated LHS literal %d", lit);
+      clashing = lit;
+      g->degenerated_and_neg = true;
+      break;
+    }
+    if (lit == g->lhs)
+      g->degenerated_and_pos = true;
+    const signed char val = internal->val (lit);
+    if (val > 0) {
+      continue;
+    }
+    if (val < 0) {
+      LOG ("found falsifying literal %d", (lit));
+      falsifies = lit;
+      break;
+    }
+    if (lit == dst) {
+      if (not_dst_count) {
+        LOG ("clashing literals %d and %d", (-dst), (dst));
+        clashing = -dst;
+        break;
+      }
+      if (dst_count++)
+        continue;
+    }
+    if (lit == -dst) {
+      if (dst_count) {
+        CADICAL_assert (!not_dst_count);
+        LOG ("clashing literals %d and %d", (dst), (-dst));
+        clashing = -dst;
+        break;
+      }
+      CADICAL_assert (!not_dst_count);
+      ++not_dst_count;
+    }
+    *q++ = lit;
+  }
+  LOG (lrat_chain, "lrat chain after rewriting");
+
+  if (internal->lrat) { // updating reasons in the chain.
+#ifdef LOGGING
+    for (auto litId : g->pos_lhs_ids) {
+      LOG (litId.clause, "%d ->", litId.current_lit);
+    }
+#endif
+    // We remove all assigned literals except the falsified literal such
+    // that we can produce an LRAT chain
+    size_t i = 0, size = g->pos_lhs_ids.size ();
+    bool found = false;
+    CADICAL_assert (!falsifies || !clashing);
+    const int orig_falsifies = falsifies == dst ? src : falsifies;
+    const int orig_clashing =
+      clashing == -dst ? -src : (clashing == dst ? src : clashing);
+    int keep_clashing = clashing;
+    LOG ("keeping chain for falsifies: %d aka %d and clashing: %d aka %d",
+         falsifies, orig_falsifies, clashing, orig_clashing);
+    for (size_t j = 0; j < size; ++j) {
+      LOG (g->pos_lhs_ids[j].clause, "looking at %d [%zd %zd] with val %d",
+           g->pos_lhs_ids[j].current_lit, i, j,
+           internal->val (g->pos_lhs_ids[i].current_lit));
+      g->pos_lhs_ids[i] = g->pos_lhs_ids[j];
+      if (keep_clashing && g->pos_lhs_ids[i].current_lit != orig_clashing &&
+          g->pos_lhs_ids[i].current_lit != -orig_clashing &&
+          g->pos_lhs_ids[i].current_lit != keep_clashing &&
+          g->pos_lhs_ids[i].current_lit != -keep_clashing)
+        continue;
+      if (internal->val (g->pos_lhs_ids[i].current_lit) &&
+          g->pos_lhs_ids[i].current_lit != src &&
+          g->pos_lhs_ids[i].current_lit != orig_falsifies)
+        continue;
+      if (g->pos_lhs_ids[i].current_lit == dst) {
+        if (!found)
+          found = true;
+        else
+          continue; // we have already one defining clause
+      }
+
+      LOG ("maybe keeping %d [%zd %zd], src: %d, found: %d",
+           g->pos_lhs_ids[i].current_lit, i, j, src, found);
+      if (g->pos_lhs_ids[i].current_lit == src) {
+        if (!found)
+          g->pos_lhs_ids[i].current_lit = dst, found = true;
+        else
+          continue; // we have already one defining clause
+      }
+      LOG ("keeping %d [%zd %zd]", g->pos_lhs_ids[i].current_lit, i, j);
+      ++i;
+    }
+    LOG ("resizing to %zd", i);
+    CADICAL_assert (i);
+    g->pos_lhs_ids.resize (i);
+  }
+
+  if (q != end (g->rhs)) {
+    g->rhs.resize (q - begin (g->rhs));
+    g->shrunken = true;
+  }
+  CADICAL_assert (dst_count <= 2);
+  CADICAL_assert (not_dst_count <= 1);
+
+  std::vector<LRAT_ID> reasons_lrat_src, reasons_lrat_usrc;
+  shrink_and_gate (g, falsifies, clashing);
+  LOG (g, "rewritten as");
+  CADICAL_assert (!internal->lrat || !g->pos_lhs_ids.empty ());
+  //  check_and_gate_implied (g);
+  update_and_gate (g, git, src, dst, id1, id2, falsifies, clashing);
+  ++internal->stats.congruence.rewritten_ands;
+}
+
+bool Closure::rewrite_gate (Gate *g, int dst, int src, LRAT_ID id1,
+                            LRAT_ID id2) {
+  switch (g->tag) {
+  case Gate_Type::And_Gate:
+    rewrite_and_gate (g, dst, src, id1, id2);
+    break;
+  case Gate_Type::XOr_Gate:
+    rewrite_xor_gate (g, dst, src);
+    break;
+  case Gate_Type::ITE_Gate:
+    rewrite_ite_gate (g, dst, src);
+    break;
+  default:
+    CADICAL_assert (false);
+    break;
+  }
+  CADICAL_assert (internal->unsat || lrat_chain.empty ());
+  return !internal->unsat;
+}
+
+bool Closure::rewrite_gates (int dst, int src, LRAT_ID id1, LRAT_ID id2) {
+  const auto &occs = goccs (src);
+  for (auto g : occs) {
+    CADICAL_assert (lrat_chain.empty ());
+    if (!rewrite_gate (g, dst, src, id1, id2))
+      return false;
+    else if (!g->garbage && gate_contains (g, dst))
+      goccs (dst).push_back (g);
+  }
+  goccs (src).clear ();
+
+#ifndef CADICAL_NDEBUG
+  for (const auto &occs : gtab) {
+    for (auto g : occs) {
+      CADICAL_assert (g);
+      CADICAL_assert (g->garbage || !gate_contains (g, src));
+    }
+  }
+#endif
+  CADICAL_assert (lrat_chain.empty ());
+  return true;
+}
+
+bool Closure::rewriting_lhs (Gate *g, int dst) {
+  if (dst != g->lhs && dst != -g->lhs)
+    return false;
+  mark_garbage (g);
+  return true;
+}
+
+// update to produce proofs
+void Closure::rewrite_xor_gate (Gate *g, int dst, int src) {
+  if (skip_xor_gate (g))
+    return;
+  if (rewriting_lhs (g, dst))
+    return;
+  if (!gate_contains (g, src))
+    return;
+  LOG (g, "rewriting (%d -> %d)", src, dst);
+  check_xor_gate_implied (g);
+  GatesTable::iterator git = (g->indexed ? table.find (g) : end (table));
+  size_t j = 0, dst_count = 0;
+  bool original_dst_negated = (dst < 0);
+  dst = abs (dst);
+  unsigned negate = original_dst_negated;
+  const size_t size = g->rhs.size ();
+  for (size_t i = 0; i < size; ++i) {
+    int lit = g->rhs[i];
+    CADICAL_assert (lit > 0);
+    if (lit == src)
+      lit = dst;
+    const signed char v = internal->val (lit);
+    if (v > 0) {
+      negate ^= true;
+    }
+    if (v)
+      continue;
+    if (lit == dst)
+      dst_count++;
+    LOG ("keeping value %d", lit);
+    g->rhs[j++] = lit;
+  }
+  if (negate) {
+    LOG ("flipping LHS %d", g->lhs);
+    g->lhs = -g->lhs;
+  }
+  CADICAL_assert (dst_count <= 2);
+  if (dst_count == 2) {
+    LOG ("destination found twice, removing");
+    size_t k = 0;
+    for (size_t i = 0; i < j; ++i) {
+      const int lit = g->rhs[i];
+      if (lit != dst)
+        g->rhs[k++] = g->rhs[i];
+    }
+    CADICAL_assert (k == j - 2);
+    g->rhs.resize (k);
+    g->shrunken = true;
+    CADICAL_assert (is_sorted (begin (g->rhs), end (g->rhs),
+                       sort_literals_by_var_smaller (internal)));
+    g->hash = hash_lits (nonces, g->rhs);
+  } else if (j != size) {
+    g->shrunken = true;
+    g->rhs.resize (j);
+    sort_literals_by_var (g->rhs);
+    g->hash = hash_lits (
+        nonces,
+        g->rhs); // all but one (the dst) is sorted correctly actually
+  } else {
+    CADICAL_assert (j == size);
+    sort_literals_by_var (g->rhs);
+  }
+
+  CADICAL_assert (clause.empty ());
+  // LRAT for add_xor_shrinking_proof_chain
+  // this should be unnecessary...
+  // TODO check if really unnecessary
+  if (dst_count > 1)
+    add_xor_shrinking_proof_chain (g, dst);
+  CADICAL_assert (internal->clause.size () <= 1);
+  update_xor_gate (g, git);
+
+  if (!g->garbage && !internal->unsat && original_dst_negated &&
+      dst_count == 1) {
+    connect_goccs (g, dst);
+  }
+
+  check_xor_gate_implied (g);
+  // TODO stats
+}
+
+// update to produce proofs
+void Closure::simplify_xor_gate (Gate *g) {
+  LOG (g, "simplifying");
+  if (skip_xor_gate (g))
+    return;
+  check_xor_gate_implied (g);
+  unsigned negate = 0;
+  GatesTable::iterator git = (g->indexed ? table.find (g) : end (table));
+  const size_t size = g->rhs.size ();
+  size_t j = 0;
+  for (size_t i = 0; i < size; ++i) {
+    int lit = g->rhs[i];
+    CADICAL_assert (lit > 0);
+    const signed char v = internal->val (lit);
+    if (v > 0)
+      negate ^= 1;
+    if (!v) {
+      g->rhs[j++] = lit;
+    }
+  }
+  if (negate) {
+    LOG ("flipping LHS literal %d", (g->lhs));
+    g->lhs = -(g->lhs);
+  }
+  if (j != size) {
+    LOG ("shrunken gate");
+    g->shrunken = true;
+    g->rhs.resize (j);
+    CADICAL_assert (is_sorted (begin (g->rhs), end (g->rhs),
+                       sort_literals_by_var_smaller (internal)));
+    g->hash = hash_lits (nonces, g->rhs);
+  } else {
+    CADICAL_assert (g->hash == hash_lits (nonces, g->rhs));
+  }
+
+  check_xor_gate_implied (g);
+  CADICAL_assert (clause.empty ());
+  update_xor_gate (g, git);
+  LOG (g, "simplified");
+  check_xor_gate_implied (g);
+  internal->stats.congruence.simplified++;
+  internal->stats.congruence.simplified_xors++;
+}
+
+/*------------------------------------------------------------------------*/
+// propagation of clauses and simplification
+void Closure::schedule_literal (int lit) {
+  const int idx = abs (lit);
+  if (scheduled[idx])
+    return;
+  scheduled[idx] = true;
+  schedule.push (lit);
+  CADICAL_assert (lit != find_representative (lit));
+  LOG ("scheduled literal %d", lit);
+}
+
+bool Closure::propagate_unit (int lit) {
+  LOG ("propagation of congruence unit %d", lit);
+  if (internal->lrat)
+    lazy_propagated (lit) = true;
+  return simplify_gates (lit) && simplify_gates (-lit);
+}
+
+bool Closure::propagate_units () {
+  while (units !=
+         internal->trail
+             .size ()) { // units are added during propagation, so reloading
+    LOG ("propagating %d over gates", internal->trail[units]);
+    if (!propagate_unit (internal->trail[units++]))
+      return false;
+  }
+  return true;
+}
+
+// The replacement has to be done eagerly, not lazily to make sure that the
+// gates are in normalized form. Otherwise, some merges might be missed.
+bool Closure::propagate_equivalence (int lit) {
+  if (internal->val (lit))
+    return true;
+  LOG ("propagating literal %d", lit);
+  import_lazy_and_find_eager_representative_and_compress_both (lit);
+  const int repr = find_eager_representative_and_compress (lit);
+  const LRAT_ID id1 = find_eager_representative_lrat (lit);
+  const LRAT_ID id2 = find_eager_representative_lrat (-lit);
+  CADICAL_assert (lrat_chain.empty ());
+  return rewrite_gates (repr, lit, id1, id2) &&
+         rewrite_gates (-repr, -lit, id2, id1);
+}
+
+size_t Closure::propagate_units_and_equivalences () {
+  START (congruencemerge);
+  size_t propagated = 0;
+  LOG ("propagating at least %zd units", schedule.size ());
+  CADICAL_assert (lrat_chain.empty ());
+  while (propagate_units () && !schedule.empty ()) {
+    CADICAL_assert (!internal->unsat);
+    CADICAL_assert (lrat_chain.empty ());
+    ++propagated;
+    int lit = schedule.front ();
+    schedule.pop ();
+    scheduled[abs (lit)] = false;
+    if (!propagate_equivalence (lit))
+      break;
+  }
+
+  CADICAL_assert (internal->unsat || schedule.empty ());
+  CADICAL_assert (internal->unsat || lrat_chain.empty ());
+
+  LOG ("propagated %zu congruence units", units);
+  LOG ("propagated %zu congruence equivalences", propagated);
+
+#ifndef CADICAL_NDEBUG
+  if (!internal->unsat) {
+    for (const auto &occs : gtab) {
+      for (auto g : occs) {
+        if (g->garbage)
+          continue;
+        CADICAL_assert (g->tag == Gate_Type::ITE_Gate ||
+                g->tag == Gate_Type::XOr_Gate ||
+                !gate_contains (g, -g->lhs));
+        // TODO: this would be nice to have!
+        //      CADICAL_assert (g->tag != Gate_Type::ITE_Gate || (g->rhs.size() == 3
+        //      && g->rhs[1] != -g->lhs && g->rhs[2] != -g->lhs));
+        // CADICAL_assert (table.count(g) == 1);
+        for (auto lit : g->rhs) {
+          CADICAL_assert (!internal->val (lit));
+          CADICAL_assert (representative (lit) == lit);
+        }
+      }
+    }
+    for (Gate *g : table) {
+      if (g->garbage)
+        continue;
+      if (g->tag == Gate_Type::And_Gate) {
+        // CADICAL_assert (find_and_lits(g->arity, g->rhs));
+      }
+    }
+  }
+#endif
+  STOP (congruencemerge);
+  return propagated;
+}
+
+std::string string_of_gate (Gate_Type t) {
+  switch (t) {
+  case Gate_Type::And_Gate:
+    return "And";
+  case Gate_Type::XOr_Gate:
+    return "XOr";
+  case Gate_Type::ITE_Gate:
+    return "ITE";
+  default:
+    return "buggy";
+  }
+}
+
+void Closure::reset_closure () {
+  scheduled.clear ();
+  for (Gate *g : table) {
+    CADICAL_assert (g->indexed);
+    LOG (g, "deleting");
+    if (!g->garbage)
+      delete g;
+  }
+  table.clear ();
+
+  for (auto &occ : gtab) {
+    occ.clear ();
+  }
+  gtab.clear ();
+
+  for (auto gate : garbage)
+    delete gate;
+  garbage.clear ();
+
+  if (internal->lrat) {
+    CADICAL_assert (internal->proof);
+    for (auto c : extra_clauses) {
+      CADICAL_assert (!c->garbage);
+      internal->proof->delete_clause (c);
+      delete c;
+    }
+    extra_clauses.clear ();
+  } else {
+    CADICAL_assert (extra_clauses.empty ());
+  }
+}
+
+void Closure::reset_extraction () {
+  full_watching = true;
+  if (!internal->unsat && !internal->propagate ()) {
+    internal->learn_empty_clause ();
+  }
+
+#if 0
+  // remove delete watched clauses from the watch list
+  for (auto v : internal->vars) {
+    for (auto sgn = -1; sgn <= 1; sgn += 2) {
+      const int lit = v * sgn;
+      auto &watchers = internal->watches (lit);
+      const size_t size = watchers.size ();
+      size_t j = 0;
+      for (size_t i = 0; i != size; ++i) {
+	const auto w = watchers[i];
+	watchers[j] = watchers[i];
+	if (!w.clause->garbage)
+	  ++j;
+      }
+      watchers.resize(j);
+    }
+  }
+  // watch the remaining non-watched clauses
+  for (auto c : new_unwatched_binary_clauses)
+    internal->watch_clause (c);
+  new_unwatched_binary_clauses.clear();
+  for (auto c : internal->clauses) {
+    if (c->garbage)
+      continue;
+    if (c->size != 2)
+      internal->watch_clause (c);
+  }
+#else // simpler implementation
+  new_unwatched_binary_clauses.clear ();
+  internal->clear_watches ();
+  internal->connect_watches ();
+#endif
+}
+
+void Closure::forward_subsume_matching_clauses () {
+  START (congruencematching);
+  reset_closure ();
+  std::vector<signed char> matchable;
+  matchable.resize (internal->max_var + 1);
+  size_t count_matchable = 0;
+
+  for (auto idx : internal->vars) {
+    if (!internal->flags (idx).active ())
+      continue;
+    const int lit = idx;
+    const int repr = find_representative (lit);
+    if (lit == repr)
+      continue;
+    const int repr_idx = abs (repr);
+    if (!matchable[idx]) {
+      LOG ("matchable %d", idx);
+      matchable[idx] = true;
+      count_matchable++;
+    }
+
+    if (!matchable[repr_idx]) {
+      LOG ("matchable %d", repr_idx);
+      matchable[repr_idx] = true;
+      count_matchable++;
+    }
+  }
+
+  LOG ("found %.0f%%",
+       (double) count_matchable /
+           (double) (internal->max_var ? internal->max_var : 1));
+  std::vector<Clause *> candidates;
+  auto &analyzed = internal->analyzed;
+
+  for (auto *c : internal->clauses) {
+    if (c->garbage)
+      continue;
+    if (c->redundant)
+      continue;
+    if (c->size == 2)
+      continue;
+    CADICAL_assert (analyzed.empty ());
+    bool contains_matchable = false;
+    for (auto lit : *c) {
+      const signed char v = internal->val (lit);
+      if (v < 0)
+        continue;
+      if (v > 0) {
+        LOG (c, "mark satisfied");
+        internal->mark_garbage (c);
+        break;
+      }
+      if (!contains_matchable) {
+        const int idx = abs (lit);
+        if (matchable[idx])
+          contains_matchable = true;
+      }
+
+      const int repr = find_representative (lit);
+      CADICAL_assert (!internal->val (repr));
+      if (marked (repr))
+        continue;
+      const int not_repr = -repr;
+      if (marked (not_repr)) {
+        LOG (c, "matches both %d and %d", (lit), (not_repr));
+        internal->mark_garbage (c);
+        break;
+      }
+      marked (repr) = 1;
+      analyzed.push_back (repr);
+    }
+
+    for (auto lit : analyzed)
+      marked (lit) = 0;
+    analyzed.clear ();
+    if (c->garbage)
+      continue;
+    if (!contains_matchable) {
+      LOG ("no matching variable");
+      continue;
+    }
+    LOG (c, "candidate");
+    candidates.push_back (c);
+  }
+
+  rsort (begin (candidates), end (candidates), smaller_clause_size_rank ());
+  size_t tried = 0, subsumed = 0;
+  internal->init_occs ();
+  for (auto c : candidates) {
+    CADICAL_assert (c->size != 2);
+    // TODO if terminated
+    ++tried;
+    if (find_subsuming_clause (c)) {
+      ++subsumed;
+    }
+  }
+  LOG ("[congruence] subsumed %.0f%%",
+       (double) subsumed / (double) (tried ? tried : 1));
+  STOP (congruencematching);
+}
+
+/*------------------------------------------------------------------------*/
+// Candidate clause 'subsumed' is subsumed by 'subsuming'.  We need to copy
+// the function because 'congruence' is too early to include the version
+// from subsume
+
+void Closure::subsume_clause (Clause *subsuming, Clause *subsumed) {
+  //  CADICAL_assert (!subsuming->redundant);
+  // CADICAL_assert (!subsumed->redundant);
+  auto &stats = internal->stats;
+  stats.subsumed++;
+  CADICAL_assert (subsuming->size <= subsumed->size);
+  LOG (subsumed, "subsumed");
+  if (subsumed->redundant)
+    stats.subred++;
+  else
+    stats.subirr++;
+  if (subsumed->redundant || !subsuming->redundant) {
+    internal->mark_garbage (subsumed);
+    return;
+  }
+  LOG ("turning redundant subsuming clause into irredundant clause");
+  subsuming->redundant = false;
+  if (internal->proof)
+    internal->proof->strengthen (subsuming->id);
+  internal->mark_garbage (subsumed);
+  stats.current.irredundant++;
+  stats.added.irredundant++;
+  stats.irrlits += subsuming->size;
+  CADICAL_assert (stats.current.redundant > 0);
+  stats.current.redundant--;
+  CADICAL_assert (stats.added.redundant > 0);
+  stats.added.redundant--;
+  // ... and keep 'stats.added.total'.
+}
+
+bool Closure::find_subsuming_clause (Clause *subsumed) {
+  CADICAL_assert (!subsumed->garbage);
+  Clause *subsuming = nullptr;
+  for (auto lit : *subsumed) {
+    CADICAL_assert (internal->val (lit) <= 0);
+    const int repr_lit = find_representative (lit);
+    const signed char repr_val = internal->val (repr_lit);
+    CADICAL_assert (repr_val <= 0);
+    if (repr_val < 0)
+      continue;
+    if (marked (repr_lit))
+      continue;
+    CADICAL_assert (!marked (-repr_lit));
+    marked (repr_lit) = 1;
+  }
+  int least_occuring_lit = 0;
+  size_t count_least_occurring = INT_MAX;
+  LOG (subsumed, "trying to forward subsume");
+
+  for (auto lit : *subsumed) {
+    const int repr_lit = find_representative (lit);
+    const size_t count = internal->occs (lit).size ();
+    CADICAL_assert (count <= UINT_MAX);
+    if (count < count_least_occurring) {
+      count_least_occurring = count;
+      least_occuring_lit = repr_lit;
+    }
+    for (auto d : internal->occs (lit)) {
+      CADICAL_assert (!d->garbage);
+      CADICAL_assert (subsumed != d);
+      if (!subsumed->redundant && d->redundant)
+        continue;
+      for (auto other : *d) {
+        const signed char v = internal->val (other);
+        if (v < 0)
+          continue;
+        CADICAL_assert (!v);
+        const int repr_other = find_representative (other);
+        if (!marked (repr_other))
+          goto CONTINUE_WITH_NEXT_CLAUSE;
+        LOG ("subsuming due to %d -> %d", other, repr_other);
+      }
+      subsuming = d;
+      goto FOUND_SUBSUMING;
+
+    CONTINUE_WITH_NEXT_CLAUSE:;
+    }
+  }
+  CADICAL_assert (least_occuring_lit);
+
+FOUND_SUBSUMING:
+  for (auto lit : *subsumed) {
+    const int repr_lit = find_representative (lit);
+    const signed char v = internal->val (lit);
+    if (!v)
+      marked (repr_lit) = 0;
+  }
+  if (subsuming) {
+    LOG (subsumed, "subsumed");
+    LOG (subsuming, "subsuming");
+    subsume_clause (subsuming, subsumed);
+    ++internal->stats.congruence.subsumed;
+    return true;
+  } else {
+    internal->occs (least_occuring_lit).push_back (subsumed);
+    return false;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+static bool skip_ite_gate (Gate *g) {
+  CADICAL_assert (g->tag == Gate_Type::ITE_Gate);
+  if (g->garbage)
+    return true;
+  return false;
+}
+
+void Closure::produce_ite_merge_then_else_reasons (
+    Gate *g, int src, int dst, std::vector<LRAT_ID> &reasons_implication,
+    std::vector<LRAT_ID> &reasons_back) {
+  CADICAL_assert (!g->garbage);
+  if (!internal->lrat)
+    return;
+  check_correct_ite_flags (g);
+  // no merge is happening actually
+  CADICAL_assert (g->rhs[1] == find_eager_representative(g->rhs[1]) || g->rhs[2] == find_eager_representative(g->rhs[2]));
+  if (find_eager_representative (g->lhs) == g->rhs[1] || find_eager_representative (g->lhs) == g->rhs[2])
+    return;
+  if ((g->rhs[1] == src && g->lhs == dst && g->rhs[2] == g->lhs) ||
+      (g->rhs[2] == src && g->lhs == dst && g->rhs[1] == g->lhs) ||
+      (g->rhs[1] == -src && g->lhs == -dst && g->rhs[2] == g->lhs) ||
+      (g->rhs[2] == -src && g->lhs == -dst && g->rhs[1] == g->lhs))
+    return;
+  check_ite_lrat_reasons (g, false);
+  CADICAL_assert (g->rhs.size () == 3);
+  CADICAL_assert (src == g->rhs[1] || src == g->rhs[2]);
+  CADICAL_assert (dst == g->rhs[1] || dst == g->rhs[2]);
+  const int8_t flag = g->degenerated_ite;
+  CADICAL_assert (!ite_flags_no_then_clauses (flag)); // e = lhs: already merged
+  CADICAL_assert (!ite_flags_no_else_clauses (flag)); // t = lhs: already merged
+  produce_rewritten_clause_lrat (g->pos_lhs_ids, g->lhs, false);
+  if (ite_flags_neg_cond_lhs (flag)) {
+    LOG ("degenerated case with lhs = -cond");
+    LOG (g->pos_lhs_ids[0].clause, "1:");
+    LOG (g->pos_lhs_ids[1].clause, "2:");
+    reasons_back.push_back (g->pos_lhs_ids[0].clause->id);
+    reasons_implication.push_back (g->pos_lhs_ids[1].clause->id);
+    return;
+  }
+  if (ite_flags_cond_lhs (flag)) {
+    LOG ("degenerated case with lhs = cond");
+    CADICAL_assert (g->pos_lhs_ids[0].clause);
+    CADICAL_assert (g->pos_lhs_ids[3].clause);
+    reasons_back.push_back (g->pos_lhs_ids[3].clause->id);
+    reasons_implication.push_back (g->pos_lhs_ids[0].clause->id);
+    return;
+  }
+  reasons_implication.push_back (g->pos_lhs_ids[0].clause->id);
+  reasons_implication.push_back (g->pos_lhs_ids[2].clause->id);
+  reasons_back.push_back (g->pos_lhs_ids[1].clause->id);
+  reasons_back.push_back (g->pos_lhs_ids[3].clause->id);
+}
+
+void Closure::rewrite_ite_gate_update_lrat_reasons (Gate *g, int src,
+                                                    int dst) {
+  if (!internal->lrat)
+    return;
+  LOG (g, "updating lrat from");
+  for (auto &litId : g->pos_lhs_ids) {
+    CADICAL_assert (litId.clause);
+    if (litId.current_lit == src)
+      litId.current_lit = dst;
+    if (litId.current_lit == -src)
+      litId.current_lit = -dst;
+  }
+  check_ite_lrat_reasons (g, false);
+}
+
+bool Closure::rewrite_ite_gate_to_and (
+    Gate *g, int src, int dst, size_t idx1, size_t idx2,
+    int cond_lit_to_learn_if_degenerated) {
+  CADICAL_assert (internal->lrat_chain.empty ());
+  CADICAL_assert (!g->garbage);
+  LOG (g, "rewriting to proper AND");
+  if (internal->val (g->lhs) > 0) {
+    {
+      const int lit = g->rhs[0];
+      const char v = internal->val (lit);
+      if (v > 0) {
+      } else if (!v) {
+        if (internal->lrat) {
+          push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[idx1].clause,
+                                           Rewrite (), lrat_chain);
+        }
+        learn_congruence_unit (cond_lit_to_learn_if_degenerated);
+      } else {
+        if (internal->lrat)
+          push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[idx1].clause,
+                                           Rewrite (), lrat_chain);
+        push_lrat_unit (-lit);
+        internal->learn_empty_clause ();
+        return true;
+      }
+    }
+    if (!internal->unsat) {
+      const int lit = g->rhs[1];
+      const char v = internal->val (lit);
+      CADICAL_assert (dst == g->rhs[0] || dst == g->rhs[1] || -dst == g->rhs[0] ||
+              -dst == g->rhs[1]);
+      const int other = (dst == g->rhs[0] || dst == g->rhs[1])
+                            ? dst ^ g->rhs[0] ^ g->rhs[1]
+                            : (-dst) ^ g->rhs[0] ^ g->rhs[1];
+      if (v > 0) {
+        // already set by propagation
+        return true;
+      } else if (!v) {
+        if (internal->lrat) {
+          push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[idx2].clause,
+                                           Rewrite (), lrat_chain);
+        }
+        learn_congruence_unit (other);
+      } else {
+        if (internal->lrat) {
+          push_lrat_unit (cond_lit_to_learn_if_degenerated);
+          push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[idx2].clause,
+                                           Rewrite (), lrat_chain);
+        }
+        internal->learn_empty_clause ();
+        return true;
+      }
+    }
+    return true;
+  }
+  if (!internal->lrat)
+    return false;
+  LOG ("updating flags");
+  g->degenerated_and_neg = (g->rhs[1] == -g->lhs || g->rhs[0] == -g->lhs);
+  g->degenerated_and_pos = (g->rhs[0] == g->lhs || g->rhs[1] == g->lhs);
+  CADICAL_assert (g->rhs.size () == 3);
+  CADICAL_assert (g->pos_lhs_ids.size () == 4);
+  CADICAL_assert (idx1 < g->pos_lhs_ids.size ());
+  CADICAL_assert (idx2 < g->pos_lhs_ids.size ());
+  int lit = g->pos_lhs_ids[idx2].current_lit, other = g->lhs;
+  // TODO: remove argument
+  (void) src;
+  produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, g->lhs, idx1,
+                                           idx2, false);
+
+  if ((idx1 == (size_t) -1 || idx2 == (size_t) -1)) {
+    // degenerated and gate
+    return false;
+  }
+
+  CADICAL_assert (idx1 != (size_t) -1);
+  CADICAL_assert (idx2 != (size_t) -1);
+  CADICAL_assert (idx1 < g->pos_lhs_ids.size ());
+  CADICAL_assert (idx2 < g->pos_lhs_ids.size ());
+  Clause *c = g->pos_lhs_ids[idx1].clause;
+  CADICAL_assert (c->size == 2);
+  Clause *d = g->pos_lhs_ids[idx2].clause;
+  CADICAL_assert (c != d);
+  CADICAL_assert (c);
+  CADICAL_assert (d);
+  g->pos_lhs_ids.erase (std::remove_if (begin (g->pos_lhs_ids),
+                                        end (g->pos_lhs_ids),
+                                        [d] (const LitClausePair &p) {
+                                          return p.clause == d || !p.clause;
+                                        }),
+                        end (g->pos_lhs_ids));
+  CADICAL_assert (g->pos_lhs_ids.size () == 2);
+  CADICAL_assert (lit);
+  CADICAL_assert (other);
+  CADICAL_assert (lit != dst);
+  CADICAL_assert (other != dst);
+  CADICAL_assert (lit != other);
+  lrat_chain.push_back (c->id);
+  lrat_chain.push_back (d->id);
+  Clause *e = learn_binary_tmp_or_full_clause (lit, -other);
+  CADICAL_assert (e);
+
+  auto long_clause =
+      std::find_if (begin (g->pos_lhs_ids), end (g->pos_lhs_ids),
+                    [] (LitClausePair l) { return l.clause->size == 3; });
+  CADICAL_assert (long_clause != end (g->pos_lhs_ids));
+  LOG (long_clause->clause, "new long clause");
+  g->neg_lhs_ids.push_back (*long_clause);
+  g->pos_lhs_ids.erase (long_clause);
+
+  CADICAL_assert (g->pos_lhs_ids.size () == 1);
+
+  (void) maybe_promote_tmp_binary_clause (g->pos_lhs_ids[0].clause);
+  g->pos_lhs_ids.push_back ({lit, e});
+#ifndef CADICAL_NDEBUG
+  for (auto litId : g->pos_lhs_ids) {
+    bool found = false;
+    CADICAL_assert (litId.clause);
+    for (auto other : *litId.clause) {
+      found = (find_eager_representative (other) == litId.current_lit);
+      if (found)
+        break;
+    }
+    CADICAL_assert (found);
+  }
+  for (auto id : g->pos_lhs_ids) {
+    LOG (id.clause, "clause after rewriting:");
+    CADICAL_assert (id.clause->size == 2);
+  }
+
+#endif
+  return false;
+}
+
+void Closure::produce_ite_merge_lhs_then_else_reasons (
+    Gate *g, std::vector<LRAT_ID> &reasons_implication,
+    std::vector<LRAT_ID> &reasons_back, std::vector<LRAT_ID> &reasons_unit,
+    bool rewritting_then, bool &learn_units) {
+
+  const size_t idx1 = rewritting_then ? 0 : 2;
+  const size_t idx2 = idx1 + 1;
+  const size_t other_idx1 = rewritting_then ? 2 : 0;
+  const size_t other_idx2 = other_idx1 + 1;
+  const int cond_lit = g->rhs[0];
+  const int lit_to_merge = g->rhs[rewritting_then ? 2 : 1];
+  const int other_lit = g->rhs[rewritting_then ? 1 : 2];
+  const int repr_cond_lit = find_eager_representative (g->rhs[0]);
+  const int repr_lit_to_merge = find_eager_representative (lit_to_merge);
+  const int repr_other_lit = find_eager_representative (other_lit);
+  const int repr_lhs = find_eager_representative(g->lhs);
+  if (!internal->proof)
+    return;
+
+
+  LOG ("cond: %d, merging %d and rewriting to %d", cond_lit, lit_to_merge,
+       other_lit);
+  if (internal->lrat) {
+    CADICAL_assert (internal->lrat);
+    CADICAL_assert (g->pos_lhs_ids.size () == 4);
+
+    if (repr_lhs == -repr_other_lit) {
+      LOG ("special case: %s=%s, checking if other: %s %s", LOGLIT (g->lhs),
+           LOGLIT (-lit_to_merge), LOGLIT (cond_lit), LOGLIT (other_lit));
+      CADICAL_assert (repr_lit_to_merge != -repr_lhs); // should have been rewritten before
+
+      if (rewritting_then && repr_cond_lit == repr_lhs) {
+        LOG ("t=-lhs/c=lhs");
+        learn_units = true;
+        // is a unit
+        push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[0].clause,
+                                         Rewrite (), lrat_chain);
+        unsimplified.push_back (-cond_lit);
+        LRAT_ID id_unit = simplify_and_add_to_proof_chain (unsimplified);
+        reasons_unit = {id_unit};
+        // don't bother finding out which one is used
+        reasons_implication.push_back (id_unit);
+        g->pos_lhs_ids[3].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[3].clause, g->lhs, false);
+        CADICAL_assert (g->pos_lhs_ids[3].clause);
+        reasons_implication.push_back (g->pos_lhs_ids[3].clause->id);
+        unsimplified.clear ();
+        return;
+      }
+      if (!rewritting_then && repr_cond_lit == repr_lhs) {
+        LOG ("e=-lhs/c=lhs");
+        learn_units = true;
+        // is a unit
+        push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[3].clause,
+                                         Rewrite (), lrat_chain);
+        unsimplified.push_back (cond_lit);
+        LRAT_ID id_unit = simplify_and_add_to_proof_chain (unsimplified);
+        reasons_unit = {id_unit};
+        // don't bother finding out which one is used
+        reasons_implication.push_back (id_unit);
+        g->pos_lhs_ids[0].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[0].clause, g->lhs, false);
+        CADICAL_assert (g->pos_lhs_ids[0].clause);
+        reasons_implication.push_back (g->pos_lhs_ids[0].clause->id);
+        unsimplified.clear ();
+        return;
+      }
+      if (!rewritting_then && repr_cond_lit == -repr_lhs) {
+        LOG ("e=-lhs/c=-lhs");
+        learn_units = true;
+        // TODO: this function does not work to produce units for this case
+        // c LOG 0 rewriting 4 by 3 in gate[42] (arity: 3) -3 := ITE 3 7
+        // ...
+        // c LOG 0 clause[50] 4 -3
+        // c LOG 0 clause[44] 5 3
+        // c LOG 0 clause[2] -3 -4 -5
+        // the first two are rewriting, but they are not ordered properly
+        // and we need the '5' clause to come after
+        push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[2].clause,
+                                         Rewrite (), lrat_chain);
+        unsimplified.push_back (cond_lit);
+        LRAT_ID id_unit = simplify_and_add_to_proof_chain (unsimplified);
+        reasons_unit = {id_unit};
+        g->pos_lhs_ids[1].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[1].clause, g->lhs, false);
+        CADICAL_assert (g->pos_lhs_ids[1].clause);
+
+        // don't bother finding out which one is used
+        reasons_implication.push_back (id_unit);
+        reasons_implication.push_back (g->pos_lhs_ids[1].clause->id);
+        unsimplified.clear ();
+        return;
+      }
+      if (rewritting_then && repr_cond_lit == -repr_lhs) {
+        LOG ("t=-lhs/c=-lhs");
+        learn_units = true;
+        push_id_and_rewriting_lrat_unit (g->pos_lhs_ids[1].clause,
+                                         Rewrite (), lrat_chain);
+        unsimplified.push_back (-cond_lit);
+        LRAT_ID id_unit = simplify_and_add_to_proof_chain (unsimplified);
+        reasons_unit = {id_unit};
+        g->pos_lhs_ids[2].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[2].clause, g->lhs, false);
+        CADICAL_assert (g->pos_lhs_ids[2].clause);
+
+        reasons_implication.push_back (id_unit);
+        reasons_implication.push_back (g->pos_lhs_ids[2].clause->id);
+        unsimplified.clear ();
+        return;
+      }
+      if (rewritting_then && repr_lit_to_merge == repr_lhs) {
+        LOG ("t=-lhs/e=lhs from rewriting then");
+        learn_units = true;
+        g->pos_lhs_ids[idx1].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[idx1].clause, g->lhs, false);
+        g->pos_lhs_ids[idx2].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[idx2].clause, g->lhs, false);
+        CADICAL_assert (g->pos_lhs_ids[idx1].clause);
+        CADICAL_assert (g->pos_lhs_ids[idx2].clause);
+        lrat_chain.push_back (g->pos_lhs_ids[idx1].clause->id);
+        lrat_chain.push_back (g->pos_lhs_ids[idx2].clause->id);
+        unsimplified.push_back (-cond_lit);
+        LRAT_ID id_unit = simplify_and_add_to_proof_chain (unsimplified);
+        reasons_unit = {id_unit};
+        unsimplified.clear ();
+
+        return;
+      }
+      if (!rewritting_then && repr_lit_to_merge == repr_lhs) {
+        LOG ("t=-lhs/e=lhs from rewriting else");
+        learn_units = true;
+        g->pos_lhs_ids[idx1].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[idx1].clause, g->lhs, false);
+        g->pos_lhs_ids[idx2].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[idx2].clause, g->lhs, false);
+        CADICAL_assert (g->pos_lhs_ids[idx1].clause);
+        CADICAL_assert (g->pos_lhs_ids[idx2].clause);
+        lrat_chain.push_back (g->pos_lhs_ids[idx1].clause->id);
+        lrat_chain.push_back (g->pos_lhs_ids[idx2].clause->id);
+        unsimplified.push_back (cond_lit);
+        LRAT_ID id_unit = simplify_and_add_to_proof_chain (unsimplified);
+        reasons_unit = {id_unit};
+        unsimplified.clear ();
+        return;
+      }
+
+      if (other_lit == repr_lhs) {
+        LOG ("TODO FIX ME t=-lhs/e=lhs");
+        learn_units = true;
+        // in the other direction we are merging a literal with itself
+        g->pos_lhs_ids[idx1].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[idx1].clause, g->lhs, false);
+        g->pos_lhs_ids[idx2].clause = produce_rewritten_clause_lrat (
+            g->pos_lhs_ids[idx2].clause, g->lhs, false);
+        CADICAL_assert (g->pos_lhs_ids[idx1].clause);
+        CADICAL_assert (g->pos_lhs_ids[idx2].clause);
+        reasons_unit.push_back (g->pos_lhs_ids[idx1].clause->id);
+        reasons_unit.push_back (g->pos_lhs_ids[idx2].clause->id);
+        return;
+      }
+      // if (other_lit == -g->lhs) {
+      //   CADICAL_assert (false);
+      // }
+      // if (other_lit == g->lhs) {
+      //   CADICAL_assert (false);
+      // }
+    }
+
+    LOG ("normal path");
+    produce_rewritten_clause_lrat (g->pos_lhs_ids, g->lhs, false);
+    CADICAL_assert (g->pos_lhs_ids.size () == 4);
+
+    reasons_unit.push_back (g->pos_lhs_ids[idx1].clause->id);
+    reasons_unit.push_back (g->pos_lhs_ids[idx2].clause->id);
+
+    // already merged: only unit is important
+    if (!rewritting_then && repr_lhs == repr_lit_to_merge) {
+      return;
+    }
+
+    reasons_implication.push_back (g->pos_lhs_ids[other_idx1].clause->id);
+    reasons_implication.push_back (g->pos_lhs_ids[idx1].clause->id);
+    reasons_implication.push_back (g->pos_lhs_ids[idx2].clause->id);
+
+    reasons_back.push_back (g->pos_lhs_ids[other_idx2].clause->id);
+    reasons_back.push_back (g->pos_lhs_ids[idx1].clause->id);
+    reasons_back.push_back (g->pos_lhs_ids[idx2].clause->id);
+  } else {
+    LOG ("learn extra clauses XXXXXXXXXXXXXXXXXXXXXXXXX");
+    const int lhs = g->lhs;
+    const int cond = g->rhs[0];
+    if (rewritting_then) {
+      unsimplified.push_back (-cond);
+      unsimplified.push_back (lhs);
+      simplify_and_add_to_proof_chain (unsimplified);
+      unsimplified.push_back (-cond);
+      unsimplified.push_back (-lhs);
+      simplify_and_add_to_proof_chain (unsimplified);
+    } else {
+      unsimplified.push_back (cond);
+      unsimplified.push_back (-lhs);
+      simplify_and_add_to_proof_chain (unsimplified);
+      unsimplified.push_back (cond);
+      unsimplified.push_back (lhs);
+      simplify_and_add_to_proof_chain (unsimplified);
+    }
+    unsimplified.clear ();
+  }
+}
+
+void Closure::rewrite_ite_gate (Gate *g, int dst, int src) {
+  CADICAL_assert (unsimplified.empty ());
+  if (skip_ite_gate (g))
+    return;
+  if (!gate_contains (g, src))
+    return;
+  LOG (g, "rewriting %d by %d in", src, dst);
+  CADICAL_assert (!g->shrunken);
+  CADICAL_assert (g->rhs.size () == 3);
+  CADICAL_assert (!internal->lrat || g->pos_lhs_ids.size () == 4);
+  auto &rhs = g->rhs;
+  const int lhs = g->lhs;
+  const int cond = g->rhs[0];
+  const int then_lit = g->rhs[1];
+  const int else_lit = g->rhs[2];
+  const int not_lhs = -(lhs);
+  const int not_dst = -(dst);
+  const int not_cond = -(cond);
+  const int not_then_lit = -(then_lit);
+  const int not_else_lit = -(else_lit);
+  Gate_Type new_tag = Gate_Type::And_Gate;
+
+  bool garbage = false;
+  bool shrink = true;
+  const auto git = g->indexed ? table.find (g) : end (table);
+  CADICAL_assert (!g->indexed || git != end (table));
+  CADICAL_assert (*git == g);
+  if (internal->val (cond) && internal->val (then_lit) &&
+      internal->val (else_lit)) { // propagation has set all value anyway
+    LOG (g, "all values are set");
+    CADICAL_assert (internal->val (g->lhs));
+    garbage = true;
+  } else if (internal->val (g->lhs) && internal->val (cond)) {
+    LOG (g, "all values are set 2");
+    CADICAL_assert (internal->val (g->lhs));
+    garbage = true;
+  }
+  // this code is taken one-to-one from kissat
+  else if (src == cond) {
+    if (dst == then_lit) {
+      // then_lit ? then_lit : else_lit
+      // then_lit & then_lit | !then_lit & else_lit
+      // then_lit | !then_lit & else_lit
+      // then_lit | else_lit
+      // !(!then_lit & !else_lit)
+      g->lhs = not_lhs;
+      rhs[0] = not_then_lit;
+      rhs[1] = not_else_lit;
+      if (then_lit == lhs || else_lit == lhs)
+        garbage = true;
+      else
+        garbage = rewrite_ite_gate_to_and (g, src, dst, 1, 3, -dst);
+    } else if (not_dst == then_lit) {
+      // !then_lit ? then_lit : else_lit
+      // !then_lit & then_lit | then_lit & else_lit
+      // then_lit & else_lit
+      rhs[0] = else_lit;
+      CADICAL_assert (rhs[1] == then_lit);
+      garbage = rewrite_ite_gate_to_and (g, src, dst, 0, 2, -dst);
+    } else if (dst == else_lit) {
+      // else_list ? then_lit : else_lit
+      // else_list & then_lit | !else_list & else_lit
+      // else_list & then_lit
+      rhs[0] = else_lit;
+      CADICAL_assert (rhs[1] == then_lit);
+      garbage = rewrite_ite_gate_to_and (g, src, dst, 2, 0, dst);
+    } else if (not_dst == else_lit) {
+      // !else_list ? then_lit : else_lit
+      // !else_list & then_lit | else_lit & else_lit
+      // !else_list & then_lit | else_lit
+      // then_lit | else_lit
+      // !(!then_lit & !else_lit)
+      g->lhs = not_lhs;
+      rhs[0] = not_then_lit;
+      rhs[1] = not_else_lit;
+      if (then_lit == lhs || else_lit == lhs)
+        garbage = true;
+      else
+        garbage = rewrite_ite_gate_to_and (g, src, dst, 3, 1, dst);
+    } else {
+      shrink = false;
+      rhs[0] = dst;
+      rewrite_ite_gate_update_lrat_reasons (g, src, dst);
+    }
+  } else if (src == then_lit) {
+    if (not_dst == g->lhs) { // TODO not in kissat
+      rhs[1] = dst;
+      check_ite_implied (g->lhs, cond, then_lit, else_lit);
+      std::vector<LRAT_ID> reasons_implication, reasons_back, reasons_unit;
+      LOG ("%d = %d ?", g->lhs, -g->rhs[0]);
+      bool learn_units_instead_of_equivalence = false;
+      produce_ite_merge_lhs_then_else_reasons (
+          g, reasons_implication, reasons_back, reasons_unit, true,
+          learn_units_instead_of_equivalence);
+      if (learn_units_instead_of_equivalence) { // it is too hard to produce
+                                                // LRAT chains
+                                                // in this case
+
+        if (internal->lrat)
+          lrat_chain = reasons_unit;
+        learn_congruence_unit (-cond, true);
+        if (-else_lit == lhs) {
+          if (internal->lrat)
+            lrat_chain = reasons_implication;
+          learn_congruence_unit (cond == -lhs ? -else_lit : else_lit, false, true);
+        } else fully_propagate ();
+      } else {
+        if (merge_literals_lrat (g->lhs, else_lit, reasons_implication,
+                                 reasons_back)) {
+          ++internal->stats.congruence.unaries;
+          ++internal->stats.congruence.unary_ites;
+        }
+        if (!internal->unsat) {
+          if (internal->lrat)
+            lrat_chain = reasons_unit;
+          learn_congruence_unit (-cond);
+        }
+      }
+      delete_proof_chain ();
+      garbage = true;
+    } else if (dst == cond) {
+      // cond ? cond : else_lit
+      // cond & cond | !cond & else_lit
+      // cond | !cond & else_lit
+      // cond | else_lit
+      // !(!cond & !else_lit)
+      g->lhs = not_lhs;
+      rhs[0] = not_cond;
+      rhs[1] = not_else_lit;
+      if (else_lit == lhs || cond == lhs)
+        garbage = true;
+      else
+        garbage = rewrite_ite_gate_to_and (g, src, dst, 1, 3, -cond);
+    } else if (not_dst == cond) {
+      // cond ? !cond : else_lit
+      // cond & !cond | !cond & else_lit
+      // !cond & else_lit
+      rhs[0] = not_cond;
+      rhs[1] = else_lit;
+      garbage = rewrite_ite_gate_to_and (g, src, dst, 0, 2, -cond);
+    } else if (dst == else_lit) {
+      // cond ? else_lit : else_lit
+      // else_lit
+      std::vector<LRAT_ID> reasons_implication, reasons_back;
+      produce_ite_merge_then_else_reasons (g, src, dst, reasons_implication,
+                                           reasons_back);
+      if (merge_literals_lrat (lhs, else_lit, reasons_implication,
+                               reasons_back)) {
+        ++internal->stats.congruence.unaries;
+        ++internal->stats.congruence.unary_ites;
+      }
+      delete_proof_chain ();
+      garbage = true;
+    } else if (not_dst == else_lit) {
+      // cond ? !else_lit : else_lit
+      // cond & !else_lit | !cond & else_lit
+      // cond ^ else_lit
+      if (g->lhs == cond) {
+        produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, g->lhs,
+                                                 false);
+        if (internal->lrat) {
+          CADICAL_assert (g->pos_lhs_ids.size () == 2);
+          lrat_chain.push_back (g->pos_lhs_ids[0].clause->id);
+          lrat_chain.push_back (g->pos_lhs_ids[1].clause->id);
+        }
+        learn_congruence_unit (-else_lit);
+        garbage = true;
+      } else {
+        LOG ("changing to xor");
+        new_tag = Gate_Type::XOr_Gate;
+        CADICAL_assert (rhs[0] == cond);
+        rhs[1] = else_lit;
+        CADICAL_assert (!internal->lrat || !g->pos_lhs_ids.empty ());
+        {
+#ifdef LOGGING
+          for (auto litId : g->pos_lhs_ids) {
+            LOG (litId.clause, "%d ->", litId.current_lit);
+          }
+#endif
+          produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, g->lhs,
+                                                   true);
+#ifdef LOGGING
+          for (auto litId : g->pos_lhs_ids) {
+            LOG (litId.clause, "%d ->", litId.current_lit);
+          }
+#endif
+        }
+      }
+    } else {
+      shrink = false;
+      rhs[1] = dst;
+      rewrite_ite_gate_update_lrat_reasons (g, src, dst);
+    }
+  } else {
+    CADICAL_assert (src == else_lit);
+    if (not_dst == g->lhs) { // TODO not in kissat
+      rhs[2] = dst;
+      std::vector<LRAT_ID> reasons_implication, reasons_back, reasons_unit;
+      bool learn_units_instead_of_equivalence = false;
+      produce_ite_merge_lhs_then_else_reasons (
+          g, reasons_implication, reasons_back, reasons_unit, false,
+          learn_units_instead_of_equivalence);
+      if (learn_units_instead_of_equivalence) { // Too hard to produce LRAT
+        if (internal->lrat)
+          lrat_chain = reasons_unit;
+        learn_congruence_unit (cond, true);
+        if (then_lit != lhs) {
+	  LOG ("special case, learning %d",cond == -lhs ? -then_lit : then_lit);
+          if (internal->lrat)
+            lrat_chain = reasons_implication;
+          learn_congruence_unit (cond == -lhs ? -then_lit : then_lit, false, true);
+        } else fully_propagate ();
+      } else {
+        if (merge_literals_lrat (lhs, then_lit, reasons_implication,
+                                 reasons_back)) {
+          ++internal->stats.congruence.unaries;
+          ++internal->stats.congruence.unary_ites;
+        }
+        if (!internal->unsat) {
+          if (internal->lrat)
+            lrat_chain = reasons_unit;
+          learn_congruence_unit (cond);
+        }
+      }
+      delete_proof_chain ();
+      garbage = true;
+    } else if (dst == cond) {
+      // cond ? then_lit : cond
+      // cond & then_lit | !cond & cond
+      // cond & then_lit
+      CADICAL_assert (rhs[0] == cond);
+      CADICAL_assert (rhs[1] == then_lit);
+      garbage = rewrite_ite_gate_to_and (g, src, dst, 2, 0, cond);
+    } else if (not_dst == cond) {
+      // cond ? then_lit : !cond
+      // cond & then_lit | !cond & !cond
+      // cond & then_lit | !cond
+      // then_lit | !cond
+      // !(!then_lit & cond)
+      g->lhs = not_lhs;
+      CADICAL_assert (rhs[0] == cond);
+      rhs[1] = not_then_lit;
+      if (then_lit == lhs || cond == lhs)
+        garbage = true;
+      else
+        garbage = rewrite_ite_gate_to_and (g, src, dst, 3, 1, cond);
+    } else if (dst == then_lit) {
+      // cond ? then_lit : then_lit
+      // then_lit
+      std::vector<LRAT_ID> reasons_implication, reasons_back;
+      produce_ite_merge_then_else_reasons (g, src, dst, reasons_implication,
+                                           reasons_back);
+      if (merge_literals_lrat (lhs, then_lit, reasons_implication,
+                               reasons_back)) {
+        ++internal->stats.congruence.unaries;
+        ++internal->stats.congruence.unary_ites;
+      }
+      garbage = true;
+    } else if (not_dst == then_lit) {
+      // cond ? then_lit : !then_lit
+      // cond & then_lit | !cond & !then_lit
+      // !(cond ^ then_lit)
+      if (lhs == cond) {
+        produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, not_lhs,
+                                                 false);
+        if (internal->lrat) {
+          CADICAL_assert (g->pos_lhs_ids.size () == 2);
+          lrat_chain.push_back (g->pos_lhs_ids[0].clause->id);
+          lrat_chain.push_back (g->pos_lhs_ids[1].clause->id);
+        }
+        learn_congruence_unit (then_lit);
+        garbage = true;
+      } else if (not_lhs == cond) {
+        produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, not_lhs,
+                                                 false);
+        if (internal->lrat) {
+          CADICAL_assert (g->pos_lhs_ids.size () == 2);
+          lrat_chain.push_back (g->pos_lhs_ids[0].clause->id);
+          lrat_chain.push_back (g->pos_lhs_ids[1].clause->id);
+        }
+        learn_congruence_unit (-then_lit);
+        garbage = true;
+      } else if (not_lhs == then_lit) {
+        produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, not_lhs,
+                                                 false);
+        if (internal->lrat) {
+          CADICAL_assert (g->pos_lhs_ids.size () == 2);
+          lrat_chain.push_back (g->pos_lhs_ids[0].clause->id);
+          lrat_chain.push_back (g->pos_lhs_ids[1].clause->id);
+        }
+        learn_congruence_unit (cond);
+        garbage = true;
+      } else {
+        new_tag = Gate_Type::XOr_Gate;
+        g->lhs = not_lhs;
+        CADICAL_assert (rhs[0] == cond);
+        CADICAL_assert (rhs[1] == then_lit);
+        CADICAL_assert (rhs[0] != g->lhs);
+        CADICAL_assert (rhs[1] != g->lhs);
+        produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, not_lhs,
+                                                 false);
+      }
+    } else {
+      shrink = false;
+      rhs[2] = dst;
+      rewrite_ite_gate_update_lrat_reasons (g, src, dst);
+    }
+  }
+  if (!garbage && !internal->unsat) {
+    CADICAL_assert (new_tag != Gate_Type::ITE_Gate || g->lhs != -rhs[1]);
+    CADICAL_assert (new_tag != Gate_Type::ITE_Gate || g->lhs != -rhs[2]);
+    if (shrink) {
+      if (new_tag == Gate_Type::XOr_Gate) {
+        bool negate_lhs = false;
+        if (rhs[0] < 0) {
+          rhs[0] = -rhs[0];
+          negate_lhs = !negate_lhs;
+        }
+        if (rhs[1] < 0) {
+          rhs[1] = -rhs[1];
+          negate_lhs = !negate_lhs;
+        }
+        if (negate_lhs)
+          g->lhs = -g->lhs;
+      }
+      if (internal->vlit (rhs[0]) >
+          internal->vlit (
+              rhs[1])) { // unlike kissat, we need to do it after negating
+        std::swap (rhs[0], rhs[1]);
+        CADICAL_assert (new_tag != Gate_Type::ITE_Gate);
+      }
+      CADICAL_assert (internal->vlit (rhs[0]) < internal->vlit (rhs[1]));
+      CADICAL_assert (!g->shrunken);
+      g->shrunken = true;
+      rhs[2] = 0;
+      g->tag = new_tag;
+      rhs.resize (2);
+      CADICAL_assert (rhs[0] != -rhs[1]);
+      if (new_tag == Gate_Type::XOr_Gate) {
+        if (rhs[0] == -g->lhs || rhs[1] == -g->lhs) {
+          LOG (g, "special XOR:");
+          const int unit = rhs[0] ^ -g->lhs ^ rhs[1];
+          produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, not_lhs,
+                                                   false);
+          if (internal->lrat) {
+            CADICAL_assert (g->pos_lhs_ids.size () == 2);
+            lrat_chain.push_back (g->pos_lhs_ids[0].clause->id);
+            lrat_chain.push_back (g->pos_lhs_ids[1].clause->id);
+          }
+          learn_congruence_unit (unit);
+          garbage = true;
+        } else if (rhs[0] == g->lhs || rhs[1] == g->lhs) {
+          LOG (g, "special XOR:");
+          const int unit = rhs[0] ^ g->lhs ^ rhs[1];
+          produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, not_lhs,
+                                                   false);
+          if (internal->lrat) {
+            CADICAL_assert (g->pos_lhs_ids.size () == 2);
+            lrat_chain.push_back (g->pos_lhs_ids[0].clause->id);
+            lrat_chain.push_back (g->pos_lhs_ids[1].clause->id);
+          }
+          learn_congruence_unit (-unit);
+          garbage = true;
+        } else {
+          int i = 0;
+          bool negated = false;
+          for (int j = 0; j < 2; ++i, ++j) {
+            CADICAL_assert (i <= j);
+            const int lit = rhs[i] = rhs[j];
+            const char v = internal->val (lit);
+            if (v > 0) {
+              --i;
+              negated = !negated;
+            } else if (v < 0) {
+              --i;
+            }
+          }
+          CADICAL_assert (i <= 2);
+          rhs.resize (i);
+          if (negated) {
+            g->lhs = -g->lhs;
+          }
+          if (i != 2) {
+            LOG (g, "removed units");
+          }
+          if (!i)
+            garbage = true;
+          else if (i == 1) {
+#ifdef LOGGING
+            for (auto litId : g->pos_lhs_ids) {
+              LOG (litId.clause, "%d ->", litId.current_lit);
+            }
+#endif
+            produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, g->lhs);
+            CADICAL_assert (!internal->lrat || g->pos_lhs_ids.size () == 2);
+            Clause *c1 = nullptr, *c2 = nullptr;
+            if (internal->lrat) {
+              CADICAL_assert (g->pos_lhs_ids[0].clause);
+              bool rhs_as_src_first =
+                  g->pos_lhs_ids[0].clause->literals[0] == g->lhs ||
+                  g->pos_lhs_ids[0].clause->literals[1] == g->lhs;
+              c1 = (rhs_as_src_first ? g->pos_lhs_ids[0].clause
+                                     : g->pos_lhs_ids[1].clause);
+              c2 = (rhs_as_src_first ? g->pos_lhs_ids[1].clause
+                                     : g->pos_lhs_ids[0].clause);
+              c1 = maybe_promote_tmp_binary_clause (c1);
+              c2 = maybe_promote_tmp_binary_clause (c2);
+            } else {
+              maybe_add_binary_clause (-g->lhs, g->rhs[0]);
+              maybe_add_binary_clause (g->lhs, -g->rhs[0]);
+            }
+            merge_literals_equivalence (g->lhs, g->rhs[0], c1, c2);
+            garbage = true;
+          }
+        }
+        if (!garbage) {
+          CADICAL_assert (rhs[0] != g->lhs);
+          CADICAL_assert (rhs[1] != g->lhs);
+          CADICAL_assert (rhs[0] != -g->lhs);
+          CADICAL_assert (rhs[1] != -g->lhs);
+        }
+      }
+
+      if (!garbage) {
+        g->hash = hash_lits (nonces, g->rhs);
+        LOG (g, "rewritten");
+
+        if (internal->lrat) {
+          if (new_tag == Gate_Type::XOr_Gate) {
+#ifndef CADICAL_NDEBUG
+            std::for_each (begin (g->pos_lhs_ids), end (g->pos_lhs_ids),
+                           [g] (LitClausePair l) {
+                             CADICAL_assert ((size_t) l.clause->size ==
+                                     1 + g->arity ());
+                           });
+#endif
+          } else if (new_tag == Gate_Type::And_Gate) {
+            // we have to get rid of one clause, two become binaries, and
+            // becomes ternary
+
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+            for (auto id : g->pos_lhs_ids) {
+              LOG (id.clause, "clause after rewriting:");
+              CADICAL_assert (id.clause->size == 2);
+            }
+#endif
+            CADICAL_assert (g->pos_lhs_ids.size () == 2 ||
+                    gate_contains (g, g->lhs));
+            CADICAL_assert (g->neg_lhs_ids.size () == 1 ||
+                    gate_contains (g, g->lhs));
+            CADICAL_assert (g->arity () == 2);
+#ifndef CADICAL_NDEBUG
+            std::for_each (
+                begin (g->pos_lhs_ids), end (g->pos_lhs_ids),
+                [] (LitClausePair l) { CADICAL_assert (l.clause->size == 2); });
+#endif
+          } else {
+            CADICAL_assert (false);
+#ifdef WIN32
+            __assume(false);
+#else
+            __builtin_unreachable ();
+#endif
+          }
+        }
+        Gate *h;
+        if (new_tag == Gate_Type::And_Gate) {
+          check_and_gate_implied (g);
+          h = find_and_lits (rhs);
+        } else {
+          CADICAL_assert (new_tag == Gate_Type::XOr_Gate);
+          check_xor_gate_implied (g);
+          h = find_xor_gate (g);
+        }
+        if (h) {
+          garbage = true;
+          if (new_tag == Gate_Type::XOr_Gate) {
+            std::vector<LRAT_ID> reasons_implication, reasons_back;
+            add_xor_matching_proof_chain (g, g->lhs, h->pos_lhs_ids, h->lhs,
+                                          reasons_implication,
+                                          reasons_back);
+            if (merge_literals_lrat (g->lhs, h->lhs, reasons_implication,
+                                     reasons_back))
+              ++internal->stats.congruence.xors;
+          } else {
+            add_ite_turned_and_binary_clauses (g);
+            std::vector<LRAT_ID> reasons_implication, reasons_back;
+            if (internal->lrat)
+              merge_and_gate_lrat_produce_lrat (g, h, reasons_implication,
+                                                reasons_back, false);
+            if (merge_literals_lrat (g->lhs, h->lhs, reasons_implication,
+                                     reasons_back))
+              ++internal->stats.congruence.ands;
+          }
+          delete_proof_chain ();
+        } else {
+          garbage = false;
+          if (g->indexed)
+            remove_gate (git);
+          index_gate (g);
+          CADICAL_assert (g->arity () == 2);
+          for (auto lit : g->rhs)
+            if (lit != dst)
+              if (lit != cond && lit != then_lit && lit != else_lit)
+                connect_goccs (g, lit);
+          if (g->tag == Gate_Type::And_Gate && !internal->lrat)
+            for (auto lit : g->rhs)
+              maybe_add_binary_clause (-g->lhs, lit);
+        }
+      }
+    } else {
+      LOG (g, "rewritten");
+      if (internal->lrat)
+	update_ite_flags (g), check_correct_ite_flags(g);
+      CADICAL_assert (rhs[0] != rhs[1]);
+      CADICAL_assert (rhs[0] != rhs[2]);
+      CADICAL_assert (rhs[1] != rhs[2]);
+      CADICAL_assert (rhs[0] != -(rhs[1]));
+      CADICAL_assert (rhs[0] != -(rhs[2]));
+      CADICAL_assert (rhs[1] != -(rhs[2]));
+      check_ite_gate_implied (g);
+      check_ite_lrat_reasons (g, false);
+      bool negate_lhs;
+      Gate *h = find_ite_gate (g, negate_lhs);
+      CADICAL_assert (lhs == g->lhs);
+      CADICAL_assert (not_lhs == -(g->lhs));
+      if (negate_lhs)
+        g->lhs = -lhs;
+      check_ite_lrat_reasons (g);
+      if (internal->lrat)
+	check_correct_ite_flags (g);
+      if (h) {
+        garbage = true;
+        check_ite_gate_implied (g);
+        check_ite_lrat_reasons (g, false);
+        check_ite_gate_implied (h);
+        check_ite_lrat_reasons (h, false);
+        int normalized_lhs = negate_lhs ? not_lhs : lhs;
+        std::vector<LRAT_ID> extra_reasons_lit, extra_reasons_ulit;
+        add_ite_matching_proof_chain (g, h, normalized_lhs, h->lhs,
+                                      extra_reasons_lit,
+                                      extra_reasons_ulit);
+        if (merge_literals_lrat (normalized_lhs, h->lhs, extra_reasons_lit,
+                                 extra_reasons_ulit))
+          ++internal->stats.congruence.ites;
+        delete_proof_chain ();
+        CADICAL_assert (internal->unsat || chain.empty ());
+      } else {
+        garbage = false;
+        if (g->indexed)
+          remove_gate (git);
+        LOG (g, "normalized");
+        g->hash = hash_lits (nonces, g->rhs);
+        index_gate (g);
+        CADICAL_assert (g->arity () == 3);
+        for (auto lit : g->rhs)
+          if (lit != dst)
+            if (lit != cond && lit != then_lit && lit != else_lit)
+              connect_goccs (g, lit);
+      }
+    }
+  }
+  if (garbage && !internal->unsat)
+    mark_garbage (g);
+
+  CADICAL_assert (chain.empty ());
+}
+
+void Closure::simplify_ite_gate_produce_unit_lrat (Gate *g, int lit,
+                                                   size_t idx1,
+                                                   size_t idx2) {
+  if (!internal->lrat)
+    return;
+  // TODO
+  if (internal->val (lit) > 0)
+    return;
+  CADICAL_assert (internal->lrat);
+  CADICAL_assert (g);
+  CADICAL_assert (idx1 < g->pos_lhs_ids.size ());
+  CADICAL_assert (idx2 < g->pos_lhs_ids.size ());
+  CADICAL_assert (g->pos_lhs_ids.size () == 4);
+
+  CADICAL_assert (idx1 != idx2);
+  Clause *c = g->pos_lhs_ids[idx1].clause;
+  Clause *d = g->pos_lhs_ids[idx2].clause;
+
+  if (g->lhs == -g->rhs[0]) {
+    LOG ("special case of LHS=-cond where only one clause in LRAT is needed is needed");
+    size_t idx = (internal->val (g->rhs[1]) < 0 ? idx2 : idx1);
+    c = produce_rewritten_clause_lrat (g->pos_lhs_ids[idx].clause, g->lhs, false, false);
+    CADICAL_assert (c);
+    // not possible to do this in a single lrat chain
+    push_id_and_rewriting_lrat_unit (c, Rewrite (), lrat_chain, true,
+                                     Rewrite (), g->lhs);
+    CADICAL_assert (d);
+    return;
+  }
+  if (g->lhs == g->rhs[0]) {
+    LOG ("special case of LHS=cond where only one clause in LRAT is needed is needed");
+    size_t idx = (internal->val (g->rhs[1]) > 0 ? idx2 : idx1);
+    c = produce_rewritten_clause_lrat (g->pos_lhs_ids[idx].clause, g->lhs, false, false);
+    CADICAL_assert (c);
+    // not possible to do this in a single lrat chain
+    push_id_and_rewriting_lrat_unit (c, Rewrite (), lrat_chain, true,
+                                     Rewrite (), g->lhs);
+    CADICAL_assert (d);
+    return;
+  }
+
+  c = produce_rewritten_clause_lrat (c, g->lhs, true);
+  if (c) {
+    lrat_chain.push_back (c->id);
+    d = produce_rewritten_clause_lrat (d, g->lhs, true);
+    if (d)
+      lrat_chain.push_back (d->id);
+  } else if (!c) {
+    push_id_and_rewriting_lrat_unit (d, Rewrite (), lrat_chain, true,
+                                     Rewrite (), g->lhs);
+    CADICAL_assert (d);
+    lrat_chain.push_back (d->id);
+  }
+}
+
+// TODO merge
+void Closure::merge_and_gate_lrat_produce_lrat (
+    Gate *g, Gate *h, std::vector<LRAT_ID> &reasons_lrat_src,
+    std::vector<LRAT_ID> &reasons_lrat_usrc, bool remove_units) {
+  CADICAL_assert (internal->lrat);
+  CADICAL_assert (g->tag == Gate_Type::And_Gate);
+  CADICAL_assert (h->tag == Gate_Type::And_Gate);
+  CADICAL_assert (g->neg_lhs_ids.size () <= 1);
+  update_and_gate_build_lrat_chain (g, h, reasons_lrat_src,
+                                    reasons_lrat_usrc, remove_units);
+}
+
+// odd copy of rewrite_ite_gate_lrat_and
+bool Closure::simplify_ite_gate_to_and (Gate *g, size_t idx1, size_t idx2,
+                                        int removed_lit) {
+  CADICAL_assert (internal->lrat_chain.empty ());
+  CADICAL_assert (g->rhs.size () == 3);
+#ifdef LOGGING
+  for (auto litId : g->pos_lhs_ids) {
+    LOG (litId.clause, "%d ->", litId.current_lit);
+  }
+#endif
+  if (g->lhs == -g->rhs[0] || g->lhs == -g->rhs[1]) {
+    if (internal->lrat) {
+      Clause *c = g->pos_lhs_ids[idx1].clause;
+      push_id_and_rewriting_lrat_unit (c, Rewrite (), lrat_chain);
+      CADICAL_assert (!lrat_chain.empty ());
+    }
+    learn_congruence_unit (-g->lhs);
+    return true;
+  }
+  if (!internal->lrat)
+    return false;
+  g->degenerated_and_neg = (g->degenerated_and_neg || g->rhs[1] == -g->lhs || g->rhs[0] == -g->lhs);
+  g->degenerated_and_pos = (g->degenerated_and_pos || g->rhs[0] == g->lhs || g->rhs[1] == g->lhs);
+
+  CADICAL_assert (g->pos_lhs_ids.size () == 4);
+  CADICAL_assert (idx1 < g->pos_lhs_ids.size ());
+  CADICAL_assert (idx2 < g->pos_lhs_ids.size ());
+  int lit = g->pos_lhs_ids[idx2].current_lit, other = g->lhs;
+  size_t new_idx1 = idx1;
+  size_t new_idx2 = idx2;
+  produce_rewritten_clause_lrat_and_clean (g->pos_lhs_ids, g->lhs, new_idx1,
+                                           new_idx2);
+
+  if (g->pos_lhs_ids.size () == 1) {
+    LOG (g, "degenerated AND gate");
+    const int replacement_lit = (g->rhs[1] == g->lhs ? g->rhs[0] : g->rhs[1]);
+    for (auto &litId : g->pos_lhs_ids) {
+      CADICAL_assert (litId.clause);
+      LOG (litId.clause, "%d ->", litId.current_lit);
+      if (litId.current_lit == removed_lit)
+        litId.current_lit = -replacement_lit;
+      if (litId.current_lit == -removed_lit)
+        litId.current_lit = replacement_lit;
+      LOG (litId.clause, "%d ->", litId.current_lit);
+      // TODO we need a replacement index
+      CADICAL_assert (std::find (begin (*litId.clause), end (*litId.clause), litId.current_lit) !=
+              end (*litId.clause));
+      CADICAL_assert (std::find (begin (g->rhs), end (g->rhs), litId.current_lit) !=
+              end (g->rhs));
+    }
+    return false;
+  }
+  CADICAL_assert (new_idx1 < g->pos_lhs_ids.size ());
+  CADICAL_assert (new_idx2 < g->pos_lhs_ids.size ());
+  Clause *c = g->pos_lhs_ids[new_idx1].clause;
+  CADICAL_assert (c->size == 2);
+  CADICAL_assert (new_idx1 != new_idx2);
+  Clause *d = g->pos_lhs_ids[new_idx2].clause;
+  CADICAL_assert (c != d);
+  CADICAL_assert (c);
+  CADICAL_assert (d);
+  g->pos_lhs_ids.erase (std::remove_if (begin (g->pos_lhs_ids),
+                                        end (g->pos_lhs_ids),
+                                        [d] (const LitClausePair &p) {
+                                          return p.clause == d;
+                                        }),
+                        end (g->pos_lhs_ids));
+  CADICAL_assert (g->pos_lhs_ids.size () == 2);
+  CADICAL_assert (lit);
+  CADICAL_assert (other);
+  CADICAL_assert (lit != other);
+  lrat_chain.push_back (c->id);
+  lrat_chain.push_back (d->id);
+  Clause *e = add_tmp_binary_clause (lit, -other);
+
+  auto long_clause =
+      std::find_if (begin (g->pos_lhs_ids), end (g->pos_lhs_ids),
+                    [] (LitClausePair l) { return l.clause->size == 3; });
+  CADICAL_assert (long_clause != end (g->pos_lhs_ids));
+  LOG (long_clause->clause, "new long clause");
+  g->neg_lhs_ids.push_back (*long_clause);
+  g->pos_lhs_ids.erase (long_clause);
+  CADICAL_assert (g->pos_lhs_ids.size () == 1);
+  g->pos_lhs_ids.push_back ({lit, e});
+
+  const int first_lit = g->rhs[0];
+  const int second_lit = g->rhs[1];
+  for (auto &litId : g->pos_lhs_ids) {
+    CADICAL_assert (litId.clause);
+    LOG (litId.clause, "%s ->", LOGLIT (litId.current_lit));
+    if (internal->val (litId.current_lit)) {
+      CADICAL_assert (litId.clause->size == 2);
+      int replacement_lit = 0;
+      for (int i = 0; i < 2; ++i) {
+        if (litId.clause->literals[i] == first_lit) {
+          replacement_lit = first_lit;
+          break;
+        } else if (litId.clause->literals[i] == second_lit) {
+          replacement_lit = second_lit;
+          break;
+        }
+      }
+      CADICAL_assert (replacement_lit);
+
+      litId.current_lit = replacement_lit;
+    } else if (litId.current_lit == removed_lit)
+      litId.current_lit = -g->rhs[0];
+    else if (litId.current_lit == -removed_lit)
+      litId.current_lit = g->rhs[0];
+    LOG (litId.clause, "%d ->", litId.current_lit);
+    // TODO we need a replacement index
+    CADICAL_assert (std::find (begin (g->rhs), end (g->rhs), litId.current_lit) !=
+            end (g->rhs));
+    CADICAL_assert (std::find (begin (*litId.clause), end (*litId.clause),
+                       litId.current_lit) != end (*litId.clause));
+  }
+  return false;
+}
+
+void Closure::merge_ite_gate_same_then_else_lrat (
+    std::vector<LitClausePair> &clauses,
+    std::vector<LRAT_ID> &reasons_implication,
+    std::vector<LRAT_ID> &reasons_back) {
+  CADICAL_assert (clauses.size () == 4);
+  produce_rewritten_clause_lrat_and_clean (clauses);
+  CADICAL_assert (clauses.size () == 4);
+  auto then_imp = clauses[0];
+  auto neg_then_imp = clauses[1];
+  auto else_imp = clauses[2];
+  auto neg_else_imp = clauses[3];
+  reasons_implication.push_back (then_imp.clause->id);
+  reasons_implication.push_back (else_imp.clause->id);
+  reasons_back.push_back (neg_then_imp.clause->id);
+  reasons_back.push_back (neg_else_imp.clause->id);
+}
+
+void Closure::simplify_ite_gate_then_else_set (
+    Gate *g, std::vector<LRAT_ID> &reasons_implication,
+    std::vector<LRAT_ID> &reasons_back, size_t idx1, size_t idx2) {
+  CADICAL_assert (idx1 < g->pos_lhs_ids.size ());
+  CADICAL_assert (idx2 < g->pos_lhs_ids.size ());
+  Clause *c = g->pos_lhs_ids[idx1].clause;
+  Clause *d = g->pos_lhs_ids[idx2].clause;
+  push_id_and_rewriting_lrat_unit (c, Rewrite (), reasons_back, true,
+                                   Rewrite (), g->lhs);
+  push_id_and_rewriting_lrat_unit (d, Rewrite (), reasons_implication, true,
+                                   Rewrite (), g->lhs);
+  LOG (reasons_back, "LRAT");
+  LOG (reasons_implication, "LRAT");
+  // c = produce_rewritten_clause_lrat (c, g->lhs, false);
+  // CADICAL_assert (c);
+  // d = produce_rewritten_clause_lrat (d, g->lhs, false);
+  // CADICAL_assert (d);
+  // const int cond = g->rhs[0];
+  // CADICAL_assert (internal->val (cond));
+  // reasons_implication.push_back(internal->unit_id (internal->val (cond) >
+  // 0 ? cond : -cond)); reasons_implication.push_back(c->id);
+  // reasons_back.push_back(internal->unit_id (internal->val (cond) > 0 ?
+  // cond : -cond)); reasons_back.push_back(d->id);
+}
+
+void Closure::simplify_ite_gate_condition_set (
+    Gate *g, std::vector<LRAT_ID> &reasons_lrat,
+    std::vector<LRAT_ID> &reasons_back_lrat, size_t idx1, size_t idx2) {
+  CADICAL_assert (internal->lrat);
+  Clause *c = g->pos_lhs_ids[idx1].clause;
+  Clause *d = g->pos_lhs_ids[idx2].clause;
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+  const int cond = g->rhs[0];
+  CADICAL_assert (internal->val (cond));
+  LOG ("cond = %d", cond);
+#endif
+#ifdef LOGGING
+  for (auto litid : g->pos_lhs_ids)
+    LOG (litid.clause, "clause in gate:");
+#endif
+  push_id_and_rewriting_lrat_unit (c, Rewrite (), reasons_lrat, true,
+                                   Rewrite (), -g->lhs);
+  push_id_and_rewriting_lrat_unit (d, Rewrite (), reasons_back_lrat, true,
+                                   Rewrite (), g->lhs);
+}
+
+void Closure::simplify_ite_gate (Gate *g) {
+  if (skip_ite_gate (g))
+    return;
+  LOG (g, "simplifying");
+  CADICAL_assert (g->arity () == 3);
+  bool garbage = true;
+  int lhs = g->lhs;
+  auto &rhs = g->rhs;
+  const int cond = rhs[0];
+  const int then_lit = rhs[1];
+  const int else_lit = rhs[2];
+  const signed char v_cond = internal->val (cond);
+  const signed char v_else = internal->val (else_lit);
+  const signed char v_then = internal->val (then_lit);
+  std::vector<LRAT_ID> reasons_lrat, reasons_back_lrat;
+  if (v_cond && v_else && v_then) { // propagation has set all value anyway
+    LOG (g, "all values are set");
+    CADICAL_assert (internal->val (g->lhs));
+    garbage = true;
+  } else if (v_cond > 0) {
+    if (internal->lrat)
+      simplify_ite_gate_condition_set (g, reasons_lrat, reasons_back_lrat,
+                                       0, 1);
+    if (merge_literals_lrat (lhs, then_lit, reasons_lrat,
+                             reasons_back_lrat)) {
+      ++internal->stats.congruence.unary_ites;
+      ++internal->stats.congruence.unaries;
+    }
+  } else if (v_cond < 0) {
+    if (internal->lrat)
+      simplify_ite_gate_condition_set (g, reasons_lrat, reasons_back_lrat,
+                                       2, 3);
+    if (merge_literals_lrat (lhs, else_lit, reasons_lrat,
+                             reasons_back_lrat)) {
+      ++internal->stats.congruence.unary_ites;
+      ++internal->stats.congruence.unaries;
+    }
+  } else {
+    LOG ("then %d: %d; else %d: %d", then_lit, v_then, else_lit, v_else);
+    std::vector<LRAT_ID> extra_reasons, extra_reasons_back;
+    CADICAL_assert (v_then || v_else);
+    if (v_then > 0 && v_else > 0) {
+      simplify_ite_gate_produce_unit_lrat (g, lhs, 1, 3);
+      learn_congruence_unit (lhs);
+    } else if (v_then < 0 && v_else < 0) {
+      simplify_ite_gate_produce_unit_lrat (g, -lhs, 0, 2);
+      learn_congruence_unit (-lhs);
+    } else if (v_then > 0 && v_else < 0) {
+      if (internal->lrat)
+        simplify_ite_gate_then_else_set (g, extra_reasons,
+                                         extra_reasons_back, 1, 2);
+      if (merge_literals_lrat (lhs, cond, extra_reasons,
+                               extra_reasons_back)) {
+        ++internal->stats.congruence.unary_ites;
+        ++internal->stats.congruence.unaries;
+      }
+    } else if (v_then < 0 && v_else > 0) {
+      if (internal->lrat)
+        simplify_ite_gate_then_else_set (g, extra_reasons,
+                                         extra_reasons_back, 0, 3);
+      if (merge_literals_lrat (lhs, -cond, extra_reasons_back,
+                               extra_reasons)) {
+        ++internal->stats.congruence.unary_ites;
+        ++internal->stats.congruence.unaries;
+      }
+    } else {
+      CADICAL_assert (!!v_then + !!v_else == 1);
+      auto git = g->indexed ? table.find (g) : end (table);
+      CADICAL_assert (!g->indexed || git != end (table));
+      if (v_then > 0) {
+        g->lhs = -lhs;
+        rhs[0] = -cond;
+        rhs[1] = -else_lit;
+        simplify_ite_gate_to_and (g, 1, 3, then_lit);
+      } else if (v_then < 0) {
+        rhs[0] = -cond;
+        rhs[1] = else_lit;
+        simplify_ite_gate_to_and (g, 0, 2, -then_lit);
+      } else if (v_else > 0) {
+        g->lhs = -lhs;
+        rhs[0] = -then_lit;
+        rhs[1] = cond;
+        simplify_ite_gate_to_and (g, 3, 1, else_lit);
+      } else {
+        CADICAL_assert (v_else < 0);
+        rhs[0] = then_lit;
+        rhs[1] = cond;
+        simplify_ite_gate_to_and (g, 2, 0, -else_lit);
+      }
+      if (internal->unsat)
+        return;
+      if (internal->vlit (rhs[0]) > internal->vlit (rhs[1]))
+        std::swap (rhs[0], rhs[1]);
+      g->shrunken = true;
+      g->tag = Gate_Type::And_Gate;
+      rhs.resize (2);
+      CADICAL_assert (is_sorted (begin (rhs), end (rhs),
+                         sort_literals_by_var_smaller (internal)));
+      g->hash = hash_lits (nonces, rhs);
+      check_and_gate_implied (g);
+      Gate *h = find_and_lits (rhs);
+      if (h) {
+        CADICAL_assert (garbage);
+        std::vector<LRAT_ID> reasons_lrat, reasons_lrat_back;
+        if (internal->lrat)
+          merge_and_gate_lrat_produce_lrat (g, h, reasons_lrat,
+                                            reasons_lrat_back, false);
+        if (merge_literals_lrat (g->lhs, h->lhs, reasons_lrat,
+                                 reasons_lrat_back)) {
+          ++internal->stats.congruence.ites;
+        }
+      } else {
+        remove_gate (git);
+        index_gate (g);
+        garbage = false;
+        g->hash = hash_lits (nonces, g->rhs);
+        for (auto lit : rhs)
+          if (lit != cond && lit != then_lit && lit != else_lit) {
+            connect_goccs (g, lit);
+          }
+
+        if (rhs[0] == -g->lhs || rhs[1] == -g->lhs)
+          simplify_and_gate (
+              g); // TODO Kissat does not do that, but it has also no
+                  // checks to verify that it cannot happen...
+      }
+    }
+  }
+  if (garbage && !internal->unsat)
+    mark_garbage (g);
+  ++internal->stats.congruence.simplified;
+  ++internal->stats.congruence.simplified_ites;
+}
+
+void Closure::add_ite_matching_proof_chain (
+    Gate *g, Gate *h, int lhs1, int lhs2, std::vector<LRAT_ID> &reasons1,
+    std::vector<LRAT_ID> &reasons2) {
+  check_ite_lrat_reasons (g);
+  check_ite_lrat_reasons (h, false);
+  CADICAL_assert (g->lhs == lhs1);
+  CADICAL_assert (h->lhs == lhs2);
+  if (lhs1 == lhs2)
+    return;
+  if (!internal->proof)
+    return;
+  LOG (g, "starting ITE matching proof chain");
+  LOG (h, "starting ITE matching proof chain with");
+  CADICAL_assert (unsimplified.empty ());
+  CADICAL_assert (chain.empty ());
+  if (internal->lrat)
+    check_correct_ite_flags (g);
+  const auto &rhs = g->rhs;
+  const int8_t flags_g = g->degenerated_ite;
+  const int8_t flags_h = h->degenerated_ite;
+  const int cond = rhs[0];
+  LRAT_ID g_then_id = 0, g_neg_then_id = 0, g_neg_else_id = 0;
+  LRAT_ID h_then_id = 0, h_neg_then_id = 0, h_else_id = 0;
+  LRAT_ID g_else_id = 0, h_neg_else_id = 0;
+  const bool degenerated_g_then = ite_flags_no_then_clauses (flags_g);
+  const bool degenerated_g_else = ite_flags_no_else_clauses (flags_g);
+  const bool degenerated_h_then = ite_flags_no_then_clauses (flags_h);
+  const bool degenerated_h_else = ite_flags_no_else_clauses (flags_h);
+
+  const bool degenerated_g_cond = ite_flags_cond_lhs (flags_g);
+  const bool degenerated_h_cond = ite_flags_cond_lhs (flags_h);
+  CADICAL_assert (!(degenerated_g_cond && degenerated_h_cond));
+
+  const bool degenerated_g_not_cond = ite_flags_neg_cond_lhs (flags_g);
+  const bool degenerated_h_not_cond = ite_flags_neg_cond_lhs (flags_h);
+  CADICAL_assert (!(degenerated_g_not_cond && degenerated_h_not_cond));
+
+  if (internal->lrat) {
+    // the code can produce tautologies in the case that:
+    // a = (c ? a : e)
+    // b = (c ? a : e)
+    // (no clauses with (then) index a/-a)
+    // but also for
+    // a = (a ? t : e)
+    // b = (a ? t : e)
+    // (no clauses with (then) index -a and (else) index e)
+    // and same for
+    // a = (c ? t : a)
+    // b = (c ? t : a)
+    // (no clauses with (then) index a and (else) index -e)
+    LOG (g, "get ids from");
+    CADICAL_assert (g->pos_lhs_ids.size () == 4);
+    auto &g_then_clause = g->pos_lhs_ids[0].clause;
+    g_then_clause =
+      g_then_clause ? produce_rewritten_clause_lrat (g_then_clause, g->lhs, false) : nullptr;
+    if (g_then_clause)
+      g_then_id = g_then_clause->id;
+
+    auto &g_neg_then_clause = g->pos_lhs_ids[1].clause;
+    g_neg_then_clause =
+      g_neg_then_clause ? produce_rewritten_clause_lrat (g_neg_then_clause, g->lhs, false) : nullptr;
+    if (g_neg_then_clause)
+      g_neg_then_id = g_neg_then_clause->id;
+
+    auto &g_else_clause = g->pos_lhs_ids[2].clause;
+    g_else_clause =
+      g_else_clause ? produce_rewritten_clause_lrat (g_else_clause, g->lhs, false) : g_else_clause;
+    if (g_else_clause)
+      g_else_id = g_else_clause->id;
+
+    auto &g_neg_else_clause = g->pos_lhs_ids[3].clause;
+    g_neg_else_clause =
+      g_neg_else_clause ? produce_rewritten_clause_lrat (g_neg_else_clause, g->lhs, false) : nullptr;
+    if (g_neg_else_clause)
+      g_neg_else_id = g_neg_else_clause->id;
+
+    LOG (h, "now clauses from");
+    CADICAL_assert (h->pos_lhs_ids.size () == 4);
+    auto &h_then_clause = h->pos_lhs_ids[0].clause;
+    h_then_clause =
+      h_then_clause ? produce_rewritten_clause_lrat (h_then_clause, h->lhs, false) : nullptr;
+    if (h_then_clause)
+      h_then_id = h_then_clause->id;
+
+    auto &h_neg_then_clause = h->pos_lhs_ids[1].clause;
+    h_neg_then_clause =
+      h_neg_then_clause ? produce_rewritten_clause_lrat (h_neg_then_clause, h->lhs, false) : nullptr;
+    if (h_neg_then_clause)
+      h_neg_then_id = h_neg_then_clause->id;
+
+    auto &h_else_clause = h->pos_lhs_ids[2].clause;
+    h_else_clause =
+      h_else_clause ? produce_rewritten_clause_lrat (h_else_clause, h->lhs, false) : nullptr;
+    if (h_else_clause)
+      h_else_id = h_else_clause->id;
+
+    auto &h_neg_else_clause = h->pos_lhs_ids[3].clause;
+    h_neg_else_clause =
+      h_neg_else_clause ? produce_rewritten_clause_lrat (h_neg_else_clause, h->lhs, false) : nullptr;
+    if (h_neg_else_clause)
+      h_neg_else_id = h_neg_else_clause->id;
+
+  }
+
+  if (degenerated_g_cond) {
+    LOG ("special case: cond = lhs, g degenerated");
+    unsimplified.push_back (-lhs1);
+    unsimplified.push_back (lhs2);
+    LRAT_ID id1 = 0;
+    if (internal->lrat) {
+      lrat_chain.push_back (g_then_id);
+      lrat_chain.push_back (h_neg_then_id);
+    }
+    id1 = simplify_and_add_to_proof_chain (unsimplified);
+
+    unsimplified.clear ();
+    unsimplified.push_back (lhs1);
+    unsimplified.push_back (-lhs2);
+    LRAT_ID id2 = 0;
+    if (internal->lrat) {
+      lrat_chain.push_back (g_neg_else_id);
+      lrat_chain.push_back (h_else_id);
+    }
+    id2 = simplify_and_add_to_proof_chain (unsimplified);
+
+    CADICAL_assert (!internal->lrat || id1);
+    CADICAL_assert (!internal->lrat || id2);
+    reasons1.push_back (id1);
+    reasons2.push_back (id2);
+    unsimplified.clear ();
+    return;
+  }
+
+  if (degenerated_h_cond) {
+    LOG ("special case: cond = lhs, h degenerated");
+    unsimplified.push_back (lhs1); // potentially lhs1 == lhs2
+    unsimplified.push_back (-lhs2);
+    LRAT_ID id1 = 0;
+    if (internal->lrat) {
+      lrat_chain.push_back (h_then_id);
+      lrat_chain.push_back (g_neg_then_id);
+    }
+    id1 = simplify_and_add_to_proof_chain (unsimplified);
+
+    unsimplified.clear ();
+    unsimplified.push_back (-lhs1);
+    unsimplified.push_back (lhs2);
+    LRAT_ID id2 = 0;
+    if (internal->lrat) {
+      lrat_chain.push_back (h_neg_else_id);
+      lrat_chain.push_back (g_else_id);
+    }
+    id2 = simplify_and_add_to_proof_chain (unsimplified);
+
+    CADICAL_assert (!internal->lrat || id1);
+    CADICAL_assert (!internal->lrat || id2);
+    reasons2.push_back (id1);
+    reasons1.push_back (id2);
+    unsimplified.clear ();
+    return;
+  }
+
+  if (degenerated_g_not_cond) {
+    LOG ("special case: cond = -lhs, g degenerated");
+    unsimplified.push_back (lhs1);
+    unsimplified.push_back (-lhs2);
+    LRAT_ID id1 = 0;
+    if (internal->lrat) {
+      CADICAL_assert (g_neg_then_id && h_then_id && g_else_id && h_neg_else_id);
+      lrat_chain.push_back (g_neg_then_id);
+      lrat_chain.push_back (h_then_id);
+    }
+    id1 = simplify_and_add_to_proof_chain (unsimplified);
+
+    unsimplified.clear ();
+    unsimplified.push_back (-lhs1);
+    unsimplified.push_back (lhs2);
+    LRAT_ID id2 = -1;
+
+    if (internal->lrat) {
+      lrat_chain.push_back (g_else_id);
+      lrat_chain.push_back (h_neg_else_id);
+    }
+    id2 = simplify_and_add_to_proof_chain (unsimplified);
+    CADICAL_assert (!internal->lrat || id1);
+    CADICAL_assert (!internal->lrat || id2);
+    reasons2.push_back (id1);
+    reasons1.push_back (id2);
+    unsimplified.clear ();
+    return;
+  }
+
+  if (degenerated_h_not_cond) {
+    LOG ("special case: cond = -lhs, h degenerated");
+    unsimplified.push_back (lhs1);
+    unsimplified.push_back (-lhs2);
+    LRAT_ID id1 = 0;
+    if (internal->lrat) {
+      CADICAL_assert (g_neg_then_id && h_then_id && g_else_id && h_neg_else_id);
+      lrat_chain.push_back (h_neg_then_id);
+      lrat_chain.push_back (g_then_id);
+    }
+    id1 = simplify_and_add_to_proof_chain (unsimplified);
+
+    unsimplified.clear ();
+    unsimplified.push_back (-lhs1);
+    unsimplified.push_back (lhs2);
+    LRAT_ID id2 = -1;
+
+    if (internal->lrat) {
+      lrat_chain.push_back (h_else_id);
+      lrat_chain.push_back (g_neg_else_id);
+    }
+    id2 = simplify_and_add_to_proof_chain (unsimplified);
+    CADICAL_assert (!internal->lrat || id1);
+    CADICAL_assert (!internal->lrat || id2);
+    reasons2.push_back (id1);
+    reasons1.push_back (id2);
+    unsimplified.clear ();
+    return;
+  }
+  
+  LOG ("normal path");
+  CADICAL_assert (!internal->lrat || degenerated_g_then ||
+          (g_then_id && g_neg_then_id));
+  CADICAL_assert (!internal->lrat || degenerated_g_else ||
+          (g_else_id && g_neg_else_id));
+  CADICAL_assert (!internal->lrat || degenerated_h_then ||
+          (h_then_id && h_neg_then_id));
+  CADICAL_assert (!internal->lrat || degenerated_h_else ||
+          (h_else_id && h_neg_else_id));
+  CADICAL_assert (!internal->lrat || g_then_id || h_neg_then_id);
+  CADICAL_assert (!internal->lrat || g_neg_then_id || h_then_id);
+  unsimplified.push_back (-lhs1);
+  unsimplified.push_back (lhs2);
+  unsimplified.push_back (-cond);
+  LRAT_ID id1 = 0;
+  if (degenerated_g_then || degenerated_h_then) {
+    id1 = degenerated_g_then ? h_neg_then_id : g_then_id;
+  } else {
+    if (internal->lrat) {
+      lrat_chain.push_back (g_then_id);
+      lrat_chain.push_back (h_neg_then_id);
+    }
+    id1 = simplify_and_add_to_proof_chain (unsimplified);
+  }
+  unsimplified.pop_back ();
+  unsimplified.push_back (cond);
+
+  LRAT_ID id2 = 0;
+  if (degenerated_g_else || degenerated_h_else) {
+    id2 = degenerated_g_else ? h_neg_else_id : g_else_id;
+  } else {
+    if (internal->lrat) {
+      lrat_chain.push_back (h_neg_else_id);
+      lrat_chain.push_back (g_else_id);
+    }
+    id2 = simplify_and_add_to_proof_chain (unsimplified);
+  }
+  unsimplified.pop_back ();
+
+  unsimplified.clear ();
+  unsimplified.push_back (lhs1);
+  unsimplified.push_back (-lhs2);
+  unsimplified.push_back (-cond);
+  CADICAL_assert (lrat_chain.empty ());
+
+  LRAT_ID id3 = 0;
+  if (degenerated_g_then || degenerated_h_then) {
+    id3 = degenerated_g_then ? h_then_id : g_neg_then_id;
+  } else {
+    if (internal->lrat) {
+      // lrat_chain.push_back (g_then_id);
+      // lrat_chain.push_back (h_neg_then_id);
+      lrat_chain.push_back (g_neg_then_id);
+      lrat_chain.push_back (h_then_id);
+    }
+    id3 = simplify_and_add_to_proof_chain (unsimplified);
+  }
+  unsimplified.pop_back ();
+  unsimplified.push_back (cond);
+  CADICAL_assert (lrat_chain.empty ());
+
+  LRAT_ID id4 = 0;
+  if (degenerated_g_else || degenerated_h_else) {
+    id4 = degenerated_g_else ? h_else_id : g_neg_else_id;
+  } else {
+    if (internal->lrat) {
+      lrat_chain.push_back (g_neg_else_id);
+      lrat_chain.push_back (h_else_id);
+    }
+    id4 = simplify_and_add_to_proof_chain (unsimplified);
+  }
+  unsimplified.pop_back ();
+
+  if (internal->lrat) {
+    CADICAL_assert (!internal->lrat || (id1 && id2 && id3 && id4));
+    reasons1.push_back (id1), reasons1.push_back (id2);
+    reasons2.push_back (id3), reasons2.push_back (id4);
+  }
+
+  unsimplified.clear ();
+
+  LOG ("finished ITE matching proof chain");
+}
+
+Gate *Closure::new_ite_gate (int lhs, int cond, int then_lit, int else_lit,
+                             std::vector<LitClausePair> &&clauses) {
+  CADICAL_assert (chain.empty ());
+  if (else_lit == -then_lit) {
+    if (then_lit < 0)
+      LOG ("skipping ternary XOR %d := %d ^ %d", lhs, cond, -then_lit);
+    else
+      LOG ("skipping ternary XOR %d := %d ^ %d", -lhs, cond, then_lit);
+    return nullptr;
+  }
+  if (else_lit == then_lit) {
+    LOG ("found trivial ITE gate %d := %d ? %d : %d", (lhs), (cond),
+         (then_lit), (else_lit));
+    std::vector<LRAT_ID> reasons_implication, reasons_back;
+    if (internal->lrat) {
+      merge_ite_gate_same_then_else_lrat (clauses, reasons_implication,
+                                   reasons_back);
+    }
+    if (merge_literals_lrat (lhs, then_lit, reasons_implication,
+                             reasons_back))
+      ++internal->stats.congruence.trivial_ite;
+    return 0;
+  }
+
+  rhs.clear ();
+  rhs.push_back (cond);
+  rhs.push_back (then_lit);
+  rhs.push_back (else_lit);
+  LOG ("ITE gate %d = %d ? %d : %d", lhs, cond, then_lit, else_lit);
+
+  bool negate_lhs = false;
+  Gate *g = new Gate;
+  g->lhs = lhs;
+  g->tag = Gate_Type::ITE_Gate;
+  g->rhs = {rhs};
+  g->pos_lhs_ids = clauses;
+#ifdef LOGGING
+  g->id = -1;
+#endif
+  Gate *h = find_ite_gate (g, negate_lhs);
+  if (negate_lhs)
+    lhs = -lhs;
+  g->lhs = lhs;
+  check_ite_gate_implied (g);
+  check_ite_lrat_reasons (
+      g, false); // due to merges done before during AND gate detection!
+
+  if (h) {
+    check_ite_gate_implied (h);
+    std::vector<LRAT_ID> extra_reasons_lit, extra_reasons_ulit;
+    add_ite_matching_proof_chain (h, g, h->lhs, lhs, extra_reasons_lit,
+                                  extra_reasons_ulit);
+    if (merge_literals_lrat (h, g, h->lhs, lhs, extra_reasons_lit,
+                             extra_reasons_ulit)) {
+      ++internal->stats.congruence.ites;
+      LOG ("found merged literals");
+    }
+    delete_proof_chain ();
+    delete g;
+    return h;
+  } else {
+    // do not sort clauses here obviously!
+    // sort (begin (g->rhs), end (g->rhs));
+    g->garbage = false;
+    g->indexed = true;
+    g->shrunken = false;
+    g->hash = hash_lits (nonces, g->rhs);
+    table.insert (g);
+    ++internal->stats.congruence.gates;
+#ifdef LOGGING
+    g->id = fresh_id++;
+#endif
+    LOG (g, "creating new");
+    if (internal->lrat)
+      update_ite_flags (g);
+    check_ite_gate_implied (g);
+    for (auto lit : g->rhs) {
+      connect_goccs (g, lit);
+    }
+  }
+  check_ite_lrat_reasons (g);
+  return g;
+}
+
+void check_ite_lits_normalized (const std::vector<int> &lits) {
+  CADICAL_assert (lits[0] > 0);
+  CADICAL_assert (lits[1] > 0);
+  CADICAL_assert (lits[0] != lits[1]);
+  CADICAL_assert (lits[0] != lits[2]);
+  CADICAL_assert (lits[1] != lits[2]);
+  CADICAL_assert (lits[0] != -lits[1]);
+  CADICAL_assert (lits[0] != -lits[2]);
+  CADICAL_assert (lits[1] != -lits[2]);
+#ifdef CADICAL_NDEBUG
+  (void) lits;
+#endif
+}
+
+void Closure::check_ite_implied (int lhs, int cond, int then_lit,
+                                 int else_lit) {
+  if (internal->lrat)
+    return;
+  check_ternary (cond, -else_lit, lhs);
+  check_ternary (cond, else_lit, -lhs);
+  check_ternary (-cond, -then_lit, lhs);
+  check_ternary (-cond, then_lit, -lhs);
+}
+
+void Closure::check_contained_module_rewriting (Clause *c, int lit,
+                                                bool normalized,
+                                                int except) {
+#ifndef CADICAL_NDEBUG
+  if (lit == except) // happens for degenerated cases
+    except = 0;
+  const int normalize_lit =
+      (lit == except ? except : find_eager_representative (lit));
+  CADICAL_assert (!normalized || lit == -except || normalize_lit == lit);
+  bool found = false;
+  LOG (c, "looking for (normalized) %d in ", lit);
+  for (auto other : *c) {
+    const int normalize_other =
+        (other == except ? except : find_eager_representative (other));
+    LOG ("%d -> %d ", other, normalize_other);
+    CADICAL_assert (!normalized || other == -except || normalize_other == other);
+    if (normalize_other == normalize_lit) {
+      found = true;
+      break;
+    }
+  }
+  CADICAL_assert (found);
+#else
+  (void) c, (void) lit, (void) normalized, (void) except;
+#endif
+}
+
+void Closure::check_ite_lrat_reasons (Gate *g, bool normalized) {
+#ifndef CADICAL_NDEBUG
+  CADICAL_assert (g->tag == Gate_Type::ITE_Gate);
+  if (!internal->lrat)
+    return;
+  CADICAL_assert (g->rhs.size () == 3);
+  CADICAL_assert (is_tautological_ite_gate (g) || g->pos_lhs_ids.size () == 4);
+  CADICAL_assert (g->neg_lhs_ids.empty ());
+  CADICAL_assert (g->pos_lhs_ids.size () == 4);
+#else
+  (void) g, (void) normalized;
+#endif
+}
+
+void Closure::check_ite_gate_implied (Gate *g) {
+  CADICAL_assert (g->tag == Gate_Type::ITE_Gate);
+  if (internal->lrat)
+    return;
+  check_ite_implied (g->lhs, g->rhs[0], g->rhs[1], g->rhs[2]);
+}
+
+void Closure::init_ite_gate_extraction (
+    std::vector<ClauseSize> &candidates) {
+  std::vector<Clause *> ternary;
+  glargecounts.resize (2 * internal->vsize, 0);
+  for (auto c : internal->clauses) {
+    if (c->garbage)
+      continue;
+    if (c->redundant)
+      continue;
+    if (c->size < 3)
+      continue;
+    unsigned size = 0;
+
+    CADICAL_assert (!c->garbage);
+    for (auto lit : *c) {
+      const signed char v = internal->val (lit);
+      if (v < 0)
+        continue;
+      if (v > 0) {
+        LOG (c, "deleting as satisfied due to %d", lit);
+        internal->mark_garbage (c);
+        goto CONTINUE_COUNTING_NEXT_CLAUSE;
+      }
+      if (size == 3)
+        goto CONTINUE_COUNTING_NEXT_CLAUSE;
+      size++;
+    }
+    if (size < 3)
+      continue;
+    CADICAL_assert (size == 3);
+    ternary.push_back (c);
+    LOG (c, "counting original ITE gate base");
+    for (auto lit : *c) {
+      if (!internal->val (lit))
+        ++largecount (lit);
+    }
+  CONTINUE_COUNTING_NEXT_CLAUSE:;
+  }
+
+  for (auto c : ternary) {
+    CADICAL_assert (!c->garbage);
+    CADICAL_assert (!c->redundant);
+    unsigned positive = 0, negative = 0, twice = 0;
+    for (auto lit : *c) {
+      if (internal->val (lit))
+        continue;
+      const int count_not_lit = largecount (-lit);
+      if (!count_not_lit)
+        goto CONTINUE_WITH_NEXT_TERNARY_CLAUSE;
+      const unsigned count_lit = largecount (lit);
+      CADICAL_assert (count_lit);
+      if (count_lit > 1 && count_not_lit > 1)
+        ++twice;
+      if (lit < 0)
+        ++negative;
+      else
+        ++positive;
+    }
+    if (twice < 2)
+      goto CONTINUE_WITH_NEXT_TERNARY_CLAUSE;
+    CADICAL_assert (c->size != 2);
+    for (auto lit : *c)
+      internal->occs (lit).push_back (c);
+    if (positive && negative)
+      candidates.push_back (c);
+  CONTINUE_WITH_NEXT_TERNARY_CLAUSE:;
+  }
+
+  ternary.clear ();
+}
+
+void Closure::reset_ite_gate_extraction () {
+  condbin[0].clear ();
+  condbin[1].clear ();
+  condeq[0].clear ();
+  condeq[1].clear ();
+  glargecounts.clear ();
+  internal->clear_occs ();
+}
+
+void Closure::copy_conditional_equivalences (int lit,
+                                             lit_implications &condbin) {
+  CADICAL_assert (condbin.empty ());
+  for (auto c : internal->occs (lit)) {
+    CADICAL_assert (c->size != 2);
+    int first = 0, second = 0;
+    for (auto other : *c) {
+      if (internal->val (other))
+        continue;
+      if (other == lit)
+        continue;
+      if (!first)
+        first = other;
+      else {
+        CADICAL_assert (!second);
+        second = other;
+      }
+    }
+    CADICAL_assert (first), CADICAL_assert (second);
+    lit_implication p (first, second, c);
+
+    if (internal->vlit (first) < internal->vlit (second)) {
+      CADICAL_assert (p.first == first);
+      CADICAL_assert (p.second == second);
+    } else {
+      CADICAL_assert (internal->vlit (second) < internal->vlit (first));
+      p.swap ();
+      CADICAL_assert (p.first == second);
+      CADICAL_assert (p.second == first);
+    }
+    LOG (c, "literal %d condition binary clause %d %d", lit, first, second);
+    condbin.push_back (p);
+  }
+}
+
+bool less_litpair (lit_equivalence p, lit_equivalence q) {
+  const int a = p.first;
+  const int b = q.first;
+  if (a < b)
+    return true;
+  if (b > a)
+    return false;
+  const int c = p.second;
+  const int d = q.second;
+  return (c < d);
+}
+struct litpair_rank {
+  CaDiCaL::Internal *internal;
+  litpair_rank (Internal *i) : internal (i) {}
+  typedef uint64_t Type;
+  Type operator() (const lit_implication &a) const {
+    uint64_t lita = internal->vlit (a.first);
+    uint64_t litb = internal->vlit (a.second);
+    return (lita << 32) + litb;
+  }
+};
+
+struct litpair_smaller {
+  CaDiCaL::Internal *internal;
+  litpair_smaller (Internal *i) : internal (i) {}
+  bool operator() (const lit_implication &a,
+                   const lit_implication &b) const {
+    const auto s = litpair_rank (internal) (a);
+    const auto t = litpair_rank (internal) (b);
+    return s < t;
+  }
+};
+
+lit_implications::const_iterator
+Closure::find_lit_implication_second_literal (
+    int lit, lit_implications::const_iterator begin,
+    lit_implications::const_iterator end) {
+  LOG ("searching for %d in", lit);
+  for (auto it = begin; it != end; ++it)
+    LOG ("%d [%d]", it->first, it->second);
+  lit_implications::const_iterator found = std::lower_bound (
+      begin, end, lit_implication{lit, lit},
+      [] (const lit_implication &a, const lit_implication &b) {
+        return a.second < b.second;
+      });
+#ifndef CADICAL_NDEBUG
+  auto found2 = std::binary_search (
+      begin, end, lit_implication{lit, lit},
+      [] (const lit_implication &a, const lit_implication &b) {
+        return a.second < b.second;
+      });
+#endif
+
+  if (found < end && found->second == lit) {
+    CADICAL_assert (found2 == (found < end));
+    return found;
+  }
+  return end;
+}
+
+void Closure::search_condeq (int lit, int pos_lit,
+                             lit_implications::const_iterator pos_begin,
+                             lit_implications::const_iterator pos_end,
+                             int neg_lit,
+                             lit_implications::const_iterator neg_begin,
+                             lit_implications::const_iterator neg_end,
+                             lit_equivalences &condeq) {
+  CADICAL_assert (neg_lit == -pos_lit);
+  CADICAL_assert (pos_begin < pos_end);
+  CADICAL_assert (neg_begin < neg_end);
+  CADICAL_assert (pos_begin->first == pos_lit);
+  CADICAL_assert (neg_begin->first == neg_lit);
+  CADICAL_assert (pos_end <= neg_begin || neg_end <= pos_begin);
+  for (lit_implications::const_iterator p = pos_begin; p != pos_end; p++) {
+    const int other = p->second;
+    const int not_other = -other;
+    const lit_implications::const_iterator other_clause =
+        find_lit_implication_second_literal (not_other, neg_begin, neg_end);
+    CADICAL_assert (std::find (begin (*p->clause), end (*p->clause), lit) !=
+            end (*p->clause));
+    if (other_clause != neg_end) {
+      CADICAL_assert (std::find (begin (*other_clause->clause),
+                         end (*other_clause->clause),
+                         neg_lit) != end (*other_clause->clause));
+      CADICAL_assert (std::find (begin (*p->clause), end (*p->clause), other) !=
+              end (*p->clause));
+      lit_equivalence equivalence (neg_lit, other_clause->clause, other,
+                                   p->clause);
+      if (pos_lit > 0) {
+        equivalence.negate_both ();
+      }
+      if (internal->lrat)
+        equivalence.check_invariant ();
+      LOG ("found conditional %d equivalence %d = %d", lit,
+           equivalence.first, equivalence.second);
+      CADICAL_assert (equivalence.first > 0);
+      CADICAL_assert (internal->vlit (equivalence.first) <
+              internal->vlit (equivalence.second));
+      check_ternary (lit, neg_lit, -other);
+      check_ternary (lit, -neg_lit, other);
+      condeq.push_back (equivalence);
+      if (equivalence.second < 0) {
+        lit_equivalence inverse_equivalence =
+            equivalence.swap ().negate_both ();
+        condeq.push_back (inverse_equivalence);
+        if (internal->lrat)
+          inverse_equivalence.check_invariant ();
+      } else {
+        lit_equivalence inverse_equivalence = equivalence.swap ();
+        condeq.push_back (inverse_equivalence);
+        if (internal->lrat)
+          inverse_equivalence.check_invariant ();
+      }
+    }
+  }
+#ifndef LOGGING
+  (void) lit;
+#endif
+}
+
+void Closure::extract_condeq_pairs (int lit, lit_implications &condbin,
+                                    lit_equivalences &condeq) {
+  const lit_implications::const_iterator begin = condbin.cbegin ();
+  const lit_implications::const_iterator end = condbin.cend ();
+  lit_implications::const_iterator pos_begin = begin;
+  int next_lit = 0;
+
+#ifdef LOGGING
+  for (const auto &pair : condbin)
+    LOG ("unsorted conditional %d equivalence %d = %d", lit, pair.first,
+         pair.second);
+#endif
+  LOG ("searching for first positive literal for lit %d", lit);
+  for (;;) {
+    if (pos_begin == end)
+      return;
+    next_lit = pos_begin->first;
+    LOG ("checking %d", next_lit);
+    if (next_lit > 0)
+      break;
+    pos_begin++;
+  }
+
+  for (;;) {
+    CADICAL_assert (pos_begin != end);
+    CADICAL_assert (next_lit == pos_begin->first);
+    CADICAL_assert (next_lit > 0);
+    const int pos_lit = next_lit;
+    lit_implications::const_iterator pos_end = pos_begin + 1;
+    LOG ("searching for first other literal after finding lit %d",
+         next_lit);
+    for (;;) {
+      if (pos_end == end)
+        return;
+      next_lit = pos_end->first;
+      if (next_lit != pos_lit)
+        break;
+      pos_end++;
+    }
+    CADICAL_assert (pos_end != end);
+    CADICAL_assert (next_lit == pos_end->first);
+    const int neg_lit = -pos_lit;
+    if (next_lit != neg_lit) {
+      if (next_lit < 0) {
+        pos_begin = pos_end + 1;
+        LOG ("next_lit %d < 0", next_lit);
+        for (;;) {
+          if (pos_begin == end)
+            return;
+          next_lit = pos_begin->first;
+          if (next_lit > 0)
+            break;
+          pos_begin++;
+        }
+      } else
+        pos_begin = pos_end;
+      continue;
+    }
+    const lit_implications::const_iterator neg_begin = pos_end;
+    lit_implications::const_iterator neg_end = neg_begin + 1;
+    while (neg_end != end) {
+      next_lit = neg_end->first;
+      if (next_lit != neg_lit)
+        break;
+      neg_end++;
+    }
+#ifdef LOGGING
+    for (lit_implications::const_iterator p = pos_begin; p != pos_end; p++)
+      LOG ("conditional %d binary clause %d %d with positive %d", (lit),
+           (p->first), (p->second), (pos_lit));
+    for (lit_implications::const_iterator p = neg_begin; p != neg_end; p++)
+      LOG ("conditional %d binary clause %d %d with negative %d", (lit),
+           (p->first), (p->second), (neg_lit));
+#endif
+    const size_t pos_size = pos_end - pos_begin;
+    const size_t neg_size = neg_end - neg_begin;
+    if (pos_size <= neg_size) {
+      LOG ("searching negation of %zu conditional binary clauses "
+           "with positive %d in %zu conditional binary clauses with %d",
+           pos_size, (pos_lit), neg_size, (neg_lit));
+      search_condeq (lit, pos_lit, pos_begin, pos_end, neg_lit, neg_begin,
+                     neg_end, condeq);
+    } else {
+      LOG ("searching negation of %zu conditional binary clauses "
+           "with negative %d in %zu conditional binary clauses with %d",
+           neg_size, (neg_lit), pos_size, (pos_lit));
+      search_condeq (lit, neg_lit, neg_begin, neg_end, pos_lit, pos_begin,
+                     pos_end, condeq);
+    }
+    if (neg_end == end)
+      return;
+    CADICAL_assert (next_lit == neg_end->first);
+    if (next_lit < 0) {
+      pos_begin = neg_end + 1;
+      for (;;) {
+        if (pos_begin == end)
+          return;
+        next_lit = pos_begin->first;
+        if (next_lit > 0)
+          break;
+        pos_begin++;
+      }
+    } else
+      pos_begin = neg_end;
+  }
+}
+
+void Closure::find_conditional_equivalences (int lit,
+                                             lit_implications &condbin,
+                                             lit_equivalences &condeq) {
+  CADICAL_assert (condbin.empty ());
+  CADICAL_assert (condeq.empty ());
+  CADICAL_assert (internal->occs (lit).size () > 1);
+  copy_conditional_equivalences (lit, condbin);
+  MSORT (internal->opts.radixsortlim, begin (condbin), end (condbin),
+         litpair_rank (this->internal), litpair_smaller (this->internal));
+
+  extract_condeq_pairs (lit, condbin, condeq);
+  MSORT (internal->opts.radixsortlim, begin (condbin), end (condbin),
+         litpair_rank (this->internal), litpair_smaller (this->internal));
+
+#ifdef LOGGING
+  for (auto pair : condeq)
+    LOG ("sorted conditional %d equivalence %d = %d", lit, pair.first,
+         pair.second);
+  LOG ("found %zu conditional %d equivalences", condeq.size (), lit);
+
+#endif
+}
+
+void Closure::merge_condeq (int cond, lit_equivalences &condeq,
+                            lit_equivalences &not_condeq) {
+  LOG ("merging cond for literal %d", cond);
+  auto q = begin (not_condeq);
+  const auto end_not_condeq = end (not_condeq);
+  for (auto p : condeq) {
+    const int lhs = p.first;
+    const int then_lit = p.second;
+    if (internal->lrat)
+      p.check_invariant ();
+    CADICAL_assert (lhs > 0);
+    while (q != end_not_condeq && q->first < lhs)
+      ++q;
+    while (q != end_not_condeq && q->first == lhs) {
+      LOG ("looking when %d at p= %d %d", cond, p.first, p.second);
+      LOG ("looking when %d at %d %d", -cond, q->first, q->second);
+      lit_equivalence not_cond_pair = *q++;
+      const int else_lit = not_cond_pair.second;
+      std::vector<LitClausePair> clauses;
+      if (internal->lrat) {
+        // The then/else literal is the second of the pair, hence the swap
+        // of the reasons
+        CADICAL_assert (p.first_clause && p.second_clause);
+        CADICAL_assert (not_cond_pair.first_clause && not_cond_pair.second_clause);
+        LOG (p.second_clause, "pairing %d", then_lit);
+        LOG (p.first_clause, "pairing %d", -then_lit);
+        LOG (not_cond_pair.second_clause, "pairing %d", else_lit);
+        LOG (not_cond_pair.first_clause, "pairing %d", -else_lit);
+        clauses.push_back (LitClausePair (then_lit, p.second_clause));
+        clauses.push_back (LitClausePair (-then_lit, p.first_clause));
+        clauses.push_back (
+            LitClausePair (else_lit, not_cond_pair.second_clause));
+        clauses.push_back (
+            LitClausePair (-else_lit, not_cond_pair.first_clause));
+        if (internal->lrat)
+          not_cond_pair.check_invariant ();
+      }
+      new_ite_gate (lhs, cond, then_lit, else_lit, std::move (clauses));
+      if (internal->unsat)
+        return;
+    }
+  }
+}
+
+void Closure::extract_ite_gates_of_literal (int lit) {
+  LOG ("search for ITE for literal %d ", lit);
+  find_conditional_equivalences (lit, condbin[0], condeq[0]);
+  if (!condeq[0].empty ()) {
+    find_conditional_equivalences (-lit, condbin[1], condeq[1]);
+    if (!condeq[1].empty ()) {
+      if (lit < 0)
+        merge_condeq (-lit, condeq[0], condeq[1]);
+      else
+        merge_condeq (lit, condeq[1], condeq[0]);
+    }
+  }
+
+  condbin[0].clear ();
+  condbin[1].clear ();
+  condeq[0].clear ();
+  condeq[1].clear ();
+}
+
+void Closure::extract_ite_gates_of_variable (int idx) {
+  const int lit = idx;
+  const int not_lit = -idx;
+
+  auto lit_watches = internal->occs (lit);
+  auto not_lit_watches = internal->occs (not_lit);
+  const size_t size_lit_watches = lit_watches.size ();
+  const size_t size_not_lit_watches = not_lit_watches.size ();
+  if (size_lit_watches <= size_not_lit_watches) {
+    if (size_lit_watches > 1)
+      extract_ite_gates_of_literal (lit);
+  } else {
+    if (size_not_lit_watches > 1)
+      extract_ite_gates_of_literal (not_lit);
+  }
+}
+
+void Closure::extract_ite_gates () {
+  CADICAL_assert (!full_watching);
+  if (!internal->opts.congruenceite)
+    return;
+  START (extractites);
+  std::vector<ClauseSize> candidates;
+
+  init_ite_gate_extraction (candidates);
+
+  for (auto idx : internal->vars) {
+    if (internal->flags (idx).active ()) {
+      extract_ite_gates_of_variable (idx);
+      if (internal->unsat)
+        break;
+    }
+  }
+  // Kissat has an alternative version MERGE_CONDITIONAL_EQUIVALENCES
+  reset_ite_gate_extraction ();
+  STOP (extractites);
+}
+
+/*------------------------------------------------------------------------*/
+void Closure::extract_gates () {
+  START (extract);
+  extract_and_gates ();
+  CADICAL_assert (internal->unsat || lrat_chain.empty ());
+  CADICAL_assert (internal->unsat || chain.empty ());
+  if (internal->unsat || internal->terminated_asynchronously ()) {
+    STOP (extract);
+    return;
+  }
+  extract_xor_gates ();
+  CADICAL_assert (internal->unsat || lrat_chain.empty ());
+  CADICAL_assert (internal->unsat || chain.empty ());
+
+  if (internal->unsat || internal->terminated_asynchronously ()) {
+    STOP (extract);
+    return;
+  }
+  extract_ite_gates ();
+  STOP (extract);
+}
+
+/*------------------------------------------------------------------------*/
+// top level function to extract gate
+bool Internal::extract_gates () {
+  if (unsat)
+    return false;
+  if (!opts.congruence)
+    return false;
+  if (level)
+    backtrack ();
+  if (!propagate ()) {
+    learn_empty_clause ();
+    return false;
+  }
+  if (congruence_delay.bumpreasons.limit) {
+    LOG ("delaying congruence %" PRId64 " more times",
+         congruence_delay.bumpreasons.limit);
+    congruence_delay.bumpreasons.limit--;
+    return false;
+  }
+
+  // to remove false literals from clauses
+  // It makes the technique stronger as long clauses
+  // can become binary / ternary
+  //  garbage_collection ();
+
+  const int64_t old = stats.congruence.congruent;
+  const int old_merged = stats.congruence.congruent;
+
+  // congruencebinary is already doing it (and more actually)
+  if (!internal->opts.congruencebinaries) {
+    const bool dedup = opts.deduplicate;
+    opts.deduplicate = true;
+    mark_duplicated_binary_clauses_as_garbage ();
+    opts.deduplicate = dedup;
+  }
+  ++stats.congruence.rounds;
+  clear_watches ();
+  //  connect_binary_watches ();
+
+  START_SIMPLIFIER (congruence, CONGRUENCE);
+  Closure closure (this);
+
+  closure.init_closure ();
+  CADICAL_assert (unsat || closure.chain.empty ());
+  CADICAL_assert (unsat || lrat_chain.empty ());
+  closure.extract_binaries ();
+  CADICAL_assert (unsat || closure.chain.empty ());
+  CADICAL_assert (unsat || lrat_chain.empty ());
+  closure.extract_gates ();
+  CADICAL_assert (unsat || closure.chain.empty ());
+  CADICAL_assert (unsat || lrat_chain.empty ());
+  internal->clear_watches ();
+  internal->connect_watches ();
+  closure.reset_extraction ();
+
+  if (!unsat) {
+    closure.find_units ();
+    CADICAL_assert (unsat || closure.chain.empty ());
+    CADICAL_assert (unsat || lrat_chain.empty ());
+    if (!internal->unsat) {
+      closure.find_equivalences ();
+      CADICAL_assert (unsat || closure.chain.empty ());
+      CADICAL_assert (unsat || lrat_chain.empty ());
+
+      if (!unsat) {
+        const int propagated = closure.propagate_units_and_equivalences ();
+        CADICAL_assert (unsat || closure.chain.empty ());
+        if (!unsat && propagated)
+          closure.forward_subsume_matching_clauses ();
+      }
+    }
+  }
+
+  closure.reset_closure ();
+  internal->clear_watches ();
+  internal->connect_watches ();
+  if (!internal->unsat) {
+    propagated2 = propagated = 0;
+    propagate ();
+  }
+  CADICAL_assert (closure.new_unwatched_binary_clauses.empty ());
+  internal->reset_occs ();
+  internal->reset_noccs ();
+  CADICAL_assert (!internal->occurring ());
+  CADICAL_assert (lrat_chain.empty ());
+
+  const int64_t new_merged = stats.congruence.congruent;
+
+#ifndef CADICAL_QUIET
+  phase ("congruence-phase", stats.congruence.rounds, "merged %ld literals",
+         new_merged - old_merged);
+#endif
+  if (!unsat && !internal->propagate ())
+    unsat = true;
+
+  STOP_SIMPLIFIER (congruence, CONGRUENCE);
+  report ('c', !opts.reportall && !(stats.congruence.congruent - old));
+#ifndef CADICAL_NDEBUG
+  size_t watched = 0;
+  for (auto v : vars) {
+    for (auto sgn = -1; sgn <= 1; sgn += 2) {
+      const int lit = v * sgn;
+      for (auto w : watches (lit)) {
+        if (w.binary ())
+          CADICAL_assert (!w.clause->garbage);
+        if (w.clause->garbage)
+          continue;
+        ++watched;
+        LOG (w.clause, "watched");
+      }
+    }
+  }
+  LOG ("and now the clauses:");
+  size_t nb_clauses = 0;
+  for (auto c : clauses) {
+    if (c->garbage)
+      continue;
+    LOG (c, "watched");
+    ++nb_clauses;
+  }
+  CADICAL_assert (watched == nb_clauses * 2);
+#endif
+  CADICAL_assert (!internal->occurring ());
+
+  if (new_merged == old_merged) {
+    congruence_delay.bumpreasons.interval++;
+  } else {
+    congruence_delay.bumpreasons.interval /= 2;
+  }
+
+  LOG ("delay congruence internal %" PRId64,
+       congruence_delay.bumpreasons.interval);
+  congruence_delay.bumpreasons.limit =
+      congruence_delay.bumpreasons.interval;
+
+  return new_merged != old_merged;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_constrain.cpp b/src/sat/cadical/cadical_constrain.cpp
new file mode 100644
index 000000000..47f14e3d9
--- /dev/null
+++ b/src/sat/cadical/cadical_constrain.cpp
@@ -0,0 +1,70 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::constrain (int lit) {
+  if (lit)
+    constraint.push_back (lit);
+  else {
+    if (level)
+      backtrack ();
+    LOG (constraint, "shrinking constraint");
+    bool satisfied_constraint = false;
+    const vector<int>::const_iterator end = constraint.end ();
+    vector<int>::iterator i = constraint.begin ();
+    for (vector<int>::const_iterator j = i; j != end; j++) {
+      int tmp = marked (*j);
+      if (tmp > 0) {
+        LOG ("removing duplicated literal %d from constraint", *j);
+      } else if (tmp < 0) {
+        LOG ("tautological since both %d and %d occur in constraint", -*j,
+             *j);
+        satisfied_constraint = true;
+        break;
+      } else {
+        tmp = val (*j);
+        if (tmp < 0) {
+          LOG ("removing falsified literal %d from constraint clause", *j);
+        } else if (tmp > 0) {
+          LOG ("satisfied constraint with literal %d", *j);
+          satisfied_constraint = true;
+          break;
+        } else {
+          *i++ = *j;
+          mark (*j);
+        }
+      }
+    }
+    constraint.resize (i - constraint.begin ());
+    for (const auto &lit : constraint)
+      unmark (lit);
+    if (satisfied_constraint)
+      constraint.clear ();
+    else if (constraint.empty ()) {
+      unsat_constraint = true;
+      if (!conflict_id)
+        marked_failed = false; // allow to trigger failing ()
+    } else
+      for (const auto lit : constraint)
+        freeze (lit);
+  }
+}
+
+bool Internal::failed_constraint () { return unsat_constraint; }
+
+void Internal::reset_constraint () {
+  for (auto lit : constraint)
+    melt (lit);
+  LOG ("cleared %zd constraint literals", constraint.size ());
+  constraint.clear ();
+  unsat_constraint = false;
+  marked_failed = true;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_contract.cpp b/src/sat/cadical/cadical_contract.cpp
new file mode 100644
index 000000000..7485ff4aa
--- /dev/null
+++ b/src/sat/cadical/cadical_contract.cpp
@@ -0,0 +1,33 @@
+#include "global.h"
+
+#ifndef CADICAL_NCONTRACTS
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+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 ();
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+#endif
diff --git a/src/sat/cadical/cadical_cover.cpp b/src/sat/cadical/cadical_cover.cpp
new file mode 100644
index 000000000..0d3253e98
--- /dev/null
+++ b/src/sat/cadical/cadical_cover.cpp
@@ -0,0 +1,710 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Covered clause elimination (CCE) is described in our short LPAR-10 paper
+// and later in more detail in our JAIR'15 article.  Actually implement
+// the asymmetric version which adds asymmetric literals too but still call
+// it 'CCE' in the following (and not 'ACCE').  This implementation provides
+// a simplified and cleaner version of the one implemented before in
+// Lingeling. We still follow quite closely the original description in the
+// literature, which is based on asymmetric literal addition (ALA) and
+// covered literal addition (CLA).  Both can be seen as kind of propagation,
+// where the literals in the original and then extended clause are assigned
+// to false, and the literals on the trail (actually we use our own 'added'
+// stack for that) make up the extended clause.   The ALA steps can be
+// implemented by simple propagation (copied from 'propagate.cpp') using
+// watches, while the CLA steps need full occurrence lists to determine the
+// resolution candidate clauses.  The CCE is successful if a conflict is
+// found during ALA steps or if during a CLA step all resolution candidates
+// of a literal on the trail are satisfied (the extended clause is blocked).
+
+struct Coveror {
+  std::vector<int> added;        // acts as trail
+  std::vector<int> extend;       // extension stack for witness
+  std::vector<int> covered;      // clause literals or added through CLA
+  std::vector<int> intersection; // of literals in resolution candidates
+
+  size_t alas, clas; // actual number of ALAs and CLAs
+
+  struct {
+    size_t added, covered;
+  } next; // propagate next ...
+
+  Coveror () : alas (0), clas (0) {}
+};
+
+/*------------------------------------------------------------------------*/
+
+// Push on the extension stack a clause made up of the given literal, the
+// original clause (initially copied to 'covered') and all the added covered
+// literals so far.  The given literal will act as blocking literal for that
+// clause, if CCE is successful.  Only in this case, this private extension
+// stack is copied to the actual extension stack of the solver.  Note, that
+// even though all 'added' clauses correspond to the extended clause, we
+// only need to save the original and added covered literals.
+
+inline void Internal::cover_push_extension (int lit, Coveror &coveror) {
+  coveror.extend.push_back (0);
+  coveror.extend.push_back (lit); // blocking literal comes first
+  bool found = false;
+  for (const auto &other : coveror.covered)
+    if (lit == other)
+      CADICAL_assert (!found), found = true;
+    else
+      coveror.extend.push_back (other);
+  CADICAL_assert (found);
+  (void) found;
+}
+
+// Successful covered literal addition (CLA) step.
+
+inline void Internal::covered_literal_addition (int lit, Coveror &coveror) {
+  require_mode (COVER);
+  CADICAL_assert (level == 1);
+  cover_push_extension (lit, coveror);
+  for (const auto &other : coveror.intersection) {
+    LOG ("covered literal addition %d", other);
+    CADICAL_assert (!vals[other]), CADICAL_assert (!vals[-other]);
+    set_val (other, -1);
+    coveror.covered.push_back (other);
+    coveror.added.push_back (other);
+    coveror.clas++;
+  }
+  coveror.next.covered = 0;
+}
+
+// Successful asymmetric literal addition (ALA) step.
+
+inline void Internal::asymmetric_literal_addition (int lit,
+                                                   Coveror &coveror) {
+  require_mode (COVER);
+  CADICAL_assert (level == 1);
+  LOG ("initial asymmetric literal addition %d", lit);
+  CADICAL_assert (!vals[lit]), CADICAL_assert (!vals[-lit]);
+  set_val (lit, -1);
+  coveror.added.push_back (lit);
+  coveror.alas++;
+  coveror.next.covered = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// In essence copied and adapted from 'propagate' in 'propagate.cpp'. Since
+// this function is also a hot-spot here in 'cover' we specialize it in the
+// same spirit as 'probe_propagate' and 'vivify_propagate'.  Please refer to
+// the detailed comments for 'propagate' in 'propagate.cpp' for details.
+
+bool Internal::cover_propagate_asymmetric (int lit, Clause *ignore,
+                                           Coveror &coveror) {
+  require_mode (COVER);
+  stats.propagations.cover++;
+  CADICAL_assert (val (lit) < 0);
+  bool subsumed = false;
+  LOG ("asymmetric literal propagation of %d", lit);
+  Watches &ws = watches (lit);
+  const const_watch_iterator eow = ws.end ();
+  watch_iterator j = ws.begin ();
+  const_watch_iterator i = j;
+  while (!subsumed && i != eow) {
+    const Watch w = *j++ = *i++;
+    if (w.clause == ignore)
+      continue; // costly but necessary here ...
+    const signed char b = val (w.blit);
+    if (b > 0)
+      continue;
+    if (w.clause->garbage)
+      j--;
+    else if (w.binary ()) {
+      if (b < 0) {
+        LOG (w.clause, "found subsuming");
+        subsumed = true;
+      } else
+        asymmetric_literal_addition (-w.blit, coveror);
+    } else {
+      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 {
+        const int size = w.clause->size;
+        const const_literal_iterator end = lits + size;
+        const literal_iterator middle = lits + w.clause->pos;
+        literal_iterator k = middle;
+        signed char v = -1;
+        int r = 0;
+        while (k != end && (v = val (r = *k)) < 0)
+          k++;
+        if (v < 0) {
+          k = lits + 2;
+          CADICAL_assert (w.clause->pos <= size);
+          while (k != middle && (v = val (r = *k)) < 0)
+            k++;
+        }
+        w.clause->pos = k - lits;
+        CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
+        if (v > 0)
+          j[-1].blit = r;
+        else if (!v) {
+          LOG (w.clause, "unwatch %d in", lit);
+          lits[1] = r;
+          *k = lit;
+          watch_literal (r, lit, w.clause);
+          j--;
+        } else if (!u) {
+          CADICAL_assert (v < 0);
+          asymmetric_literal_addition (-other, coveror);
+        } else {
+          CADICAL_assert (u < 0), CADICAL_assert (v < 0);
+          LOG (w.clause, "found subsuming");
+          subsumed = true;
+          break;
+        }
+      }
+    }
+  }
+  if (j != i) {
+    while (i != eow)
+      *j++ = *i++;
+    ws.resize (j - ws.begin ());
+  }
+  return subsumed;
+}
+
+// Covered literal addition (which needs full occurrence lists).  The
+// function returns 'true' if the extended clause is blocked on 'lit.'
+
+bool Internal::cover_propagate_covered (int lit, Coveror &coveror) {
+  require_mode (COVER);
+
+  CADICAL_assert (val (lit) < 0);
+  if (frozen (lit)) {
+    LOG ("no covered propagation on frozen literal %d", lit);
+    return false;
+  }
+
+  stats.propagations.cover++;
+
+  LOG ("covered propagation of %d", lit);
+  CADICAL_assert (coveror.intersection.empty ());
+
+  Occs &os = occs (-lit);
+  const auto end = os.end ();
+  bool first = true;
+
+  // Compute the intersection of the literals in all the clauses with
+  // '-lit'.  If all these clauses are double satisfied then we know that
+  // the extended clauses (in 'added') is blocked.  All literals in the
+  // intersection can be added as covered literal. As soon the intersection
+  // becomes empty (during traversal of clauses with '-lit') we abort.
+
+  for (auto i = os.begin (); i != end; i++) {
+
+    Clause *c = *i;
+    if (c->garbage)
+      continue;
+
+    // First check whether clause is 'blocked', i.e., is double satisfied.
+
+    bool blocked = false;
+    for (const auto &other : *c) {
+      if (other == -lit)
+        continue;
+      const signed char tmp = val (other);
+      if (tmp < 0)
+        continue;
+      if (tmp > 0) {
+        blocked = true;
+        break;
+      }
+    }
+    if (blocked) { // ... if 'c' is double satisfied.
+      LOG (c, "blocked");
+      continue; // with next clause with '-lit'.
+    }
+
+    if (first) {
+
+      // Copy and mark literals of first clause.
+
+      for (const auto &other : *c) {
+        if (other == -lit)
+          continue;
+        const signed char tmp = val (other);
+        if (tmp < 0)
+          continue;
+        CADICAL_assert (!tmp);
+        coveror.intersection.push_back (other);
+        mark (other);
+      }
+
+      first = false;
+
+    } else {
+
+      // Unmark all literals in current clause.
+
+      for (const auto &other : *c) {
+        if (other == -lit)
+          continue;
+        signed char tmp = val (other);
+        if (tmp < 0)
+          continue;
+        CADICAL_assert (!tmp);
+        tmp = marked (other);
+        if (tmp > 0)
+          unmark (other);
+      }
+
+      // Then remove from intersection all marked literals.
+
+      const auto end = coveror.intersection.end ();
+      auto j = coveror.intersection.begin ();
+      for (auto k = j; k != end; k++) {
+        const int other = *j++ = *k;
+        const int tmp = marked (other);
+        CADICAL_assert (tmp >= 0);
+        if (tmp)
+          j--, unmark (other); // remove marked and unmark it
+        else
+          mark (other); // keep unmarked and mark it
+      }
+      const size_t new_size = j - coveror.intersection.begin ();
+      coveror.intersection.resize (new_size);
+
+      if (!coveror.intersection.empty ())
+        continue;
+
+      // No covered literal addition candidates in the intersection left!
+      // Move this clause triggering early abort to the beginning.
+      // This is a common move to front strategy to minimize effort.
+
+      auto begin = os.begin ();
+      while (i != begin) {
+        auto prev = i - 1;
+        *i = *prev;
+        i = prev;
+      }
+      *begin = c;
+
+      break; // early abort ...
+    }
+  }
+
+  bool res = false;
+  if (first) {
+    LOG ("all resolution candidates with %d blocked", -lit);
+    CADICAL_assert (coveror.intersection.empty ());
+    cover_push_extension (lit, coveror);
+    res = true;
+  } else if (coveror.intersection.empty ()) {
+    LOG ("empty intersection of resolution candidate literals");
+  } else {
+    LOG (coveror.intersection,
+         "non-empty intersection of resolution candidate literals");
+    covered_literal_addition (lit, coveror);
+    unmark (coveror.intersection);
+    coveror.intersection.clear ();
+    coveror.next.covered = 0; // Restart covering.
+  }
+
+  unmark (coveror.intersection);
+  coveror.intersection.clear ();
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::cover_clause (Clause *c, Coveror &coveror) {
+
+  require_mode (COVER);
+  CADICAL_assert (!c->garbage);
+
+  LOG (c, "trying covered clauses elimination on");
+  bool satisfied = false;
+  for (const auto &lit : *c)
+    if (val (lit) > 0)
+      satisfied = true;
+
+  if (satisfied) {
+    LOG (c, "clause already satisfied");
+    mark_garbage (c);
+    return false;
+  }
+
+  CADICAL_assert (coveror.added.empty ());
+  CADICAL_assert (coveror.extend.empty ());
+  CADICAL_assert (coveror.covered.empty ());
+
+  CADICAL_assert (!level);
+  level = 1;
+  LOG ("assuming literals of candidate clause");
+  for (const auto &lit : *c) {
+    if (val (lit))
+      continue;
+    asymmetric_literal_addition (lit, coveror);
+    coveror.covered.push_back (lit);
+  }
+
+  bool tautological = false;
+
+  coveror.next.added = coveror.next.covered = 0;
+
+  while (!tautological) {
+    if (coveror.next.added < coveror.added.size ()) {
+      const int lit = coveror.added[coveror.next.added++];
+      tautological = cover_propagate_asymmetric (lit, c, coveror);
+    } else if (coveror.next.covered < coveror.covered.size ()) {
+      const int lit = coveror.covered[coveror.next.covered++];
+      tautological = cover_propagate_covered (lit, coveror);
+    } else
+      break;
+  }
+
+  if (tautological) {
+    if (coveror.extend.empty ()) {
+      stats.cover.asymmetric++;
+      stats.cover.total++;
+      LOG (c, "asymmetric tautological");
+    } else {
+      stats.cover.blocked++;
+      stats.cover.total++;
+      // Only copy extension stack if successful.
+      int prev = INT_MIN;
+      bool already_pushed = false;
+      int64_t last_id = 0;
+      LOG (c, "covered tautological");
+      CADICAL_assert (clause.empty ());
+      LOG (coveror.extend, "extension = ");
+      for (const auto &other : coveror.extend) {
+        if (!prev) {
+          // are we finishing a clause?
+          if (already_pushed) {
+            // add missing literals that are not needed for covering
+            // but avoid RAT proofs
+            for (auto i = 0, j = 0; i < c->size; ++i, ++j) {
+              const int lit = c->literals[i];
+              if (j >= (int) coveror.covered.size () ||
+                  c->literals[i] != coveror.covered[j]) {
+                --j;
+                LOG ("adding lit %d not needed for ATA", lit);
+                clause.push_back (lit);
+                external->push_clause_literal_on_extension_stack (lit);
+              }
+            }
+          }
+          if (proof && already_pushed) {
+            if (lrat)
+              lrat_chain.push_back (c->id);
+            LOG ("LEARNING clause with id %" PRId64, last_id);
+            proof->add_derived_clause (last_id, false, clause, lrat_chain);
+            proof->weaken_plus (last_id, clause);
+            lrat_chain.clear ();
+          }
+          last_id = ++clause_id;
+          external->push_zero_on_extension_stack ();
+          external->push_witness_literal_on_extension_stack (other);
+          external->push_zero_on_extension_stack ();
+          external->push_id_on_extension_stack (last_id);
+          external->push_zero_on_extension_stack ();
+          clause.clear ();
+          already_pushed = true;
+        }
+        if (other) {
+          external->push_clause_literal_on_extension_stack (other);
+          clause.push_back (other);
+          LOG (clause, "current clause is");
+        }
+        prev = other;
+      }
+
+      if (proof) {
+        // add missing literals that are not needed for covering
+        // but avoid RAT proofs
+        for (auto i = 0, j = 0; i < c->size; ++i, ++j) {
+          const int lit = c->literals[i];
+          if (j >= (int) coveror.covered.size () ||
+              c->literals[i] != coveror.covered[j]) {
+            --j;
+            LOG ("adding lit %d not needed for ATA", lit);
+            clause.push_back (lit);
+            external->push_clause_literal_on_extension_stack (lit);
+          }
+        }
+        if (lrat)
+          lrat_chain.push_back (c->id);
+        proof->add_derived_clause (last_id, false, clause, lrat_chain);
+        proof->weaken_plus (last_id, clause);
+        lrat_chain.clear ();
+      }
+      clause.clear ();
+
+      mark_garbage (c);
+    }
+  }
+
+  // Backtrack and 'unassign' all literals.
+
+  CADICAL_assert (level == 1);
+  for (const auto &lit : coveror.added)
+    set_val (lit, 0);
+  level = 0;
+
+  coveror.covered.clear ();
+  coveror.extend.clear ();
+  coveror.added.clear ();
+
+  return tautological;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Not yet tried and larger clauses are tried first.
+
+struct clause_covered_or_smaller {
+  bool operator() (const Clause *a, const Clause *b) {
+    if (a->covered && !b->covered)
+      return true;
+    if (!a->covered && b->covered)
+      return false;
+    return a->size < b->size;
+  }
+};
+
+int64_t Internal::cover_round () {
+
+  if (unsat)
+    return 0;
+
+  init_watches ();
+  connect_watches (true); // irredundant watches only is enough
+
+  int64_t delta = stats.propagations.search;
+  delta *= 1e-3 * opts.covereffort;
+  if (delta < opts.covermineff)
+    delta = opts.covermineff;
+  if (delta > opts.covermaxeff)
+    delta = opts.covermaxeff;
+  delta = max (delta, ((int64_t) 2) * active ());
+
+  PHASE ("cover", stats.cover.count,
+         "covered clause elimination limit of %" PRId64 " propagations",
+         delta);
+
+  int64_t limit = stats.propagations.cover + delta;
+
+  init_occs ();
+
+  vector<Clause *> schedule;
+  Coveror coveror;
+
+  // First connect all clauses and find all not yet tried clauses.
+  //
+#ifndef CADICAL_QUIET
+  int64_t untried = 0;
+#endif
+  //
+  for (auto c : clauses) {
+    CADICAL_assert (!c->frozen);
+    if (c->garbage)
+      continue;
+    if (c->redundant)
+      continue;
+    bool satisfied = false, allfrozen = true;
+    for (const auto &lit : *c)
+      if (val (lit) > 0) {
+        satisfied = true;
+        break;
+      } else if (allfrozen && !frozen (lit))
+        allfrozen = false;
+    if (satisfied) {
+      mark_garbage (c);
+      continue;
+    }
+    if (allfrozen) {
+      c->frozen = true;
+      continue;
+    }
+    for (const auto &lit : *c)
+      occs (lit).push_back (c);
+    if (c->size < opts.coverminclslim)
+      continue;
+    if (c->size > opts.covermaxclslim)
+      continue;
+    if (c->covered)
+      continue;
+    schedule.push_back (c);
+#ifndef CADICAL_QUIET
+    untried++;
+#endif
+  }
+
+  if (schedule.empty ()) {
+
+    PHASE ("cover", stats.cover.count, "no previously untried clause left");
+
+    for (auto c : clauses) {
+      if (c->garbage)
+        continue;
+      if (c->redundant)
+        continue;
+      if (c->frozen) {
+        c->frozen = false;
+        continue;
+      }
+      if (c->size < opts.coverminclslim)
+        continue;
+      if (c->size > opts.covermaxclslim)
+        continue;
+      CADICAL_assert (c->covered);
+      c->covered = false;
+      schedule.push_back (c);
+    }
+  } else { // Mix of tried and not tried clauses ....
+
+    for (auto c : clauses) {
+      if (c->garbage)
+        continue;
+      if (c->redundant)
+        continue;
+      if (c->frozen) {
+        c->frozen = false;
+        continue;
+      }
+      if (c->size < opts.coverminclslim)
+        continue;
+      if (c->size > opts.covermaxclslim)
+        continue;
+      if (!c->covered)
+        continue;
+      schedule.push_back (c);
+    }
+  }
+
+  stable_sort (schedule.begin (), schedule.end (),
+               clause_covered_or_smaller ());
+
+#ifndef CADICAL_QUIET
+  const size_t scheduled = schedule.size ();
+  PHASE ("cover", stats.cover.count,
+         "scheduled %zd clauses %.0f%% with %" PRId64 " untried %.0f%%",
+         scheduled, percent (scheduled, stats.current.irredundant), untried,
+         percent (untried, scheduled));
+#endif
+
+  // Heuristically it should be beneficial to intersect with smaller clauses
+  // first, since then the chances are higher that the intersection of
+  // resolution candidates becomes emptier earlier.
+
+  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 (!terminated_asynchronously () && !schedule.empty () &&
+         stats.propagations.cover < limit) {
+    Clause *c = schedule.back ();
+    schedule.pop_back ();
+    c->covered = true;
+    if (cover_clause (c, coveror))
+      covered++;
+  }
+
+#ifndef CADICAL_QUIET
+  const size_t remain = schedule.size ();
+  const size_t tried = scheduled - remain;
+  PHASE ("cover", stats.cover.count,
+         "eliminated %" PRId64 " covered clauses out of %zd tried %.0f%%",
+         covered, tried, percent (covered, tried));
+  if (remain)
+    PHASE ("cover", stats.cover.count,
+           "remaining %zu clauses %.0f%% untried", remain,
+           percent (remain, scheduled));
+  else
+    PHASE ("cover", stats.cover.count, "all scheduled clauses tried");
+#endif
+  reset_occs ();
+  reset_watches ();
+
+  return covered;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::cover () {
+
+  if (!opts.cover)
+    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
+  // literal addition step which (empirically) conflicts with flushing
+  // during restoring clauses (see 'regr00{48,51}.trace') even though
+  // flushing during restore is disabled by default (as is covered clause
+  // elimination).  The consequence of combining these two options
+  // ('opts.cover' and 'opts.restoreflush') can thus produce incorrect
+  // witness reconstruction and thus invalid witnesses.  This is quite
+  // infrequent (one out of half billion mobical test cases) but as the two
+  // regression traces show, does happen. Thus we disable the combination.
+  //
+  if (opts.restoreflush)
+    return false;
+
+  START_SIMPLIFIER (cover, COVER);
+
+  stats.cover.count++;
+
+  // During variable elimination unit clauses can be generated which need to
+  // be propagated properly over redundant clauses too.  Since variable
+  // elimination avoids to have occurrence lists and watches at the same
+  // time this propagation is delayed until the end of variable elimination.
+  // Since we want to interleave CCE with it, we have to propagate here.
+  // Otherwise this triggers inconsistencies.
+  //
+  if (propagated < trail.size ()) {
+    init_watches ();
+    connect_watches (); // need to propagated over all clauses!
+    LOG ("elimination produced %zd units",
+         (size_t) (trail.size () - propagated));
+    if (!propagate ()) {
+      LOG ("propagating units before covered clause elimination "
+           "results in empty clause");
+      learn_empty_clause ();
+      CADICAL_assert (unsat);
+    }
+    reset_watches ();
+  }
+  CADICAL_assert (unsat || propagated == trail.size ());
+
+  int64_t covered = cover_round ();
+
+  STOP_SIMPLIFIER (cover, COVER);
+  report ('c', !opts.reportall && !covered);
+
+  return covered;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_decide.cpp b/src/sat/cadical/cadical_decide.cpp
new file mode 100644
index 000000000..0874cffd7
--- /dev/null
+++ b/src/sat/cadical/cadical_decide.cpp
@@ -0,0 +1,258 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// This function determines the next decision variable on the queue, without
+// actually removing it from the decision queue, e.g., calling it multiple
+// times without any assignment will return the same result.  This is of
+// course used below in 'decide' but also in 'reuse_trail' to determine the
+// largest decision level to backtrack to during 'restart' without changing
+// the assigned variables (if 'opts.restartreusetrail' is non-zero).
+
+int Internal::next_decision_variable_on_queue () {
+  int64_t searched = 0;
+  int res = queue.unassigned;
+  while (val (res))
+    res = link (res).prev, searched++;
+  if (searched) {
+    stats.searched += searched;
+    update_queue_unassigned (res);
+  }
+  LOG ("next queue decision variable %d bumped %" PRId64 "", res,
+       bumped (res));
+  return res;
+}
+
+// This function determines the best decision with respect to score.
+//
+int Internal::next_decision_variable_with_best_score () {
+  int res = 0;
+  for (;;) {
+    res = scores.front ();
+    if (!val (res))
+      break;
+    (void) scores.pop_front ();
+  }
+  LOG ("next decision variable %d with score %g", res, score (res));
+  return res;
+}
+
+int Internal::next_decision_variable () {
+  if (use_scores ())
+    return next_decision_variable_with_best_score ();
+  else
+    return next_decision_variable_on_queue ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Implements phase saving as well using a target phase during
+// 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)
+    phase = phases.forced[idx]; // swapped with opts.forcephase case!
+  if (!phase && opts.forcephase)
+    phase = initial_phase;
+  if (!phase && target)
+    phase = phases.target[idx];
+  if (!phase)
+    phase = phases.saved[idx];
+
+  // The following should not be necessary and in some version we had even
+  // a hard 'COVER' CADICAL_assertion here to check for this.   Unfortunately it
+  // triggered for some users and we could not get to the root cause of
+  // 'phase' still not being set here.  The logic for phase and target
+  // saving is pretty complex, particularly in combination with local
+  // search, and to avoid running in such an issue in the future again, we
+  // now use this 'defensive' code here, even though such defensive code is
+  // considered bad programming practice.
+  //
+  if (!phase)
+    phase = initial_phase;
+
+  return phase * idx;
+}
+
+// The likely phase of an variable used in 'collect' for optimizing
+// co-location of clauses likely accessed together during search.
+
+int Internal::likely_phase (int idx) { return decide_phase (idx, false); }
+
+/*------------------------------------------------------------------------*/
+
+// adds new level to control and trail
+//
+void Internal::new_trail_level (int lit) {
+  level++;
+  control.push_back (Level (lit, trail.size ()));
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::satisfied () {
+  if ((size_t) level < assumptions.size () + (!!constraint.size ()))
+    return false;
+  if (num_assigned < (size_t) max_var)
+    return false;
+  CADICAL_assert (num_assigned == (size_t) max_var);
+  if (propagated < trail.size ())
+    return false;
+  size_t assigned = num_assigned;
+  return (assigned == (size_t) max_var);
+}
+
+bool Internal::better_decision (int lit, int other) {
+  int lit_idx = abs (lit);
+  int other_idx = abs (other);
+  if (stable)
+    return stab[lit_idx] > stab[other_idx];
+  else
+    return btab[lit_idx] > btab[other_idx];
+}
+
+// Search for the next decision and assign it to the saved phase.  Requires
+// that not all variables are assigned.
+
+int Internal::decide () {
+  CADICAL_assert (!satisfied ());
+  START (decide);
+  int res = 0;
+  if ((size_t) level < assumptions.size ()) {
+    const int lit = assumptions[level];
+    CADICAL_assert (assumed (lit));
+    const signed char tmp = val (lit);
+    if (tmp < 0) {
+      LOG ("assumption %d falsified", lit);
+      res = 20;
+    } else if (tmp > 0) {
+      LOG ("assumption %d already satisfied", lit);
+      new_trail_level (0);
+      LOG ("added pseudo decision level");
+      notify_decision ();
+    } else {
+      LOG ("deciding assumption %d", lit);
+      search_assume_decision (lit);
+    }
+  } else if ((size_t) level == assumptions.size () && constraint.size ()) {
+
+    int satisfied_lit = 0;  // The literal satisfying the constrain.
+    int unassigned_lit = 0; // Highest score unassigned literal.
+    int previous_lit = 0;   // Move satisfied literals to the front.
+
+    const size_t size_constraint = constraint.size ();
+
+#ifndef CADICAL_NDEBUG
+    unsigned sum = 0;
+    for (auto lit : constraint)
+      sum += lit;
+#endif
+    for (size_t i = 0; i != size_constraint; i++) {
+
+      // Get literal and move 'constraint[i] = constraint[i-1]'.
+
+      int lit = constraint[i];
+      constraint[i] = previous_lit;
+      previous_lit = lit;
+
+      const signed char tmp = val (lit);
+      if (tmp < 0) {
+        LOG ("constraint literal %d falsified", lit);
+        continue;
+      }
+
+      if (tmp > 0) {
+        LOG ("constraint literal %d satisfied", lit);
+        satisfied_lit = lit;
+        break;
+      }
+
+      CADICAL_assert (!tmp);
+      LOG ("constraint literal %d unassigned", lit);
+
+      if (!unassigned_lit || better_decision (lit, unassigned_lit))
+        unassigned_lit = lit;
+    }
+
+    if (satisfied_lit) {
+
+      constraint[0] = satisfied_lit; // Move satisfied to the front.
+
+      LOG ("literal %d satisfies constraint and "
+           "is implied by assumptions",
+           satisfied_lit);
+
+      new_trail_level (0);
+      LOG ("added pseudo decision level for constraint");
+      notify_decision ();
+
+    } else {
+
+      // Just move all the literals back.  If we found an unsatisfied
+      // literal then it will be satisfied (most likely) at the next
+      // decision and moved then to the first position.
+
+      if (size_constraint) {
+
+        for (size_t i = 0; i + 1 != size_constraint; i++)
+          constraint[i] = constraint[i + 1];
+
+        constraint[size_constraint - 1] = previous_lit;
+      }
+
+      if (unassigned_lit) {
+
+        LOG ("deciding %d to satisfy constraint", unassigned_lit);
+        search_assume_decision (unassigned_lit);
+
+      } else {
+
+        LOG ("failing constraint");
+        unsat_constraint = true;
+        res = 20;
+      }
+    }
+
+#ifndef CADICAL_NDEBUG
+    for (auto lit : constraint)
+      sum -= lit;
+    CADICAL_assert (!sum); // Checksum of literal should not change!
+#endif
+
+  } else {
+
+    int decision = ask_decision ();
+    if ((size_t) level < assumptions.size () ||
+        ((size_t) level == assumptions.size () && constraint.size ())) {
+      // Forced backtrack below pseudo decision levels.
+      // So one of the two branches above will handle it.
+      STOP (decide);
+      res = decide (); // STARTS and STOPS profiling
+      START (decide);
+    } else {
+      stats.decisions++;
+      if (!decision) {
+        int idx = next_decision_variable ();
+        const bool target = (opts.target > 1 || (stable && opts.target));
+        decision = decide_phase (idx, target);
+      }
+      search_assume_decision (decision);
+    }
+  }
+  if (res)
+    marked_failed = false;
+  STOP (decide);
+  return res;
+}
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_decompose.cpp b/src/sat/cadical/cadical_decompose.cpp
new file mode 100644
index 000000000..9081321b4
--- /dev/null
+++ b/src/sat/cadical/cadical_decompose.cpp
@@ -0,0 +1,739 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::decompose_analyze_binary_chain (DFS *dfs, int from) {
+  if (!lrat)
+    return;
+  LOG ("binary chain starting at %d", from);
+  DFS &from_dfs = dfs[vlit (from)];
+  Clause *reason = from_dfs.parent;
+  if (!reason)
+    return;
+  CADICAL_assert (reason->size == 2);
+  mini_chain.push_back (reason->id);
+  int other = reason->literals[0];
+  other = other == from ? -reason->literals[1] : -other;
+  Flags &f = flags (other);
+  if (f.seen)
+    return;
+  f.seen = true;
+  analyzed.push_back (other);
+  decompose_analyze_binary_chain (dfs, other);
+}
+
+vector<Clause *> Internal::decompose_analyze_binary_clauses (DFS *dfs,
+                                                             int from) {
+  vector<Clause *> result;
+  LOG ("binary chain starting at %d", from);
+  DFS &from_dfs = dfs[vlit (from)];
+  Clause *reason = from_dfs.parent;
+  while (reason) {
+    result.push_back (reason);
+    CADICAL_assert (reason->size == 2);
+    int other = reason->literals[0];
+    other = other == from ? -reason->literals[1] : -other;
+    Flags &f = flags (other);
+    if (f.seen)
+      break;
+    f.seen = true;
+    analyzed.push_back (other);
+    from = other;
+    DFS &from_dfs = dfs[vlit (from)];
+    reason = from_dfs.parent;
+  }
+  return result;
+}
+
+void Internal::decompose_conflicting_scc_lrat (DFS *dfs, vector<int> &scc) {
+  if (!lrat)
+    return;
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (mini_chain.empty ());
+  for (auto &lit : scc) {
+    Flags &f = flags (lit);
+    if (f.seen)
+      return;
+    f.seen = true;
+    analyzed.push_back (lit);
+    decompose_analyze_binary_chain (dfs, lit);
+    for (auto p = mini_chain.rbegin (); p != mini_chain.rend (); p++) {
+      lrat_chain.push_back (*p);
+    }
+    mini_chain.clear ();
+  }
+  clear_analyzed_literals ();
+}
+
+void Internal::build_lrat_for_clause (
+    const vector<vector<Clause *>> &dfs_chains, bool invert) {
+  CADICAL_assert (lrat);
+  LOG ("building chain for not subsumed clause");
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (sign_marked.empty ());
+  // build chain for each replaced literal
+  for (const auto lit : clause) {
+    auto other = lit;
+    if (val (other) > 0) {
+      if (marked_decomposed (other))
+        continue;
+      mark_decomposed (other);
+      int64_t id = unit_id (other);
+      lrat_chain.push_back (id);
+      continue;
+    }
+    CADICAL_assert (mini_chain.empty ());
+    for (auto p : dfs_chains[vlit (other)]) {
+      if (marked_decomposed (other))
+        continue;
+      mark_decomposed (other);
+      int implied = p->literals[0];
+      implied = implied == other ? -p->literals[1] : -implied;
+      LOG ("ADDED %d -> %d (%" PRId64 ")", implied, other, p->id);
+      other = implied;
+      mini_chain.push_back (p->id);
+      if (val (implied) <= 0)
+        continue;
+      if (marked_decomposed (implied))
+        break;
+      mark_decomposed (implied);
+      int64_t id = unit_id (implied);
+      mini_chain.push_back (id);
+      break;
+    }
+    if (invert)
+      for (auto p = mini_chain.rbegin (); p != mini_chain.rend (); p++)
+        lrat_chain.push_back (*p);
+    else
+      for (auto p = mini_chain.begin (); p != mini_chain.end (); p++)
+        lrat_chain.push_back (*p);
+    mini_chain.clear ();
+  }
+  clear_sign_marked_literals ();
+  LOG (lrat_chain, "lrat_chain:");
+}
+
+void Internal::clear_sign_marked_literals () {
+  LOG ("clearing %zd marked literals", sign_marked.size ());
+  for (const auto &lit : sign_marked) {
+    // CADICAL_assert (marked_signed (lit));  violated on purpose in factor
+    unmark_decomposed (lit);
+  }
+  sign_marked.clear ();
+}
+
+// This performs one round of Tarjan's algorithm, e.g., equivalent literal
+// detection and substitution, on the whole formula.  We might want to
+// repeat it since its application might produce new binary clauses or
+// units. Such units might even result in an empty clause.
+
+bool Internal::decompose_round () {
+
+  if (!opts.decompose)
+    return false;
+  if (unsat)
+    return false;
+  if (terminated_asynchronously ())
+    return false;
+
+  CADICAL_assert (!level);
+
+  START_SIMPLIFIER (decompose, DECOMP);
+
+  stats.decompositions++;
+
+  const size_t size_dfs = 2 * (1 + (size_t) max_var);
+  DFS *dfs = new DFS[size_dfs];
+  DeferDeleteArray<DFS> dfs_delete (dfs);
+  int *reprs = new int[size_dfs];
+  DeferDeleteArray<int> reprs_delete (reprs);
+  clear_n (reprs, size_dfs);
+  vector<vector<Clause *>> dfs_chains;
+  dfs_chains.resize (size_dfs);
+  if (lrat) {
+    for (size_t i = 0; i > size_dfs; i++) {
+      vector<Clause *> empty;
+      dfs_chains[i] = empty;
+    }
+  }
+
+  int substituted = 0;
+#ifndef CADICAL_QUIET
+  int non_trivial_sccs = 0;
+  int before = active ();
+#endif
+  unsigned dfs_idx = 0;
+
+  vector<int> work; // depth first search working stack
+  vector<int> scc;  // collects members of one SCC
+
+  // The binary implication graph might have disconnected components and
+  // thus we have in general to start several depth first searches.
+
+  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;
+      if (dfs[vlit (root)].min == TRAVERSED)
+        continue; // skip traversed
+      LOG ("new dfs search starting at root %d", root);
+      CADICAL_assert (work.empty ());
+      CADICAL_assert (scc.empty ());
+      work.push_back (root);
+      while (!unsat && !work.empty ()) {
+        int parent = work.back ();
+        DFS &parent_dfs = dfs[vlit (parent)];
+        if (parent_dfs.min == TRAVERSED) { // skip traversed
+          CADICAL_assert (reprs[vlit (parent)]);
+          work.pop_back ();
+        } else {
+          CADICAL_assert (!reprs[vlit (parent)]);
+
+          // Go over all implied literals, thus need to iterate over all
+          // binary watched clauses with the negation of 'parent'.
+
+          Watches &ws = watches (-parent);
+
+          // Two cases: Either the node has never been visited before, i.e.,
+          // it's depth first search index is zero, then perform the
+          // 'pre-fix' work before visiting it's children.  Otherwise all
+          // it's children and nodes reachable from those children have been
+          // visited and their minimum reachable depth first search index
+          // has been computed.  This second case is the 'post-fix' work.
+
+          if (parent_dfs.idx) { // post-fix
+
+            work.pop_back (); // 'parent' done
+
+            // Get the minimum reachable depth first search index reachable
+            // from the children of 'parent'.
+
+            unsigned new_min = parent_dfs.min;
+
+            for (const auto &w : ws) {
+              if (!w.binary ())
+                continue;
+              const int child = w.blit;
+              if (!active (child))
+                continue;
+              DFS &child_dfs = dfs[vlit (child)];
+              if (new_min > child_dfs.min)
+                new_min = child_dfs.min;
+            }
+
+            LOG ("post-fix work dfs search %d index %u reaches minimum %u",
+                 parent, parent_dfs.idx, new_min);
+
+            if (parent_dfs.idx == new_min) { // entry to SCC
+
+              // All nodes on the 'scc' stack after and including 'parent'
+              // are in the same SCC.  Their representative is computed as
+              // the smallest literal (index-wise) in the SCC.  If the SCC
+              // contains both a literal and its negation, then the formula
+              // becomes unsatisfiable.
+
+              if (lrat) {
+                CADICAL_assert (analyzed.empty ());
+                int other, first = 0;
+                bool conflicting = false;
+                size_t j = scc.size ();
+                do {
+                  CADICAL_assert (j > 0);
+                  other = scc[--j];
+                  if (!first || vlit (other) < vlit (first))
+                    first = other;
+                  Flags &f = flags (other);
+                  if (other == -parent) {
+                    conflicting = true; // conflicting scc
+                  }
+                  if (f.seen) {
+                    continue; // also conflicting scc
+                  }
+                  f.seen = true;
+                  analyzed.push_back (other);
+                } while (other != parent);
+
+                CADICAL_assert (!conflicting || first > 0);
+                vector<int> to_justify;
+                if (conflicting) {
+                  LOG ("conflicting scc simulating up at %d", parent);
+                  to_justify.push_back (-parent);
+                } else
+                  to_justify.push_back (first);
+                while (!to_justify.empty ()) {
+                  const int next = to_justify.back ();
+                  to_justify.pop_back ();
+                  Watches &next_ws = watches (-next);
+                  for (const auto &w : next_ws) {
+                    if (!w.binary ())
+                      continue;
+                    const int child = w.blit;
+                    if (!active (child))
+                      continue;
+                    if (!flags (child).seen)
+                      continue;
+                    DFS &child_dfs = dfs[vlit (child)];
+                    if (child_dfs.parent)
+                      continue;
+                    child_dfs.parent = w.clause;
+                    to_justify.push_back (child);
+                  }
+                }
+
+                clear_analyzed_literals ();
+              }
+
+              int other, repr = parent;
+#ifndef CADICAL_QUIET
+              int size = 0;
+#endif
+              CADICAL_assert (!scc.empty ());
+              size_t j = scc.size ();
+              do {
+                CADICAL_assert (j > 0);
+                other = scc[--j];
+                if (other == -parent) {
+                  LOG ("both %d and %d in one SCC", parent, -parent);
+                  if (lrat) {
+                    Flags &f = flags (-parent);
+                    f.seen = true;
+                    analyzed.push_back (-parent);
+                    decompose_analyze_binary_chain (dfs, parent);
+                    for (auto p : mini_chain)
+                      lrat_chain.push_back (p);
+                    mini_chain.clear ();
+                  }
+                  assign_unit (parent);
+#ifndef CADICAL_NDEBUG
+                  bool ok =
+#endif
+                      propagate ();
+                  CADICAL_assert (!ok);
+                  learn_empty_clause ();
+                  lrat_chain.clear ();
+                } else {
+                  if (abs (other) < abs (repr))
+                    repr = other;
+#ifndef CADICAL_QUIET
+                  size++;
+#endif
+                }
+              } while (!unsat && other != parent);
+
+              if (unsat)
+                break;
+#ifndef CADICAL_QUIET
+              LOG ("SCC of representative %d of size %d", repr, size);
+#endif
+              do {
+                CADICAL_assert (!scc.empty ());
+                other = scc.back ();
+                scc.pop_back ();
+                dfs[vlit (other)].min = TRAVERSED;
+                if (frozen (other)) {
+                  reprs[vlit (other)] = other;
+                  continue;
+                }
+                reprs[vlit (other)] = repr;
+                if (other == repr)
+                  continue;
+                substituted++;
+                LOG ("literal %d in SCC of %d", other, repr);
+                if (!lrat)
+                  continue;
+                CADICAL_assert (mini_chain.empty ());
+                Flags &f = flags (repr);
+                f.seen = true;
+                analyzed.push_back (repr);
+                // no need to reverse dfs_chain because this is handled by
+                // build_lrat_for_clause.
+                dfs_chains[vlit (other)] =
+                    decompose_analyze_binary_clauses (dfs, other);
+                clear_analyzed_literals ();
+              } while (other != parent);
+
+#ifndef CADICAL_QUIET
+              if (size > 1)
+                non_trivial_sccs++;
+#endif
+
+            } else {
+
+              // Current node 'parent' is in a non-trivial SCC but is not
+              // the entry point of the SCC in this depth first search, so
+              // keep it on the SCC stack until the entry point is reached.
+
+              parent_dfs.min = new_min;
+            }
+
+          } else { // pre-fix
+
+            dfs_idx++;
+            CADICAL_assert (dfs_idx < TRAVERSED);
+            parent_dfs.idx = parent_dfs.min = dfs_idx;
+            scc.push_back (parent);
+
+            LOG ("pre-fix work dfs search %d index %u", parent, dfs_idx);
+
+            // Now traverse all the children in the binary implication
+            // graph but keep 'parent' on the stack for 'post-fix' work.
+
+            for (const auto &w : ws) {
+              if (!w.binary ())
+                continue;
+              const int child = w.blit;
+              if (!active (child))
+                continue;
+              DFS &child_dfs = dfs[vlit (child)];
+              if (child_dfs.idx)
+                continue;
+              work.push_back (child);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  erase_vector (work);
+  erase_vector (scc);
+  // delete [] dfs; need to postpone until after changing clauses...
+
+  // Only keep the representatives 'repr' mapping.
+
+  PHASE ("decompose", stats.decompositions,
+         "%d non-trivial sccs, %d substituted %.2f%%", non_trivial_sccs,
+         substituted, percent (substituted, before));
+
+  bool new_unit = false, new_binary_clause = false;
+
+  // Finally, mark substituted literals as such and push the equivalences of
+  // the substituted literals to their representative on the extension
+  // stack to fix an assignment during 'extend'.
+  // It is also necessary to do so for proper IDRUP/LIDRUP/Resolution proofs
+
+  vector<int64_t> decompose_ids;
+  const size_t size = 2 * (1 + (size_t) max_var);
+  decompose_ids.resize (size);
+
+  for (auto idx : vars) {
+    if (!substituted)
+      break;
+    if (unsat)
+      break;
+    if (!active (idx))
+      continue;
+    int other = reprs[vlit (idx)];
+    if (other == idx)
+      continue;
+    CADICAL_assert (!flags (other).eliminated ());
+    CADICAL_assert (!flags (other).substituted ());
+
+    LOG ("marking equivalence of %d and %d", idx, other);
+    CADICAL_assert (clause.empty ());
+    CADICAL_assert (lrat_chain.empty ());
+    clause.push_back (other);
+    clause.push_back (-idx);
+    if (lrat) {
+      build_lrat_for_clause (dfs_chains);
+      CADICAL_assert (!lrat_chain.empty ());
+    }
+
+    const int64_t id1 = ++clause_id;
+    if (proof) {
+      proof->add_derived_clause (id1, false, clause, lrat_chain);
+      proof->weaken_minus (id1, clause);
+    }
+    external->push_binary_clause_on_extension_stack (id1, -idx, other);
+
+    decompose_ids[vlit (-idx)] = id1;
+
+    lrat_chain.clear ();
+    clause.clear ();
+
+    CADICAL_assert (clause.empty ());
+    CADICAL_assert (lrat_chain.empty ());
+    clause.push_back (idx);
+    clause.push_back (-other);
+    if (lrat) {
+      build_lrat_for_clause (dfs_chains);
+      CADICAL_assert (!lrat_chain.empty ());
+    }
+    const int64_t id2 = ++clause_id;
+    if (proof) {
+      proof->add_derived_clause (id2, false, clause, lrat_chain);
+      proof->weaken_minus (id2, clause);
+    }
+    external->push_binary_clause_on_extension_stack (id2, idx, -other);
+    decompose_ids[vlit (idx)] = id2;
+
+    clause.clear ();
+    lrat_chain.clear ();
+  }
+
+  vector<Clause *> postponed_garbage;
+
+  // Now go over all clauses and find clause which contain literals that
+  // should be substituted by their representative.
+
+  size_t clauses_size = clauses.size ();
+#ifndef CADICAL_QUIET
+  size_t garbage = 0, replaced = 0;
+#endif
+  for (size_t i = 0; substituted && !unsat && i < clauses_size; i++) {
+    Clause *c = clauses[i];
+    if (c->garbage)
+      continue;
+    int j, size = c->size;
+    for (j = 0; j < size; j++) {
+      const int lit = c->literals[j];
+      if (reprs[vlit (lit)] != lit)
+        break;
+    }
+
+    if (j == size)
+      continue;
+
+#ifndef CADICAL_QUIET
+    replaced++;
+#endif
+    LOG (c, "first substituted literal %d in", substituted);
+
+    // Now copy the result to 'clause'.  Substitute literals if they have a
+    // different representative.  Skip duplicates and false literals.  If a
+    // literal occurs in both phases or is assigned to true the clause is
+    // satisfied and can be marked as garbage.
+
+    CADICAL_assert (clause.empty ());
+    CADICAL_assert (lrat_chain.empty ());
+    CADICAL_assert (analyzed.empty ());
+    bool satisfied = false;
+
+    for (int k = 0; !satisfied && k < size; k++) {
+      const int lit = c->literals[k];
+      signed char tmp = val (lit);
+      if (tmp > 0)
+        satisfied = true;
+      else if (tmp < 0) {
+        if (!lrat)
+          continue;
+        Flags &f = flags (lit);
+        if (f.seen)
+          continue;
+        f.seen = true;
+        analyzed.push_back (lit);
+        int64_t id = unit_id (-lit);
+        lrat_chain.push_back (id);
+        continue;
+      } else {
+        const int other = reprs[vlit (lit)];
+        tmp = val (other);
+        if (tmp < 0) {
+          if (!lrat)
+            continue;
+          Flags &f = flags (other);
+          if (!f.seen) {
+            f.seen = true;
+            analyzed.push_back (other);
+            int64_t id = unit_id (-other);
+            lrat_chain.push_back (id);
+          }
+          if (other == lit)
+            continue;
+          int64_t id = decompose_ids[vlit (-lit)];
+          CADICAL_assert (id);
+          lrat_chain.push_back (id);
+          continue;
+        } else if (tmp > 0)
+          satisfied = true;
+        else {
+          tmp = marked (other);
+          if (tmp < 0)
+            satisfied = true;
+          else if (!tmp) {
+            mark (other);
+            clause.push_back (other);
+          }
+          if (other == lit)
+            continue;
+          if (!lrat)
+            continue;
+          int64_t id = decompose_ids[vlit (-lit)];
+          CADICAL_assert (id);
+          lrat_chain.push_back (id);
+        }
+      }
+    }
+    if (lrat)
+      lrat_chain.push_back (c->id);
+    clear_analyzed_literals ();
+    LOG (lrat_chain, "lrat_chain:");
+    if (satisfied) {
+      LOG (c, "satisfied after substitution (postponed)");
+      postponed_garbage.push_back (c);
+#ifndef CADICAL_QUIET
+      garbage++;
+#endif
+    } else if (!clause.size ()) {
+      LOG ("learned empty clause during decompose");
+      learn_empty_clause ();
+    } else if (clause.size () == 1) {
+      LOG (c, "unit %d after substitution", clause[0]);
+      assign_unit (clause[0]);
+      mark_garbage (c);
+      new_unit = true;
+#ifndef CADICAL_QUIET
+      garbage++;
+#endif
+    } else if (c->literals[0] != clause[0] || c->literals[1] != clause[1]) {
+      LOG ("need new clause since at least one watched literal changed");
+      if (clause.size () == 2)
+        new_binary_clause = true;
+      size_t d_clause_idx = clauses.size ();
+      Clause *d = new_clause_as (c);
+      CADICAL_assert (clauses[d_clause_idx] == d);
+      clauses[d_clause_idx] = c;
+      clauses[i] = d;
+      mark_garbage (c);
+#ifndef CADICAL_QUIET
+      garbage++;
+#endif
+    } else {
+      LOG ("simply shrinking clause since watches did not change");
+      CADICAL_assert (c->size > 2);
+      if (!c->redundant)
+        mark_removed (c);
+      if (proof) {
+        proof->add_derived_clause (++clause_id, c->redundant, clause,
+                                   lrat_chain);
+        proof->delete_clause (c);
+        c->id = clause_id;
+      }
+      size_t l;
+      int *literals = c->literals;
+      for (l = 2; l < clause.size (); l++)
+        literals[l] = clause[l];
+      int flushed = c->size - (int) l;
+      if (flushed) {
+        if (l == 2)
+          new_binary_clause = true;
+        LOG ("flushed %d literals", flushed);
+        (void) shrink_clause (c, l);
+      } else if (likely_to_be_kept_clause (c))
+        mark_added (c);
+      // we have shrunken c->size to l so even though there is an CADICAL_assertion
+      // for c->size > 2 at the beginning of this else block, the new size
+      // can be 2 now.
+      if (c->size == 2) { // cheaper to update only new binary clauses
+        CADICAL_assert (new_binary_clause);
+        update_watch_size (watches (c->literals[0]), c->literals[1], c);
+        update_watch_size (watches (c->literals[1]), c->literals[0], c);
+      }
+      LOG (c, "substituted");
+    }
+    while (!clause.empty ()) {
+      int lit = clause.back ();
+      clause.pop_back ();
+      CADICAL_assert (marked (lit) > 0);
+      unmark (lit);
+    }
+    lrat_chain.clear ();
+  }
+
+  if (proof) {
+    for (auto idx : vars) {
+      if (!substituted)
+        break;
+      if (!active (idx))
+        continue;
+      const int64_t id1 = decompose_ids[vlit (-idx)];
+      if (!id1)
+        continue;
+      int other = reprs[vlit (idx)];
+      CADICAL_assert (other != idx);
+      CADICAL_assert (!flags (other).eliminated ());
+      CADICAL_assert (!flags (other).substituted ());
+
+      clause.push_back (other);
+      clause.push_back (-idx);
+      proof->delete_clause (id1, false, clause);
+      clause.clear ();
+
+      clause.push_back (idx);
+      clause.push_back (-other);
+      const int64_t id2 = decompose_ids[vlit (idx)];
+      proof->delete_clause (id2, false, clause);
+      clause.clear ();
+    }
+  }
+
+  if (!unsat && !postponed_garbage.empty ()) {
+    LOG ("now marking %zd postponed garbage clauses",
+         postponed_garbage.size ());
+    for (const auto &c : postponed_garbage)
+      mark_garbage (c);
+  }
+  erase_vector (postponed_garbage);
+
+  PHASE ("decompose", stats.decompositions,
+         "%zd clauses replaced %.2f%% producing %zd garbage clauses %.2f%%",
+         replaced, percent (replaced, clauses_size), garbage,
+         percent (garbage, replaced));
+
+  erase_vector (scc);
+
+  // Propagate found units.
+
+  if (!unsat && propagated < trail.size () && !propagate ()) {
+    LOG ("empty clause after propagating units from substitution");
+    learn_empty_clause ();
+  }
+
+  for (auto idx : vars) {
+    if (!substituted)
+      break;
+    if (unsat)
+      break;
+    if (!active (idx))
+      continue;
+    int other = reprs[vlit (idx)];
+    if (other == idx)
+      continue;
+    CADICAL_assert (!flags (other).eliminated ());
+    CADICAL_assert (!flags (other).substituted ());
+    if (!flags (other).fixed ())
+      mark_substituted (idx);
+  }
+
+  reprs_delete.free ();
+  dfs_delete.free ();
+  erase_vector (dfs_chains);
+
+  if (substituted)
+    flush_all_occs_and_watches (); // particularly the 'blit's
+
+  bool success =
+      unsat || (substituted > 0 && (new_unit || new_binary_clause));
+  report ('d', !opts.reportall && !success);
+
+  STOP_SIMPLIFIER (decompose, DECOMP);
+
+  return success;
+}
+
+void Internal::decompose () {
+  for (int round = 1; round <= opts.decomposerounds; round++)
+    if (!decompose_round ())
+      break;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_deduplicate.cpp b/src/sat/cadical/cadical_deduplicate.cpp
new file mode 100644
index 000000000..49d26a571
--- /dev/null
+++ b/src/sat/cadical/cadical_deduplicate.cpp
@@ -0,0 +1,176 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// Equivalent literal substitution in 'decompose' and shrinking in 'subsume'
+// or 'vivify' might produce duplicated binary clauses.  They can not be
+// found in 'subsume' nor 'vivify' since we explicitly do not consider
+// binary clauses as candidates to be shrunken or subsumed.  They are
+// detected here by a simple scan of watch lists and then marked as garbage.
+// This is actually also quite fast.
+
+// Further it might also be possible that two binary clauses can be resolved
+// to produce a unit (we call it 'hyper unary resolution').  For example
+// resolving the binary clauses '1 -2' and '1 2' produces the unit '1'.
+// This could be found by probing in 'probe' unless '-1' also occurs in a
+// binary clause (add the clause '-1 2' to those two clauses) in which case
+// '1' as well as '2' both occur positively as well as negatively and none
+// of them nor their negation is considered as probe
+
+void Internal::mark_duplicated_binary_clauses_as_garbage () {
+
+  if (!opts.deduplicate)
+    return;
+  if (unsat)
+    return;
+  if (terminated_asynchronously ())
+    return;
+
+  START_SIMPLIFIER (deduplicate, DEDUP);
+  stats.deduplications++;
+
+  CADICAL_assert (!level);
+  CADICAL_assert (watching ());
+
+  vector<int> stack; // To save marked literals and unmark them later.
+
+  int64_t subsumed = 0;
+  int64_t units = 0;
+
+  for (auto idx : vars) {
+
+    if (unsat)
+      break;
+    if (!active (idx))
+      continue;
+    int unit = 0;
+
+    for (int sign = -1; !unit && sign <= 1; sign += 2) {
+
+      const int lit = sign * idx; // Consider all literals.
+
+      CADICAL_assert (stack.empty ());
+      Watches &ws = watches (lit);
+
+      // We are removing references to garbage clause. Thus no 'auto'.
+
+      const const_watch_iterator end = ws.end ();
+      watch_iterator j = ws.begin ();
+      const_watch_iterator i;
+
+      for (i = j; !unit && i != end; i++) {
+        Watch w = *j++ = *i;
+        if (!w.binary ())
+          continue;
+        int other = w.blit;
+        const int tmp = marked (other);
+        Clause *c = w.clause;
+
+        if (tmp > 0) { // Found duplicated binary clause.
+
+          if (c->garbage) {
+            j--;
+            continue;
+          }
+          LOG (c, "found duplicated");
+
+          // The previous identical clause 'd' might be redundant and if the
+          // second clause 'c' is not (so irredundant), then we have to keep
+          // 'c' instead of 'd', thus we search for it and replace it.
+
+          if (!c->redundant) {
+            watch_iterator k;
+            for (k = ws.begin ();; k++) {
+              CADICAL_assert (k != i);
+              if (!k->binary ())
+                continue;
+              if (k->blit != other)
+                continue;
+              Clause *d = k->clause;
+              if (d->garbage)
+                continue;
+              c = d;
+              break;
+            }
+            *k = w;
+          }
+
+          LOG (c, "mark garbage duplicated");
+          stats.subsumed++;
+          stats.deduplicated++;
+          subsumed++;
+          mark_garbage (c);
+          j--;
+
+        } else if (tmp < 0) { // Hyper unary resolution.
+
+          LOG ("found %d %d and %d %d which produces unit %d", lit, -other,
+               lit, other, lit);
+          unit = lit;
+          if (lrat) {
+            // taken from fradical
+            CADICAL_assert (lrat_chain.empty ());
+            lrat_chain.push_back (c->id);
+            // We've forgotten where the other binary clause is, so go find
+            // it again
+            for (watch_iterator k = ws.begin ();; k++) {
+              CADICAL_assert (k != i);
+              if (!k->binary ())
+                continue;
+              if (k->blit != -other)
+                continue;
+              lrat_chain.push_back (k->clause->id);
+              break;
+            }
+          }
+          j = ws.begin (); // Flush 'ws'.
+          units++;
+
+        } else {
+          if (c->garbage)
+            continue;
+          mark (other);
+          stack.push_back (other);
+        }
+      }
+
+      if (j == ws.begin ())
+        erase_vector (ws);
+      else if (j != end)
+        ws.resize (j - ws.begin ()); // Shrink watchers.
+
+      for (const auto &other : stack)
+        unmark (other);
+
+      stack.clear ();
+    }
+
+    // Propagation potentially messes up the watches and thus we can not
+    // propagate the unit immediately after finding it.  Instead we break
+    // out of both loops and assign and propagate the unit here.
+
+    if (unit) {
+
+      stats.failed++;
+      stats.hyperunary++;
+      assign_unit (unit);
+      // lrat_chain.clear ();   done in search_assign
+
+      if (!propagate ()) {
+        LOG ("empty clause after propagating unit");
+        learn_empty_clause ();
+      }
+    }
+  }
+  STOP_SIMPLIFIER (deduplicate, DEDUP);
+
+  report ('2', !opts.reportall && !(subsumed + units));
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_definition.cpp b/src/sat/cadical/cadical_definition.cpp
new file mode 100644
index 000000000..7c8fe4fbb
--- /dev/null
+++ b/src/sat/cadical/cadical_definition.cpp
@@ -0,0 +1,289 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+#define INVALID_LIT UINT_MAX
+
+// functions below are passed to cadical_kitten
+//
+struct definition_extractor {
+  Eliminator *eliminator;
+  Internal *internal;
+  vector<Clause *> clauses[2];
+  int lit;
+  vector<vector<int>> implicants;
+  int unit;
+};
+
+extern "C" {
+
+// used to extract definitions from cadical_kitten
+//
+static void traverse_definition_core (void *state, unsigned id) {
+  definition_extractor *extractor = (definition_extractor *) state;
+  Clause *clause;
+  const vector<Clause *> &clauses0 = extractor->clauses[0];
+  const vector<Clause *> &clauses1 = extractor->clauses[1];
+  Eliminator *eliminator = extractor->eliminator;
+  const size_t size_clauses0 = clauses0.size ();
+  const size_t size_clauses1 = clauses1.size ();
+  CADICAL_assert (size_clauses0 <= UINT_MAX);
+  unsigned sign;
+  CADICAL_assert (id < size_clauses0 + size_clauses1);
+  if (id < size_clauses0) {
+    clause = clauses0[id];
+    sign = 1;
+  } else {
+    unsigned tmp = id - size_clauses0;
+#ifndef CADICAL_NDEBUG
+    CADICAL_assert (size_clauses1 <= UINT_MAX);
+    CADICAL_assert (tmp < size_clauses1);
+#endif
+    clause = clauses1[tmp];
+    sign = 2;
+  }
+  (void) size_clauses1;
+  clause->gate = true;
+  eliminator->gates.push_back (clause);
+#ifdef LOGGING
+  Internal *internal = extractor->internal;
+  LOG (clause, "extracted gate");
+#endif
+  eliminator->definition_unit |= sign;
+}
+
+// extracts relevant learned clauses from kissat for drat proofs
+//
+static void traverse_one_sided_core_lemma (void *state, bool learned,
+                                           size_t size,
+                                           const unsigned *lits) {
+  if (!learned)
+    return;
+  definition_extractor *extractor = (definition_extractor *) state;
+  Eliminator *eliminator = extractor->eliminator;
+  Internal *internal = extractor->internal;
+  Proof *proof = internal->proof;
+  const int unit = extractor->unit;
+  vector<proof_clause> &proof_clauses = eliminator->proof_clauses;
+  if (size) {
+    proof_clause pc;
+    pc.id = ++(internal->clause_id);
+    pc.literals.push_back (unit);
+    const unsigned *end = lits + size;
+    for (const unsigned *p = lits; p != end; p++)
+      pc.literals.push_back (internal->citten2lit (*p)); // conversion
+    proof_clauses.push_back (pc);
+    CADICAL_assert (proof);
+    proof->add_derived_clause (pc.id, true, pc.literals, pc.chain);
+  } else {
+    internal->assign_unit (unit);
+    for (const auto &pc : proof_clauses) {
+      proof->delete_clause (pc.id, true, pc.literals);
+    }
+    proof_clauses.clear ();
+  }
+}
+
+// extract lrat proofs for relevant clauses
+//
+static void traverse_one_sided_core_lemma_with_lrat (
+    void *state, unsigned cid, unsigned id, bool learned, size_t size,
+    const unsigned *lits, size_t chain_size, const unsigned *chain) {
+  definition_extractor *extractor = (definition_extractor *) state;
+  Eliminator *eliminator = extractor->eliminator;
+  Internal *internal = extractor->internal;
+  Proof *proof = internal->proof;
+  const int unit = extractor->unit;
+  const vector<Clause *> &clauses0 = extractor->clauses[0];
+  const vector<Clause *> &clauses1 = extractor->clauses[1];
+  vector<proof_clause> &proof_clauses = eliminator->proof_clauses;
+  if (!learned) { // remember clauses for mapping to cadical_kitten internal
+    CADICAL_assert (size);
+    CADICAL_assert (!chain_size);
+    proof_clause pc;
+    pc.cid = cid;
+    pc.learned = false;
+    const size_t size_clauses0 = clauses0.size ();
+    CADICAL_assert (size_clauses0 <= UINT_MAX);
+    if (id < size_clauses0) {
+      pc.id = clauses0[id]->id;
+    } else {
+      unsigned tmp = id - size_clauses0;
+#ifndef CADICAL_NDEBUG
+      const size_t size_clauses1 = clauses1.size ();
+      CADICAL_assert (size_clauses1 <= UINT_MAX);
+      CADICAL_assert (tmp < size_clauses1);
+#endif
+      pc.id = clauses1[tmp]->id;
+    }
+    proof_clauses.push_back (pc);
+  } else { // actually add to proof
+    CADICAL_assert (chain_size);
+    if (size) {
+      proof_clause pc;
+      pc.id = ++(internal->clause_id);
+      pc.cid = cid;
+      pc.learned = true;
+      pc.literals.push_back (unit);
+      const unsigned *end = lits + size;
+      for (const unsigned *p = lits; p != end; p++)
+        pc.literals.push_back (internal->citten2lit (*p)); // conversion
+      for (const unsigned *p = chain + chain_size; p != chain; p--) {
+        int64_t id = 0;
+        for (const auto &cpc : proof_clauses) {
+          if (cpc.cid == *(p - 1)) {
+            id = cpc.id;
+            break;
+          }
+        }
+        CADICAL_assert (id);
+        pc.chain.push_back (id);
+      }
+      proof_clauses.push_back (pc);
+      CADICAL_assert (proof);
+      proof->add_derived_clause (pc.id, true, pc.literals, pc.chain);
+    } else { // learn unit finish proof
+      CADICAL_assert (internal->lrat_chain.empty ());
+      for (const unsigned *p = chain + chain_size; p != chain; p--) {
+        int64_t id = 0;
+        for (const auto &cpc : proof_clauses) {
+          if (cpc.cid == *(p - 1)) {
+            id = cpc.id;
+            break;
+          }
+        }
+        CADICAL_assert (id);
+        internal->lrat_chain.push_back (id);
+      }
+      internal->assign_unit (unit);
+      CADICAL_assert (internal->lrat_chain.empty ());
+      for (const auto &pc : proof_clauses) {
+        if (pc.learned)
+          proof->delete_clause (pc.id, true, pc.literals);
+      }
+      proof_clauses.clear ();
+    }
+  }
+}
+
+} // end extern C
+
+// Code ported from kissat. Kitten (and kissat) use unsigned representation
+// for literals whereas CaDiCaL uses signed representation. Conversion is
+// necessary for communication using lit2citten and citten2lit.
+// This code is called in elim and cadical_kitten is initialized beforehand.
+// To avoid confusion all cadical interal definitions with cadical_kitten are called
+// citten.
+//
+void Internal::find_definition (Eliminator &eliminator, int lit) {
+  if (!opts.elimdef)
+    return;
+  if (unsat)
+    return;
+  if (val (lit))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+  CADICAL_assert (!val (lit));
+  CADICAL_assert (!level);
+  CADICAL_assert (citten);
+  const int not_lit = -lit;
+  definition_extractor extractor;
+  extractor.lit = lit;
+  extractor.clauses[0] = occs (lit);
+  extractor.clauses[1] = occs (not_lit);
+  extractor.eliminator = &eliminator;
+  extractor.internal = internal;
+  citten_clear_track_log_terminate ();
+  unsigned exported = 0;
+  for (unsigned sign = 0; sign < 2; sign++) {
+    const unsigned except = sign ? lit2citten (not_lit) : lit2citten (lit);
+    for (auto c : extractor.clauses[sign]) {
+      // to avoid copying the literals of c in their unsigned
+      // representation we instead implement the translation in cadical_kitten
+      if (!c->garbage) {
+        LOG (c, "adding to cadical_kitten");
+        citten_clause_with_id_and_exception (citten, exported, c->size,
+                                             c->literals, except);
+      }
+      exported++;
+    }
+  }
+  stats.definitions_checked++;
+  const size_t limit = opts.elimdefticks;
+  cadical_kitten_set_ticks_limit (citten, limit);
+  int status = cadical_kitten_solve (citten);
+  if (!exported)
+    goto ABORT;
+  if (status == 20) {
+    LOG ("sub-solver result UNSAT shows definition exists");
+    uint64_t learned;
+    unsigned reduced = cadical_kitten_compute_clausal_core (citten, &learned);
+    LOG ("1st sub-solver core of size %u original clauses out of %u",
+         reduced, exported);
+    for (int i = 2; i <= opts.elimdefcores; i++) {
+      cadical_kitten_shrink_to_clausal_core (citten);
+      cadical_kitten_shuffle_clauses (citten);
+      cadical_kitten_set_ticks_limit (citten, 10 * limit);
+      int tmp = cadical_kitten_solve (citten);
+      CADICAL_assert (!tmp || tmp == 20);
+      if (!tmp) {
+        LOG ("aborting core extraction");
+        goto ABORT;
+      }
+#ifndef CADICAL_NDEBUG
+      unsigned previous = reduced;
+#endif
+      reduced = cadical_kitten_compute_clausal_core (citten, &learned);
+      LOG ("%d sub-solver core of size %u original clauses out of %u", i,
+           reduced, exported);
+      CADICAL_assert (reduced <= previous);
+#if not defined(LOGGING) && defined(CADICAL_NDEBUG)
+      (void) reduced;
+#endif
+    }
+    stats.definitions_extracted++;
+    eliminator.gatetype = DEF;
+    eliminator.definition_unit = 0;
+    cadical_kitten_traverse_core_ids (citten, &extractor, traverse_definition_core);
+    CADICAL_assert (eliminator.definition_unit);
+    int unit = 0;
+    if (eliminator.definition_unit == 2) {
+      unit = not_lit;
+    } else if (eliminator.definition_unit == 1)
+      unit = lit;
+
+    if (unit) {
+      stats.definition_units++;
+      VERBOSE (2, "one sided core "
+                  "definition extraction yields "
+                  "failed literal");
+      if (proof) {
+        if (lrat) {
+          extractor.unit = unit;
+          cadical_kitten_trace_core (citten, &extractor,
+                             traverse_one_sided_core_lemma_with_lrat);
+        } else {
+          extractor.unit = unit;
+          cadical_kitten_traverse_core_clauses (citten, &extractor,
+                                        traverse_one_sided_core_lemma);
+        }
+      } else
+        assign_unit (unit);
+      elim_propagate (eliminator, unit);
+    }
+  } else {
+  ABORT:
+    LOG ("sub-solver failed to show that definition exists");
+  }
+  stats.definition_ticks += cadical_kitten_current_ticks (citten);
+  return;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_drattracer.cpp b/src/sat/cadical/cadical_drattracer.cpp
new file mode 100644
index 000000000..eb73b4c95
--- /dev/null
+++ b/src/sat/cadical/cadical_drattracer.cpp
@@ -0,0 +1,159 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+DratTracer::DratTracer (Internal *i, File *f, bool b)
+    : internal (i), file (f), binary (b)
+#ifndef CADICAL_QUIET
+      ,
+      added (0), deleted (0)
+#endif
+{
+  (void) internal;
+}
+
+void DratTracer::connect_internal (Internal *i) {
+  internal = i;
+  file->connect_internal (internal);
+  LOG ("DRAT TRACER connected to internal");
+}
+
+DratTracer::~DratTracer () {
+  LOG ("DRAT TRACER delete");
+  delete file;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void DratTracer::put_binary_zero () {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  file->put ((unsigned char) 0);
+}
+
+inline void DratTracer::put_binary_lit (int lit) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  CADICAL_assert (lit != INT_MIN);
+  unsigned idx = abs (lit);
+  CADICAL_assert (idx < (1u << 31));
+  unsigned x = 2u * idx + (lit < 0);
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+/*------------------------------------------------------------------------*/
+
+void DratTracer::drat_add_clause (const vector<int> &clause) {
+  if (binary)
+    file->put ('a');
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+}
+void DratTracer::drat_delete_clause (const vector<int> &clause) {
+  if (binary)
+    file->put ('d');
+  else
+    file->put ("d ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+}
+
+/*------------------------------------------------------------------------*/
+
+void DratTracer::add_derived_clause (int64_t, bool,
+                                     const vector<int> &clause,
+                                     const vector<int64_t> &) {
+  if (file->closed ())
+    return;
+  LOG ("DRAT TRACER tracing addition of derived clause");
+  drat_add_clause (clause);
+#ifndef CADICAL_QUIET
+  added++;
+#endif
+}
+
+void DratTracer::delete_clause (int64_t, bool, const vector<int> &clause) {
+  if (file->closed ())
+    return;
+  LOG ("DRAT TRACER tracing deletion of clause");
+  drat_delete_clause (clause);
+#ifndef CADICAL_QUIET
+  deleted++;
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+bool DratTracer::closed () { return file->closed (); }
+
+#ifndef CADICAL_QUIET
+
+void DratTracer::print_statistics () {
+  uint64_t bytes = file->bytes ();
+  uint64_t total = added + deleted;
+  MSG ("DRAT %" PRId64 " added clauses %.2f%%", added,
+       percent (added, total));
+  MSG ("DRAT %" PRId64 " deleted clauses %.2f%%", deleted,
+       percent (deleted, total));
+  MSG ("DRAT %" PRId64 " bytes (%.2f MB)", bytes,
+       bytes / (double) (1 << 20));
+}
+
+#endif
+
+void DratTracer::close (bool print) {
+  CADICAL_assert (!closed ());
+  file->close ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("DRAT proof file '%s' closed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+void DratTracer::flush (bool print) {
+  CADICAL_assert (!closed ());
+  file->flush ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("DRAT proof file '%s' flushed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_elim.cpp b/src/sat/cadical/cadical_elim.cpp
new file mode 100644
index 000000000..951dfee74
--- /dev/null
+++ b/src/sat/cadical/cadical_elim.cpp
@@ -0,0 +1,1178 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+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
+// 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).
+
+/*------------------------------------------------------------------------*/
+
+inline double Internal::compute_elim_score (unsigned lit) {
+  CADICAL_assert (1 <= lit), CADICAL_assert (lit <= (unsigned) max_var);
+  const unsigned uidx = 2 * lit;
+  const double pos = internal->ntab[uidx];
+  const double neg = internal->ntab[uidx + 1];
+  if (!pos)
+    return -neg;
+  if (!neg)
+    return -pos;
+  double sum = 0, prod = 0;
+  if (opts.elimsum)
+    sum = opts.elimsum * (pos + neg);
+  if (opts.elimprod)
+    prod = opts.elimprod * (pos * neg);
+  return prod + sum;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool elim_more::operator() (unsigned a, unsigned b) {
+  const auto s = internal->compute_elim_score (a);
+  const auto t = internal->compute_elim_score (b);
+  if (s > t)
+    return true;
+  if (s < t)
+    return false;
+  return a > b;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Note that the new fast subsumption algorithm implemented in 'subsume'
+// does not distinguish between irredundant and redundant clauses and is
+// also run during search to strengthen and remove 'sticky' redundant
+// clauses but also irredundant ones.  So beside learned units during search
+// or as consequence of other preprocessors, these subsumption rounds during
+// search can remove (irredundant) clauses (and literals), which in turn
+// might make new bounded variable elimination possible.  This is tested
+// in the 'bool ineliminating ()' guard.
+
+bool Internal::ineliminating () {
+
+  if (!opts.elim)
+    return false;
+  if (!preprocessing && !opts.inprocessing)
+    return false;
+  if (preprocessing)
+    CADICAL_assert (lim.preprocessing);
+
+  // Respect (increasing) conflict limit.
+  //
+  if (lim.elim >= stats.conflicts)
+    return false;
+
+  // Wait until there are new units or new removed variables
+  // (in removed or shrunken irredundant clauses and thus marked).
+  //
+  if (last.elim.fixed < stats.all.fixed)
+    return true;
+  if (last.elim.marked < stats.mark.elim)
+    return true;
+
+  // VERBOSE (3, "elim not scheduled due to fixpoint");
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Update the global elimination schedule after adding or removing a clause.
+
+void Internal::elim_update_added_clause (Eliminator &eliminator,
+                                         Clause *c) {
+  CADICAL_assert (!c->redundant);
+  ElimSchedule &schedule = eliminator.schedule;
+  for (const auto &lit : *c) {
+    if (!active (lit))
+      continue;
+    occs (lit).push_back (c);
+    if (frozen (lit))
+      continue;
+    noccs (lit)++;
+    const int idx = abs (lit);
+    if (schedule.contains (idx))
+      schedule.update (idx);
+  }
+}
+
+void Internal::elim_update_removed_lit (Eliminator &eliminator, int lit) {
+  if (!active (lit))
+    return;
+  if (frozen (lit))
+    return;
+  int64_t &score = noccs (lit);
+  CADICAL_assert (score > 0);
+  score--;
+  const int idx = abs (lit);
+  ElimSchedule &schedule = eliminator.schedule;
+  if (schedule.contains (idx))
+    schedule.update (idx);
+  else {
+    LOG ("rescheduling %d for elimination after removing clause", idx);
+    schedule.push_back (idx);
+  }
+}
+
+void Internal::elim_update_removed_clause (Eliminator &eliminator,
+                                           Clause *c, int except) {
+  CADICAL_assert (!c->redundant);
+  for (const auto &lit : *c) {
+    if (lit == except)
+      continue;
+    CADICAL_assert (lit != -except);
+    elim_update_removed_lit (eliminator, lit);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Since we do not have watches we have to do our own unit propagation
+// during elimination as soon we find a unit clause.  This finds new units
+// and also marks clauses satisfied by those units as garbage immediately.
+
+void Internal::elim_propagate (Eliminator &eliminator, int root) {
+  CADICAL_assert (val (root) > 0);
+  vector<int> work;
+  size_t i = 0;
+  work.push_back (root);
+  while (i < work.size ()) {
+    int lit = work[i++];
+    LOG ("elimination propagation of %d", lit);
+    CADICAL_assert (val (lit) > 0);
+    const Occs &ns = occs (-lit);
+    for (const auto &c : ns) {
+      if (c->garbage)
+        continue;
+      int unit = 0, satisfied = 0;
+      for (const auto &other : *c) {
+        const signed char tmp = val (other);
+        if (tmp < 0)
+          continue;
+        if (tmp > 0) {
+          satisfied = other;
+          break;
+        }
+        if (unit)
+          unit = INT_MIN;
+        else
+          unit = other;
+      }
+      if (satisfied) {
+        LOG (c, "elimination propagation of %d finds %d satisfied", lit,
+             satisfied);
+        elim_update_removed_clause (eliminator, c, satisfied);
+        mark_garbage (c);
+      } else if (!unit) {
+        LOG ("empty clause during elimination propagation of %d", lit);
+        // need to set conflict = c for lrat
+        conflict = c;
+        learn_empty_clause ();
+        conflict = 0;
+        break;
+      } else if (unit != INT_MIN) {
+        LOG ("new unit %d during elimination propagation of %d", unit, lit);
+        build_chain_for_units (unit, c, 0);
+        assign_unit (unit);
+        work.push_back (unit);
+      }
+    }
+    if (unsat)
+      break;
+    const Occs &ps = occs (lit);
+    for (const auto &c : ps) {
+      if (c->garbage)
+        continue;
+      LOG (c, "elimination propagation of %d produces satisfied", lit);
+      elim_update_removed_clause (eliminator, c, lit);
+      mark_garbage (c);
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// On-the-fly self-subsuming resolution during variable elimination is due
+// to HyoJung Han, Fabio Somenzi, SAT'09.  Basically while resolving two
+// clauses we test the resolvent to be smaller than one of the antecedents.
+// If this is the case the pivot can be removed from the antecedent
+// on-the-fly and the resolution can be skipped during elimination.
+
+void Internal::elim_on_the_fly_self_subsumption (Eliminator &eliminator,
+                                                 Clause *c, int pivot) {
+  LOG (c, "pivot %d on-the-fly self-subsuming resolution", pivot);
+  stats.elimotfstr++;
+  stats.strengthened++;
+  CADICAL_assert (clause.empty ());
+  for (const auto &lit : *c) {
+    if (lit == pivot)
+      continue;
+    const signed char tmp = val (lit);
+    CADICAL_assert (tmp <= 0);
+    if (tmp < 0)
+      continue;
+    clause.push_back (lit);
+  }
+  Clause *r = new_resolved_irredundant_clause ();
+  elim_update_added_clause (eliminator, r);
+  clause.clear ();
+  lrat_chain.clear ();
+  elim_update_removed_clause (eliminator, c, pivot);
+  mark_garbage (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Resolve two clauses on the pivot literal 'pivot', which is assumed to
+// occur in opposite phases in 'c' and 'd'.  The actual resolvent is stored
+// in the temporary global 'clause' if it is not redundant.  It is
+// considered redundant if one of the clauses is already marked as garbage
+// it is root level satisfied, the resolvent is empty, a unit, or produces a
+// self-subsuming resolution, which results in the pivot to be removed from
+// at least one of the antecedents.
+
+// Note that current root level assignments are taken into account, i.e., by
+// removing root level falsified literals.  The function returns true if the
+// resolvent is not redundant and for instance has to be taken into account
+// during bounded variable elimination.
+
+// Detected units are immediately assigned and in case the last argument is
+// true also propagated eagerly in a elimination specific propagation
+// routine, which not only finds units but also updates the schedule.
+
+// When this function is called during computation of the number of
+// non-trivial (or non-satisfied) resolvents we can eagerly propagate units.
+// But during actually adding the resolvents this results in problems as we
+// found one rare test case '../test/trace/reg0056.trace' (out of billions),
+// where the pivot itself was assigned during such a propagation while
+// adding resolvents and lead to pushing a clause to the reconstruction
+// stack that later flipped the value of the pivot (while all other literals
+// in that clause were unit implied too).  Not pushing the pivot clauses to
+// the reconstruction stack produced a wrong model too.  Our fix is to only
+// eagerly propagate during computation of the number of resolvents and
+// otherwise delay propagation until the end of elimination (which is less
+// precise regarding scheduling but very rarely happens).
+
+bool Internal::resolve_clauses (Eliminator &eliminator, Clause *c,
+                                int pivot, Clause *d,
+                                const bool propagate_eagerly) {
+
+  CADICAL_assert (!c->redundant);
+  CADICAL_assert (!d->redundant);
+
+  stats.elimres++;
+
+  if (c->garbage || d->garbage)
+    return false;
+  if (c->size > d->size) {
+    pivot = -pivot;
+    swap (c, d);
+  }
+
+  CADICAL_assert (!level);
+  CADICAL_assert (clause.empty ());
+
+  int satisfied = 0;    // Contains this satisfying literal.
+  int tautological = 0; // Clashing literal if tautological.
+
+  int s = 0; // Actual literals from 'c'.
+  int t = 0; // Actual literals from 'd'.
+
+  // First determine whether the first antecedent is satisfied, add its
+  // literals to 'clause' and mark them (except for 'pivot').
+  //
+  for (const auto &lit : *c) {
+    if (lit == pivot) {
+      s++;
+      continue;
+    }
+    CADICAL_assert (lit != -pivot);
+    const signed char tmp = val (lit);
+    if (tmp > 0) {
+      satisfied = lit;
+      break;
+    } else if (tmp < 0) {
+      if (!lrat)
+        continue;
+      Flags &f = flags (lit);
+      if (f.seen)
+        continue;
+      analyzed.push_back (lit);
+      f.seen = true;
+      int64_t id = unit_id (-lit);
+      lrat_chain.push_back (id);
+      continue;
+    } else
+      mark (lit), clause.push_back (lit), s++;
+  }
+  if (satisfied) {
+    LOG (c, "satisfied by %d antecedent", satisfied);
+    elim_update_removed_clause (eliminator, c, satisfied);
+    mark_garbage (c);
+    clause.clear ();
+    lrat_chain.clear ();
+    clear_analyzed_literals ();
+    unmark (c);
+    return false;
+  }
+
+  // Then determine whether the second antecedent is satisfied, add its
+  // literal to 'clause' and check whether a clashing literal is found, such
+  // that the resolvent would be tautological.
+  //
+  for (const auto &lit : *d) {
+    if (lit == -pivot) {
+      t++;
+      continue;
+    }
+    CADICAL_assert (lit != pivot);
+    signed char tmp = val (lit);
+    if (tmp > 0) {
+      satisfied = lit;
+      break;
+    } else if (tmp < 0) {
+      if (!lrat)
+        continue;
+      Flags &f = flags (lit);
+      if (f.seen)
+        continue;
+      analyzed.push_back (lit);
+      f.seen = true;
+      int64_t id = unit_id (-lit);
+      lrat_chain.push_back (id);
+      continue;
+    } else if ((tmp = marked (lit)) < 0) {
+      tautological = lit;
+      break;
+    } else if (!tmp)
+      clause.push_back (lit), t++;
+    else
+      CADICAL_assert (tmp > 0), t++;
+  }
+
+  clear_analyzed_literals ();
+  unmark (c);
+  const int64_t size = clause.size ();
+
+  if (lrat) {
+    lrat_chain.push_back (d->id);
+    lrat_chain.push_back (c->id);
+  }
+
+  if (satisfied) {
+    LOG (d, "satisfied by %d antecedent", satisfied);
+    elim_update_removed_clause (eliminator, d, satisfied);
+    mark_garbage (d);
+    clause.clear ();
+    lrat_chain.clear ();
+    return false;
+  }
+
+  LOG (c, "first antecedent");
+  LOG (d, "second antecedent");
+
+  if (tautological) {
+    clause.clear ();
+    LOG ("resolvent tautological on %d", tautological);
+    lrat_chain.clear ();
+    return false;
+  }
+
+  if (!size) {
+    clause.clear ();
+    LOG ("empty resolvent");
+    learn_empty_clause (); // already clears lrat_chain.
+    return false;
+  }
+
+  if (size == 1) {
+    int unit = clause[0];
+    LOG ("unit resolvent %d", unit);
+    clause.clear ();
+    assign_unit (unit); // already clears lrat_chain.
+    if (propagate_eagerly)
+      elim_propagate (eliminator, unit);
+    return false;
+  }
+
+  LOG (clause, "resolvent");
+  CADICAL_assert (!lrat || !lrat_chain.empty ());
+
+  // Double self-subsuming resolution.  The clauses 'c' and 'd' are
+  // identical except for the pivot which occurs in different phase.  The
+  // resolvent subsumes both antecedents.
+
+  if (s > size && t > size) {
+    CADICAL_assert (s == size + 1);
+    CADICAL_assert (t == size + 1);
+    clause.clear ();
+    // LRAT is c + d (+ eventual units)
+    elim_on_the_fly_self_subsumption (eliminator, c, pivot);
+    LOG (d, "double pivot %d on-the-fly self-subsuming resolution", -pivot);
+    stats.elimotfsub++;
+    stats.subsumed++;
+    elim_update_removed_clause (eliminator, d, -pivot);
+    mark_garbage (d);
+    return false;
+  }
+
+  // Single self-subsuming resolution:  The pivot can be removed from 'c',
+  // which is implemented by adding a clause which is the same as 'c' but
+  // with 'pivot' removed and then marking 'c' as garbage.
+
+  if (s > size) {
+    CADICAL_assert (s == size + 1);
+    clause.clear ();
+    // LRAT is c + d (+ eventual units)
+    elim_on_the_fly_self_subsumption (eliminator, c, pivot);
+    return false;
+  }
+
+  // Same single self-subsuming resolution situation, but only for 'd'.
+
+  if (t > size) {
+    CADICAL_assert (t == size + 1);
+    clause.clear ();
+    // LRAT is c + d (+ eventual units) -> same.
+    elim_on_the_fly_self_subsumption (eliminator, d, -pivot);
+    return false;
+  }
+  if (propagate_eagerly)
+    lrat_chain.clear ();
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether the number of non-tautological resolvents on 'pivot' is
+// smaller or equal to the number of clauses with 'pivot' or '-pivot'.  This
+// is the main criteria of bounded variable elimination.  As a side effect
+// it flushes garbage clauses with that variable, sorts its occurrence lists
+// (smallest clauses first) and also negates pivot if it has more positive
+// than negative occurrences.
+
+bool Internal::elim_resolvents_are_bounded (Eliminator &eliminator,
+                                            int pivot) {
+  const bool substitute = !eliminator.gates.empty ();
+  const bool resolve_gates = eliminator.definition_unit;
+  if (substitute)
+    LOG ("trying to substitute %d", pivot);
+
+  stats.elimtried++;
+
+  CADICAL_assert (!unsat);
+  CADICAL_assert (active (pivot));
+
+  const Occs &ps = occs (pivot);
+  const Occs &ns = occs (-pivot);
+  const int64_t pos = ps.size ();
+  const int64_t neg = ns.size ();
+  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 " + %" PRId64,
+       pivot, bound, pos, neg, lim.elimbound);
+
+  // Try all resolutions between a positive occurrence (outer loop) of
+  // 'pivot' and a negative occurrence of 'pivot' (inner loop) as long the
+  // bound on non-tautological resolvents is not hit and the size of the
+  // generated resolvents does not exceed the resolvent clause size limit.
+
+  int64_t resolvents = 0; // Non-tautological resolvents.
+
+  for (const auto &c : ps) {
+    CADICAL_assert (!c->redundant);
+    if (c->garbage)
+      continue;
+    for (const auto &d : ns) {
+      CADICAL_assert (!d->redundant);
+      if (d->garbage)
+        continue;
+      if (!resolve_gates && substitute && c->gate == d->gate)
+        continue;
+      stats.elimrestried++;
+      if (resolve_clauses (eliminator, c, pivot, d, true)) {
+        resolvents++;
+        int size = clause.size ();
+        clause.clear ();
+        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",
+               size, resolvents, pivot);
+          return false;
+        }
+        if (resolvents > bound) {
+          LOG ("too many non-tautological resolvents on %d", pivot);
+          return false;
+        }
+      } else if (unsat)
+        return false;
+      else if (val (pivot))
+        return false;
+    }
+  }
+
+  LOG ("need %" PRId64 " <= %" PRId64 " non-tautological resolvents",
+       resolvents, bound);
+
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+// Add all resolvents on 'pivot' and connect them.
+
+inline void Internal::elim_add_resolvents (Eliminator &eliminator,
+                                           int pivot) {
+
+  const bool substitute = !eliminator.gates.empty ();
+  const bool resolve_gates = eliminator.definition_unit;
+  if (substitute) {
+    LOG ("substituting pivot %d by resolving with %zd gate clauses", pivot,
+         eliminator.gates.size ());
+    stats.elimsubst++;
+  }
+  switch (eliminator.gatetype) {
+  case EQUI:
+    stats.eliminated_equi++;
+    break;
+  case AND:
+    stats.eliminated_and++;
+    break;
+  case ITE:
+    stats.eliminated_ite++;
+    break;
+  case XOR:
+    stats.eliminated_xor++;
+    break;
+  case DEF:
+    stats.eliminated_def++;
+    break;
+  default:
+    CADICAL_assert (eliminator.gatetype == NO);
+  }
+
+  LOG ("adding all resolvents on %d", pivot);
+
+  CADICAL_assert (!val (pivot));
+  CADICAL_assert (!flags (pivot).eliminated ());
+
+  const Occs &ps = occs (pivot);
+  const Occs &ns = occs (-pivot);
+#ifdef LOGGING
+  int64_t resolvents = 0;
+#endif
+  for (auto &c : ps) {
+    if (unsat)
+      break;
+    if (c->garbage)
+      continue;
+    for (auto &d : ns) {
+      if (unsat)
+        break;
+      if (d->garbage)
+        continue;
+      if (!resolve_gates && substitute && c->gate == d->gate)
+        continue;
+      if (!resolve_clauses (eliminator, c, pivot, d, false))
+        continue;
+      CADICAL_assert (!lrat || !lrat_chain.empty ());
+      Clause *r = new_resolved_irredundant_clause ();
+      elim_update_added_clause (eliminator, r);
+      eliminator.enqueue (r);
+      lrat_chain.clear ();
+      clause.clear ();
+#ifdef LOGGING
+      resolvents++;
+#endif
+    }
+  }
+
+  LOG ("added %" PRId64 " resolvents to eliminate %d", resolvents, pivot);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Remove clauses with 'pivot' and '-pivot' by marking them as garbage and
+// push them on the extension stack.
+
+void Internal::mark_eliminated_clauses_as_garbage (
+    Eliminator &eliminator, int pivot, bool &deleted_binary_clause) {
+  CADICAL_assert (!unsat);
+
+  LOG ("marking irredundant clauses with %d as garbage", pivot);
+
+  const int64_t substitute = eliminator.gates.size ();
+  if (substitute)
+    LOG ("pushing %" PRId64 " gate clauses on extension stack", substitute);
+#ifndef CADICAL_NDEBUG
+  int64_t pushed = 0;
+#endif
+  Occs &ps = occs (pivot);
+  for (const auto &c : ps) {
+    if (c->garbage)
+      continue;
+    CADICAL_assert (!c->redundant);
+    if (!substitute || c->gate) {
+      if (proof)
+        proof->weaken_minus (c);
+      if (c->size == 2)
+        deleted_binary_clause = true;
+      external->push_clause_on_extension_stack (c, pivot);
+#ifndef CADICAL_NDEBUG
+      pushed++;
+#endif
+    }
+    mark_garbage (c);
+    elim_update_removed_clause (eliminator, c, pivot);
+  }
+  erase_occs (ps);
+
+  LOG ("marking irredundant clauses with %d as garbage", -pivot);
+
+  Occs &ns = occs (-pivot);
+  for (const auto &d : ns) {
+    if (d->garbage)
+      continue;
+    CADICAL_assert (!d->redundant);
+    if (!substitute || d->gate) {
+      if (proof)
+        proof->weaken_minus (d);
+      if (d->size == 2)
+        deleted_binary_clause = true;
+      external->push_clause_on_extension_stack (d, -pivot);
+#ifndef CADICAL_NDEBUG
+      pushed++;
+#endif
+    }
+    mark_garbage (d);
+    elim_update_removed_clause (eliminator, d, -pivot);
+  }
+  erase_occs (ns);
+
+  if (substitute)
+    CADICAL_assert (pushed <= substitute);
+
+  // Unfortunately, we can not use the trick by Niklas Soerensson anymore,
+  // which avoids saving all clauses on the extension stack.  This would
+  // break our new incremental 'restore' logic.
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to eliminate 'pivot' by bounded variable elimination.
+void Internal::try_to_eliminate_variable (Eliminator &eliminator, int pivot,
+                                          bool &deleted_binary_clause) {
+
+  if (!active (pivot))
+    return;
+  CADICAL_assert (!frozen (pivot));
+
+  // First flush garbage clauses.
+  //
+  int64_t pos = flush_occs (pivot);
+  int64_t neg = flush_occs (-pivot);
+
+  if (pos > neg) {
+    pivot = -pivot;
+    swap (pos, neg);
+  }
+  LOG ("pivot %d occurs positively %" PRId64
+       " times and negatively %" PRId64 " times",
+       pivot, pos, neg);
+  CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
+  CADICAL_assert (pos <= neg);
+
+  if (pos && neg > opts.elimocclim) {
+    LOG ("too many occurrences thus not eliminated %d", pivot);
+    CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
+    return;
+  }
+
+  LOG ("trying to eliminate %d", pivot);
+  CADICAL_assert (!flags (pivot).eliminated ());
+
+  // Sort occurrence lists, such that shorter clauses come first.
+  Occs &ps = occs (pivot);
+  stable_sort (ps.begin (), ps.end (), clause_smaller_size ());
+  Occs &ns = occs (-pivot);
+  stable_sort (ns.begin (), ns.end (), clause_smaller_size ());
+
+  if (pos)
+    find_gate_clauses (eliminator, pivot);
+
+  if (!unsat && !val (pivot)) {
+    if (elim_resolvents_are_bounded (eliminator, pivot)) {
+      LOG ("number of resolvents on %d are bounded", pivot);
+      elim_add_resolvents (eliminator, pivot);
+      if (!unsat)
+        mark_eliminated_clauses_as_garbage (eliminator, pivot,
+                                            deleted_binary_clause);
+      if (active (pivot))
+        mark_eliminated (pivot);
+    } else {
+      LOG ("too many resolvents on %d so not eliminated", pivot);
+    }
+  }
+
+  unmark_gate_clauses (eliminator);
+  elim_backward_clauses (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::
+    mark_redundant_clauses_with_eliminated_variables_as_garbage () {
+  for (const auto &c : clauses) {
+    if (c->garbage || !c->redundant)
+      continue;
+    bool clean = true;
+    for (const auto &lit : *c) {
+      Flags &f = flags (lit);
+      if (f.eliminated ()) {
+        clean = false;
+        break;
+      }
+      if (f.pure ()) {
+        clean = false;
+        break;
+      }
+    }
+    if (!clean)
+      mark_garbage (c);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// 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.
+
+int Internal::elim_round (bool &completed, bool &deleted_binary_clause) {
+
+  CADICAL_assert (opts.elim);
+  CADICAL_assert (!unsat);
+
+  START_SIMPLIFIER (elim, ELIM);
+  stats.elimrounds++;
+
+  int64_t marked_before = last.elim.marked;
+  last.elim.marked = stats.mark.elim;
+  CADICAL_assert (!level);
+
+  int64_t resolution_limit;
+
+  if (opts.elimlimited) {
+    int64_t delta = stats.propagations.search;
+    delta *= 1e-3 * opts.elimeffort;
+    if (delta < opts.elimmineff)
+      delta = opts.elimmineff;
+    if (delta > opts.elimmaxeff)
+      delta = opts.elimmaxeff;
+    delta = max (delta, (int64_t) 2l * active ());
+
+    PHASE ("elim-round", stats.elimrounds,
+           "limit of %" PRId64 " resolutions", delta);
+
+    resolution_limit = stats.elimres + delta;
+  } else {
+    PHASE ("elim-round", stats.elimrounds, "resolutions unlimited");
+    resolution_limit = LONG_MAX;
+  }
+
+  init_noccs ();
+
+  // First compute the number of occurrences of each literal and at the same
+  // time mark satisfied clauses and update 'elim' flags of variables in
+  // clauses with root level assigned literals (both false and true).
+  //
+  for (const auto &c : clauses) {
+    if (c->garbage || c->redundant)
+      continue;
+    bool satisfied = false, falsified = false;
+    for (const auto &lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0)
+        satisfied = true;
+      else if (tmp < 0)
+        falsified = true;
+      else
+        CADICAL_assert (active (lit));
+    }
+    if (satisfied)
+      mark_garbage (c); // forces more precise counts
+    else {
+      for (const auto &lit : *c) {
+        if (!active (lit))
+          continue;
+        if (falsified)
+          mark_elim (lit); // simulate unit propagation
+        noccs (lit)++;
+      }
+    }
+  }
+
+  init_occs ();
+
+  Eliminator eliminator (this);
+  ElimSchedule &schedule = eliminator.schedule;
+  CADICAL_assert (schedule.empty ());
+
+  // 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 (auto idx : vars) {
+    if (!active (idx))
+      continue;
+    if (frozen (idx))
+      continue;
+    if (!flags (idx).elim)
+      continue;
+    LOG ("scheduling %d for elimination initially", idx);
+    schedule.push_back (idx);
+  }
+
+  schedule.shrink ();
+
+#ifndef CADICAL_QUIET
+  int64_t scheduled = schedule.size ();
+#endif
+
+  PHASE ("elim-round", stats.elimrounds,
+         "scheduled %" PRId64 " variables %.0f%% for elimination",
+         scheduled, percent (scheduled, active ()));
+
+  // Connect irredundant clauses.
+  //
+  for (const auto &c : clauses)
+    if (!c->garbage && !c->redundant)
+      for (const auto &lit : *c)
+        if (active (lit))
+          occs (lit).push_back (c);
+
+#ifndef CADICAL_QUIET
+  const int64_t old_resolutions = stats.elimres;
+#endif
+  const int old_eliminated = stats.all.eliminated;
+  const int old_fixed = stats.all.fixed;
+
+  // Limit on garbage literals during variable elimination. If the limit is
+  // hit a garbage collection is performed.
+  //
+  const int64_t garbage_limit = (2 * stats.irrlits / 3) + (1 << 20);
+
+  // 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 CADICAL_QUIET
+  int64_t tried = 0;
+#endif
+  while (!unsat && !terminated_asynchronously () &&
+         stats.elimres <= resolution_limit && !schedule.empty ()) {
+    int idx = schedule.front ();
+    schedule.pop_front ();
+    flags (idx).elim = false;
+    try_to_eliminate_variable (eliminator, idx, deleted_binary_clause);
+#ifndef CADICAL_QUIET
+    tried++;
+#endif
+    if (stats.garbage.literals <= garbage_limit)
+      continue;
+    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+    garbage_collection ();
+  }
+
+  // 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 ();
+
+  if (!completed)
+    last.elim.marked = marked_before;
+
+  PHASE ("elim-round", stats.elimrounds,
+         "tried to eliminate %" PRId64 " variables %.0f%% (%zd remain)",
+         tried, percent (tried, scheduled), schedule.size ());
+
+  schedule.erase ();
+
+  // Collect potential literal clause instantiation pairs, which needs full
+  // occurrence lists and thus we have it here before resetting them.
+  //
+  Instantiator instantiator;
+  if (!unsat && !terminated_asynchronously () && opts.instantiate)
+    collect_instantiation_candidates (instantiator);
+
+  reset_occs ();
+  reset_noccs ();
+
+  // Mark all redundant clauses with eliminated variables as garbage.
+  //
+  if (!unsat)
+    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+
+  int eliminated = stats.all.eliminated - old_eliminated;
+#ifndef CADICAL_QUIET
+  int64_t resolutions = stats.elimres - old_resolutions;
+  PHASE ("elim-round", stats.elimrounds,
+         "eliminated %d variables %.0f%% in %" PRId64 " resolutions",
+         eliminated, percent (eliminated, scheduled), resolutions);
+#endif
+
+  last.elim.subsumephases = stats.subsumephases;
+  const int units = stats.all.fixed - old_fixed;
+  report ('e', !opts.reportall && !(eliminated + units));
+  STOP_SIMPLIFIER (elim, ELIM);
+
+  if (!unsat && !terminated_asynchronously () &&
+      instantiator) // Do we have candidate pairs?
+    instantiate (instantiator);
+
+  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).  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 () {
+
+  if (lim.elimbound >= opts.elimboundmax)
+    return;
+
+  if (lim.elimbound < 0)
+    lim.elimbound = 0;
+  else if (!lim.elimbound)
+    lim.elimbound = 1;
+  else
+    lim.elimbound *= 2;
+
+  if (lim.elimbound > opts.elimboundmax)
+    lim.elimbound = opts.elimboundmax;
+
+  PHASE ("elim-phase", stats.elimphases,
+         "new elimination bound %" PRId64 "", lim.elimbound);
+
+  // Now reschedule all active variables for elimination again.
+  //
+#ifdef LOGGING
+  int count = 0;
+#endif
+  for (auto idx : vars) {
+    if (!active (idx))
+      continue;
+    if (flags (idx).elim)
+      continue;
+    mark_elim (idx);
+#ifdef LOGGING
+    count++;
+#endif
+  }
+  LOG ("marked %d variables as elimination candidates", count);
+
+  report ('^');
+}
+
+void Internal::init_citten () {
+  if (!opts.elimdef)
+    return;
+  CADICAL_assert (!citten);
+  citten = cadical_kitten_init ();
+}
+
+void Internal::reset_citten () {
+  if (citten) {
+    cadical_kitten_release (citten);
+    citten = 0;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elim (bool update_limits) {
+
+  if (unsat)
+    return;
+  if (level)
+    backtrack ();
+  if (!propagate ()) {
+    learn_empty_clause ();
+    return;
+  }
+
+  stats.elimphases++;
+  PHASE ("elim-phase", stats.elimphases,
+         "starting at most %d elimination rounds", opts.elimrounds);
+
+  if (external_prop) {
+    CADICAL_assert (!level);
+    private_steps = true;
+  }
+
+#ifndef CADICAL_QUIET
+  int old_active_variables = active ();
+  int old_eliminated = stats.all.eliminated;
+#endif
+
+  // Make sure there was a complete subsumption phase since last
+  // elimination including vivification etc.
+  //
+  if (last.elim.subsumephases == stats.subsumephases)
+    subsume ();
+
+  reset_watches (); // saves lots of memory
+
+  init_citten ();
+
+  // 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.
+
+  // 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, deleted_binary_clause = false;
+
+  int round = 1;
+#ifndef CADICAL_QUIET
+  int eliminated = 0;
+#endif
+
+  bool round_complete = false;
+  while (!unsat && !phase_complete && !terminated_asynchronously ()) {
+#ifndef CADICAL_QUIET
+    int eliminated =
+#endif
+        elim_round (round_complete, deleted_binary_clause);
+
+    if (!round_complete) {
+      PHASE ("elim-phase", stats.elimphases, "last round %d incomplete %s",
+             round, eliminated ? "but successful" : "and unsuccessful");
+      CADICAL_assert (!phase_complete);
+      break;
+    }
+
+    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");
+      CADICAL_assert (!phase_complete);
+      break;
+    }
+
+    // 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.
+    //
+    PHASE ("elim-phase", stats.elimphases,
+           "no new variable elimination candidates");
+
+    CADICAL_assert (round_complete);
+    phase_complete = true;
+  }
+
+  if (phase_complete) {
+    stats.elimcompleted++;
+    PHASE ("elim-phase", stats.elimphases,
+           "fully completed elimination %" PRId64
+           " at elimination bound %" PRId64 "",
+           stats.elimcompleted, lim.elimbound);
+  } else {
+    PHASE ("elim-phase", stats.elimphases,
+           "incomplete elimination %" PRId64
+           " at elimination bound %" PRId64 "",
+           stats.elimcompleted + 1, lim.elimbound);
+  }
+
+  reset_citten ();
+  if (deleted_binary_clause)
+    delete_garbage_clauses ();
+  init_watches ();
+  connect_watches ();
+
+  if (unsat)
+    LOG ("elimination derived empty clause");
+  else if (propagated < trail.size ()) {
+    LOG ("elimination produced %zd units",
+         (size_t) (trail.size () - propagated));
+    if (!propagate ()) {
+      LOG ("propagating units after elimination results in empty clause");
+      learn_empty_clause ();
+    }
+  }
+
+  // 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 CADICAL_QUIET
+  eliminated = stats.all.eliminated - old_eliminated;
+  PHASE ("elim-phase", stats.elimphases, "eliminated %d variables %.2f%%",
+         eliminated, percent (eliminated, old_active_variables));
+#endif
+
+  if (external_prop) {
+    CADICAL_assert (!level);
+    private_steps = false;
+  }
+
+  if (!update_limits)
+    return;
+
+  int64_t delta = scale (opts.elimint * (stats.elimphases + 1));
+  lim.elim = stats.conflicts + delta;
+
+  PHASE ("elim-phase", stats.elimphases,
+         "new limit at %" PRId64 " conflicts after %" PRId64 " conflicts",
+         lim.elim, delta);
+
+  last.elim.fixed = stats.all.fixed;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_elimfast.cpp b/src/sat/cadical/cadical_elimfast.cpp
new file mode 100644
index 000000000..90dacf8c0
--- /dev/null
+++ b/src/sat/cadical/cadical_elimfast.cpp
@@ -0,0 +1,576 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Implements a variant of elimination with a much lower limit to be run as
+// preprocessing. See elim for comments
+
+/*------------------------------------------------------------------------*/
+
+// Flush garbage clause, check fast elimination limits and return number of
+// remaining occurrences (or 'fastelimbound + 1' if some limit was hit).
+
+int64_t Internal::flush_elimfast_occs (int lit) {
+  const int64_t occslim = opts.fastelimbound;
+  const int64_t clslim = opts.fastelimocclim;
+  const int64_t failed = occslim + 1;
+  Occs &os = occs (lit);
+  const const_occs_iterator end = os.end ();
+  occs_iterator j = os.begin (), i = j;
+  int64_t res = 0;
+  while (i != end) {
+    Clause *c = *i++;
+    if (c->collect ())
+      continue;
+    *j++ = c;
+    if (c->size > clslim) {
+      res = failed;
+      break;
+    }
+    if (++res > occslim) {
+      CADICAL_assert (opts.fastelimbound < 0 || res == failed);
+      break;
+    }
+  }
+  if (i != j) {
+    while (i != end)
+      *j++ = *i++;
+    os.resize (j - os.begin ());
+    shrink_occs (os);
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether the number of non-tautological resolvents on 'pivot' is
+// smaller or equal to the number of clauses with 'pivot' or '-pivot'.  This
+// is the main criteria of bounded variable elimination.  As a side effect
+// it flushes garbage clauses with that variable, sorts its occurrence lists
+// (smallest clauses first) and also negates pivot if it has more positive
+// than negative occurrences.
+
+bool Internal::elimfast_resolvents_are_bounded (Eliminator &eliminator,
+                                                int pivot) {
+  CADICAL_assert (eliminator.gates.empty ());
+  CADICAL_assert (!eliminator.definition_unit);
+
+  stats.elimtried++;
+
+  CADICAL_assert (!unsat);
+  CADICAL_assert (active (pivot));
+
+  const Occs &ps = occs (pivot);
+  const Occs &ns = occs (-pivot);
+
+  int64_t pos = ps.size ();
+  int64_t neg = ns.size ();
+
+  int64_t bound = opts.fastelimbound;
+
+  if (!pos || !neg)
+    return bound >= 0;
+
+  const int64_t sum = pos + neg;
+  const int64_t product = pos * neg;
+  if (bound > sum)
+    bound = sum;
+
+  LOG ("checking number resolvents on %d bounded by "
+       "%" PRId64 " = %" PRId64 " + %" PRId64 " + %d",
+       pivot, bound, pos, neg, opts.fastelimbound);
+
+  if (product <= bound) {
+    LOG ("fast elimination occurrence limits sufficiently small enough");
+    return true;
+  }
+
+  // Try all resolutions between a positive occurrence (outer loop) of
+  // 'pivot' and a negative occurrence of 'pivot' (inner loop) as long the
+  // bound on non-tautological resolvents is not hit and the size of the
+  // generated resolvents does not exceed the resolvent clause size limit.
+
+  int64_t resolvents = 0; // Non-tautological resolvents.
+
+  for (const auto &c : ps) {
+    CADICAL_assert (!c->redundant);
+    if (c->garbage)
+      continue;
+    for (const auto &d : ns) {
+      CADICAL_assert (!d->redundant);
+      if (d->garbage)
+        continue;
+      if (resolve_clauses (eliminator, c, pivot, d, true)) {
+        resolvents++;
+        int size = clause.size ();
+        clause.clear ();
+        LOG ("now at least %" PRId64
+             " non-tautological resolvents on pivot %d",
+             resolvents, pivot);
+        if (size > opts.fastelimclslim) {
+          LOG ("resolvent size %d too big after %" PRId64
+               " resolvents on %d",
+               size, resolvents, pivot);
+          return false;
+        }
+        if (resolvents > bound) {
+          LOG ("too many non-tautological resolvents on %d", pivot);
+          return false;
+        }
+      } else if (unsat)
+        return false;
+      else if (val (pivot))
+        return false;
+    }
+  }
+
+  LOG ("need %" PRId64 " <= %" PRId64 " non-tautological resolvents",
+       resolvents, bound);
+
+  return true;
+}
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+// Add all resolvents on 'pivot' and connect them.
+
+inline void Internal::elimfast_add_resolvents (Eliminator &eliminator,
+                                               int pivot) {
+
+  CADICAL_assert (eliminator.gates.empty ());
+  CADICAL_assert (!eliminator.definition_unit);
+
+  LOG ("adding all resolvents on %d", pivot);
+
+  CADICAL_assert (!val (pivot));
+  CADICAL_assert (!flags (pivot).eliminated ());
+
+  const Occs &ps = occs (pivot);
+  const Occs &ns = occs (-pivot);
+#ifdef LOGGING
+  int64_t resolvents = 0;
+#endif
+  for (auto &c : ps) {
+    if (unsat)
+      break;
+    if (c->garbage)
+      continue;
+    for (auto &d : ns) {
+      if (unsat)
+        break;
+      if (d->garbage)
+        continue;
+      if (!resolve_clauses (eliminator, c, pivot, d, false))
+        continue;
+      CADICAL_assert (!lrat || !lrat_chain.empty ());
+      Clause *r = new_resolved_irredundant_clause ();
+      elim_update_added_clause (eliminator, r);
+      eliminator.enqueue (r);
+      lrat_chain.clear ();
+      clause.clear ();
+#ifdef LOGGING
+      resolvents++;
+#endif
+    }
+  }
+
+  LOG ("added %" PRId64 " resolvents to eliminate %d", resolvents, pivot);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to eliminate 'pivot' by bounded variable elimination.
+void Internal::try_to_fasteliminate_variable (Eliminator &eliminator,
+                                              int pivot,
+                                              bool &deleted_binary_clause) {
+
+  if (!active (pivot))
+    return;
+  CADICAL_assert (!frozen (pivot));
+
+  // First flush garbage clauses and check limits.
+
+  int64_t bound = opts.fastelimbound;
+
+  int64_t pos = flush_elimfast_occs (pivot);
+  if (pos > bound) {
+    LOG ("too many occurrences thus not eliminated %d", pivot);
+    CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
+    return;
+  }
+
+  int64_t neg = flush_elimfast_occs (-pivot);
+  if (neg > bound) {
+    LOG ("too many occurrences thus not eliminated %d", -pivot);
+    CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
+    return;
+  }
+
+  const int64_t product = pos * neg;
+  const int64_t sum = pos + neg;
+  if (bound > sum)
+    bound = sum;
+
+  if (pos > neg) {
+    pivot = -pivot;
+    swap (pos, neg);
+  }
+
+  LOG ("pivot %d occurs positively %" PRId64
+       " times and negatively %" PRId64 " times",
+       pivot, pos, neg);
+
+  CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
+  CADICAL_assert (pos <= neg);
+
+  LOG ("trying to eliminate %d", pivot);
+  CADICAL_assert (!flags (pivot).eliminated ());
+
+  // Sort occurrence lists, such that shorter clauses come first.
+  Occs &ps = occs (pivot);
+  stable_sort (ps.begin (), ps.end (), clause_smaller_size ());
+  Occs &ns = occs (-pivot);
+  stable_sort (ns.begin (), ns.end (), clause_smaller_size ());
+
+  if (!unsat && !val (pivot)) {
+    if (product <= bound ||
+        elimfast_resolvents_are_bounded (eliminator, pivot)) {
+      LOG ("number of resolvents on %d are bounded", pivot);
+      elimfast_add_resolvents (eliminator, pivot);
+      if (!unsat)
+        mark_eliminated_clauses_as_garbage (eliminator, pivot,
+                                            deleted_binary_clause);
+      if (active (pivot))
+        mark_eliminated (pivot);
+    } else {
+      LOG ("too many resolvents on %d so not eliminated", pivot);
+    }
+  }
+
+  unmark_gate_clauses (eliminator);
+  elim_backward_clauses (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+// 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.
+
+int Internal::elimfast_round (bool &completed,
+                              bool &deleted_binary_clause) {
+
+  CADICAL_assert (opts.fastelim);
+  CADICAL_assert (!unsat);
+
+  START_SIMPLIFIER (fastelim, ELIM);
+
+  stats.elimfastrounds++;
+
+  CADICAL_assert (!level);
+
+  int64_t resolution_limit;
+
+  if (opts.elimlimited) {
+    int64_t delta = stats.propagations.search;
+    delta *= 1e-3 * opts.elimeffort;
+    if (delta < opts.elimmineff)
+      delta = opts.elimmineff;
+    if (delta > opts.elimmaxeff)
+      delta = opts.elimmaxeff;
+    delta = max (delta, (int64_t) 2l * active ());
+
+    PHASE ("fastelim-round", stats.elimfastrounds,
+           "limit of %" PRId64 " resolutions", delta);
+
+    resolution_limit = stats.elimres + delta;
+  } else {
+    PHASE ("fastelim-round", stats.elimfastrounds, "resolutions unlimited");
+    resolution_limit = LONG_MAX;
+  }
+
+  init_noccs ();
+
+  // First compute the number of occurrences of each literal and at the same
+  // time mark satisfied clauses and update 'elim' flags of variables in
+  // clauses with root level assigned literals (both false and true).
+  //
+  for (const auto &c : clauses) {
+    if (c->garbage || c->redundant)
+      continue;
+    bool satisfied = false, falsified = false;
+    for (const auto &lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0)
+        satisfied = true;
+      else if (tmp < 0)
+        falsified = true;
+      else
+        CADICAL_assert (active (lit));
+    }
+    if (satisfied)
+      mark_garbage (c); // forces more precise counts
+    else {
+      for (const auto &lit : *c) {
+        if (!active (lit))
+          continue;
+        if (falsified)
+          mark_elim (lit); // simulate unit propagation
+        noccs (lit)++;
+      }
+    }
+  }
+
+  init_occs ();
+
+  Eliminator eliminator (this);
+  ElimSchedule &schedule = eliminator.schedule;
+  CADICAL_assert (schedule.empty ());
+
+  // 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 (auto idx : vars) {
+    if (!active (idx))
+      continue;
+    if (frozen (idx))
+      continue;
+    if (!flags (idx).elim)
+      continue;
+    LOG ("scheduling %d for elimination initially", idx);
+    schedule.push_back (idx);
+  }
+
+  schedule.shrink ();
+
+#ifndef CADICAL_QUIET
+  int64_t scheduled = schedule.size ();
+#endif
+
+  PHASE ("fastelim-round", stats.elimfastrounds,
+         "scheduled %" PRId64 " variables %.0f%% for elimination",
+         scheduled, percent (scheduled, active ()));
+
+  // Connect irredundant clauses.
+  //
+  for (const auto &c : clauses)
+    if (!c->garbage && !c->redundant)
+      for (const auto &lit : *c)
+        if (active (lit))
+          occs (lit).push_back (c);
+
+#ifndef CADICAL_QUIET
+  const int64_t old_resolutions = stats.elimres;
+#endif
+  const int old_eliminated = stats.all.eliminated;
+  const int old_fixed = stats.all.fixed;
+
+  // Limit on garbage literals during variable elimination. If the limit is
+  // hit a garbage collection is performed.
+  //
+  const int64_t garbage_limit = (2 * stats.irrlits / 3) + (1 << 20);
+
+  // 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 CADICAL_QUIET
+  int64_t tried = 0;
+#endif
+  while (!unsat && !terminated_asynchronously () &&
+         stats.elimres <= resolution_limit && !schedule.empty ()) {
+    int idx = schedule.front ();
+    schedule.pop_front ();
+    flags (idx).elim = false;
+    try_to_fasteliminate_variable (eliminator, idx, deleted_binary_clause);
+#ifndef CADICAL_QUIET
+    tried++;
+#endif
+    if (stats.garbage.literals <= garbage_limit)
+      continue;
+    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+    garbage_collection ();
+  }
+
+  // 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 ("fastelim-round", stats.elimfastrounds,
+         "tried to eliminate %" PRId64 " variables %.0f%% (%zd remain)",
+         tried, percent (tried, scheduled), schedule.size ());
+
+  schedule.erase ();
+
+  reset_occs ();
+  reset_noccs ();
+
+  // Mark all redundant clauses with eliminated variables as garbage.
+  //
+  if (!unsat)
+    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+
+  int eliminated = stats.all.eliminated - old_eliminated;
+  stats.all.fasteliminated += eliminated;
+#ifndef CADICAL_QUIET
+  int64_t resolutions = stats.elimres - old_resolutions;
+  PHASE ("fastelim-round", stats.elimfastrounds,
+         "eliminated %d variables %.0f%% in %" PRId64 " resolutions",
+         eliminated, percent (eliminated, scheduled), resolutions);
+#endif
+
+  const int units = stats.all.fixed - old_fixed;
+  report ('e', !opts.reportall && !(eliminated + units));
+  STOP_SIMPLIFIER (fastelim, ELIM);
+
+  return eliminated; // non-zero if successful
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elimfast () {
+
+  if (unsat)
+    return;
+  if (level)
+    backtrack ();
+  if (!propagate ()) {
+    learn_empty_clause ();
+    return;
+  }
+
+  stats.elimfastphases++;
+  PHASE ("fastelim-phase", stats.elimfastphases,
+         "starting at most %d elimination rounds", opts.fastelimrounds);
+
+  if (external_prop) {
+    CADICAL_assert (!level);
+    private_steps = true;
+  }
+
+#ifndef CADICAL_QUIET
+  int old_active_variables = active ();
+  int old_eliminated = stats.all.eliminated;
+#endif
+
+  reset_watches (); // saves lots of memory
+
+  // 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.
+
+  // 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, deleted_binary_clause = false;
+
+  int round = 1;
+#ifndef CADICAL_QUIET
+  int eliminated = 0;
+#endif
+
+  bool round_complete = false;
+  while (!unsat && !phase_complete && !terminated_asynchronously ()) {
+#ifndef CADICAL_QUIET
+    int eliminated =
+#endif
+        elimfast_round (round_complete, deleted_binary_clause);
+
+    if (!round_complete) {
+      PHASE ("fastelim-phase", stats.elimphases,
+             "last round %d incomplete %s", round,
+             eliminated ? "but successful" : "and unsuccessful");
+      CADICAL_assert (!phase_complete);
+      break;
+    }
+
+    if (round++ >= opts.fastelimrounds) {
+      PHASE ("fastelim-phase", stats.elimphases, "round limit %d hit (%s)",
+             round - 1,
+             eliminated ? "though last round successful"
+                        : "last round unsuccessful anyhow");
+      CADICAL_assert (!phase_complete);
+      break;
+    }
+
+    // Prioritize 'subsumption' over blocked and covered clause elimination.
+
+    if (subsume_round ())
+      continue;
+
+    // Was not able to generate new variable elimination candidates after
+    // variable elimination round, neither through subsumption, nor blocked,
+    // nor covered clause elimination.
+    //
+    PHASE ("fastelim-phase", stats.elimphases,
+           "no new variable elimination candidates");
+
+    CADICAL_assert (round_complete);
+    phase_complete = true;
+  }
+
+  for (auto idx : vars) {
+    if (active (idx))
+      flags (idx).elim = true;
+  }
+
+  if (phase_complete) {
+    stats.elimcompleted++;
+    PHASE ("fastelim-phase", stats.elimphases,
+           "fully completed elimination %" PRId64
+           " at elimination bound %" PRId64 "",
+           stats.elimcompleted, lim.elimbound);
+  } else {
+    PHASE ("fastelim-phase", stats.elimphases,
+           "incomplete elimination %" PRId64
+           " at elimination bound %" PRId64 "",
+           stats.elimcompleted + 1, lim.elimbound);
+  }
+
+  if (deleted_binary_clause)
+    delete_garbage_clauses ();
+  init_watches ();
+  connect_watches ();
+
+  if (unsat)
+    LOG ("elimination derived empty clause");
+  else if (propagated < trail.size ()) {
+    LOG ("elimination produced %zd units",
+         (size_t) (trail.size () - propagated));
+    if (!propagate ()) {
+      LOG ("propagating units after elimination results in empty clause");
+      learn_empty_clause ();
+    }
+  }
+
+#ifndef CADICAL_QUIET
+  eliminated = stats.all.eliminated - old_eliminated;
+  PHASE ("fastelim-phase", stats.elimphases,
+         "eliminated %d variables %.2f%%", eliminated,
+         percent (eliminated, old_active_variables));
+#endif
+
+  if (external_prop) {
+    CADICAL_assert (!level);
+    private_steps = false;
+  }
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_ema.cpp b/src/sat/cadical/cadical_ema.cpp
new file mode 100644
index 000000000..e8faf5d76
--- /dev/null
+++ b/src/sat/cadical/cadical_ema.cpp
@@ -0,0 +1,101 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// Updating an exponential moving average is placed here since we want to
+// log both updates and phases of initialization, thus need 'LOG'.
+//
+// We now use initialization bias correction as in the ADAM method
+// [KingmaBa-ICLR'15] instead of our ad-hoc initialization method used
+// before.  Our old variant used exponentially decreasing alphas:
+//
+//   1,
+//   1/2, 1/2,
+//   1/4, 1/4, 1/4, 1/4
+//   1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8,
+//   ...
+//   2^-n, ..., 2^-n                          'n' times
+//   alpha, alpha, ...                        now 'alpha' forever.
+//
+//   where 2^-n is the smallest negative power of two above 'alpha'
+//
+// This old method is better than the initializations described in our
+// [BiereFroehlich-POS'15] paper and actually faster than the ADAM method,
+// but less precise.  We consider this old method obsolete now but it
+// could still be useful for implementations relying on integers instead
+// of floating points because it only needs shifts and integer arithmetic.
+//
+// Our new method for unbiased initialization of the exponential averages
+// works as follows.  First the biased moving average is computed as usual.
+// Note that (as already before) we use the simpler equation
+//
+//   new_biased = old_biased + alpha * (y - old_biased);
+//
+// which in principle (and thus easy to remember) can be implemented as
+//
+//   biased += alpha * (y - biased);
+//
+// The original formulation in the ADAM paper (with 'alpha = 1 - beta') is
+//
+//   new_biased = beta * old_biased + (1 - beta) * y
+//
+// To show that these are equivalent (modulo floating point issues)
+// consider the following equivalent expressions:
+//
+//   old_biased + alpha * (y - old_biased)
+//   old_biased + alpha * y - alpha * old_biased
+//   (1 - alpha) * old_biased + alpha * y
+//   beta * old_biased + (1 - beta) * y
+//
+// The real new idea taken from the ADAM paper is however to fix the biased
+// moving average with a correction term '1.0 / (1.0 - pow (beta, updated))'
+// by multiplication to obtain an unbiased moving average (called simply
+// 'value' in our 'code').  In order to avoid computing 'pow' every time, we
+// use 'exp' which is multiplied in every update with 'beta'.
+
+void EMA::update (Internal *internal, double y, const char *name) {
+#ifdef LOGGING
+  updated++;
+  const double old_value = value;
+#endif
+  const double old_biased = biased;
+  const double delta = y - old_biased;
+  const double scaled_delta = alpha * delta;
+  const double new_biased = old_biased + scaled_delta;
+  LOG ("update %" PRIu64 " of biased %s EMA %g with %g (delta %g) "
+       "yields %g (scaled delta %g)",
+       updated, name, old_biased, y, delta, new_biased, scaled_delta);
+  biased = new_biased;
+  const double old_exp = exp;
+  double new_exp, div, new_value;
+  if (old_exp) {
+    new_exp = old_exp * beta;
+    CADICAL_assert (new_exp < 1);
+    exp = new_exp;
+    div = 1 - new_exp;
+    CADICAL_assert (div > 0);
+    new_value = new_biased / div;
+  } else {
+    new_value = new_biased;
+#ifdef LOGGING
+    new_exp = 0;
+    div = 1;
+#endif
+  }
+  value = new_value;
+  LOG ("update %" PRIu64 " of corrected %s EMA %g with %g (delta %g) "
+       "yields %g (exponent %g, divisor %g)",
+       updated, name, old_value, y, delta, new_value, new_exp, div);
+#ifndef LOGGING
+  (void) internal;
+  (void) name;
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_extend.cpp b/src/sat/cadical/cadical_extend.cpp
new file mode 100644
index 000000000..c549e90fa
--- /dev/null
+++ b/src/sat/cadical/cadical_extend.cpp
@@ -0,0 +1,287 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void External::push_zero_on_extension_stack () {
+  extension.push_back (0);
+  LOG ("pushing 0 on extension stack");
+}
+
+void External::push_id_on_extension_stack (int64_t id) {
+  const uint32_t higher_bits = static_cast<int> (id << 32);
+  const uint32_t lower_bits = (id & (((int64_t) 1 << 32) - 1));
+  extension.push_back (higher_bits);
+  extension.push_back (lower_bits);
+  LOG ("pushing id %" PRIu64 " = %d + %d", id, higher_bits, lower_bits);
+}
+
+void External::push_clause_literal_on_extension_stack (int ilit) {
+  CADICAL_assert (ilit);
+  const int elit = internal->externalize (ilit);
+  CADICAL_assert (elit);
+  extension.push_back (elit);
+  LOG ("pushing clause literal %d on extension stack (internal %d)", elit,
+       ilit);
+}
+
+void External::push_witness_literal_on_extension_stack (int ilit) {
+  CADICAL_assert (ilit);
+  const int elit = internal->externalize (ilit);
+  CADICAL_assert (elit);
+  extension.push_back (elit);
+  LOG ("pushing witness literal %d on extension stack (internal %d)", elit,
+       ilit);
+  if (marked (witness, elit))
+    return;
+  LOG ("marking witness %d", elit);
+  mark (witness, elit);
+}
+
+// The extension stack allows to reconstruct a satisfying assignment for the
+// original formula after removing eliminated clauses.  This was pioneered
+// by Niklas Soerensson in MiniSAT and for instance is described in our
+// inprocessing paper, published at IJCAR'12.  This first function adds a
+// clause to this stack.  First the blocking or eliminated literal is added,
+// and then the rest of the clause.
+
+void External::push_clause_on_extension_stack (Clause *c) {
+  internal->stats.weakened++;
+  internal->stats.weakenedlen += c->size;
+  push_zero_on_extension_stack ();
+  push_id_on_extension_stack (c->id);
+  push_zero_on_extension_stack ();
+  for (const auto &lit : *c)
+    push_clause_literal_on_extension_stack (lit);
+}
+
+void External::push_clause_on_extension_stack (Clause *c, int pivot) {
+  push_zero_on_extension_stack ();
+  push_witness_literal_on_extension_stack (pivot);
+  push_clause_on_extension_stack (c);
+}
+
+void External::push_binary_clause_on_extension_stack (int64_t id, int pivot,
+                                                      int other) {
+  internal->stats.weakened++;
+  internal->stats.weakenedlen += 2;
+  push_zero_on_extension_stack ();
+  push_witness_literal_on_extension_stack (pivot);
+  push_zero_on_extension_stack ();
+  push_id_on_extension_stack (id);
+  push_zero_on_extension_stack ();
+  push_clause_literal_on_extension_stack (pivot);
+  push_clause_literal_on_extension_stack (other);
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::push_external_clause_and_witness_on_extension_stack (
+    const vector<int> &c, const vector<int> &w, int64_t id) {
+  CADICAL_assert (id);
+  extension.push_back (0);
+  for (const auto &elit : w) {
+    CADICAL_assert (elit != INT_MIN);
+    init (abs (elit));
+    extension.push_back (elit);
+    mark (witness, elit);
+  }
+  extension.push_back (0);
+  const uint32_t higher_bits = static_cast<int> (id << 32);
+  const uint32_t lower_bits = (id & (((int64_t) 1 << 32) - 1));
+  extension.push_back (higher_bits);
+  extension.push_back (lower_bits);
+  extension.push_back (0);
+  for (const auto &elit : c) {
+    CADICAL_assert (elit != INT_MIN);
+    init (abs (elit));
+    extension.push_back (elit);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the actual extension process. It goes backward over the clauses
+// on the extension stack and flips the assignment of one of the blocking
+// literals in the conditional autarky stored before the clause.  In the
+// original algorithm for witness construction for variable elimination and
+// blocked clause removal the conditional autarky consists of a single
+// literal from the removed clause, while in general the autarky witness can
+// contain an arbitrary set of literals.  We are using the more general
+// witness reconstruction here which for instance would also work for
+// super-blocked or set-blocked clauses.
+
+void External::extend () {
+
+  CADICAL_assert (!extended);
+  START (extend);
+  internal->stats.extensions++;
+
+  PHASE ("extend", internal->stats.extensions,
+         "mapping internal %d assignments to %d assignments",
+         internal->max_var, max_var);
+
+#ifndef CADICAL_QUIET
+  int64_t updated = 0;
+#endif
+  for (unsigned i = 1; i <= (unsigned) max_var; i++) {
+    const int ilit = e2i[i];
+    if (!ilit)
+      continue;
+    if (i >= vals.size ())
+      vals.resize (i + 1, false);
+    vals[i] = (internal->val (ilit) > 0);
+#ifndef CADICAL_QUIET
+    updated++;
+#endif
+  }
+  PHASE ("extend", internal->stats.extensions,
+         "updated %" PRId64 " external assignments", updated);
+  PHASE ("extend", internal->stats.extensions,
+         "extending through extension stack of size %zd",
+         extension.size ());
+  const auto begin = extension.begin ();
+  auto i = extension.end ();
+#ifndef CADICAL_QUIET
+  int64_t flipped = 0;
+#endif
+  while (i != begin) {
+    bool satisfied = false;
+    int lit;
+    CADICAL_assert (i != begin);
+    while ((lit = *--i)) {
+      if (satisfied)
+        continue;
+      if (ival (lit) == lit)
+        satisfied = true;
+      CADICAL_assert (i != begin);
+    }
+    CADICAL_assert (i != begin);
+    LOG ("id=%" PRId64, ((int64_t) *i << 32) + *(i - 1));
+    CADICAL_assert (*i || *(i - 1));
+    --i;
+    CADICAL_assert (i != begin);
+    --i;
+    CADICAL_assert (i != begin);
+    CADICAL_assert (!*i);
+    --i;
+    CADICAL_assert (i != begin);
+    if (satisfied)
+      while (*--i)
+        CADICAL_assert (i != begin);
+    else {
+      while ((lit = *--i)) {
+        const int tmp = ival (lit); // not 'signed char'!!!
+        if (tmp != lit) {
+          LOG ("flipping blocking literal %d", lit);
+          CADICAL_assert (lit);
+          CADICAL_assert (lit != INT_MIN);
+          size_t idx = abs (lit);
+          if (idx >= vals.size ())
+            vals.resize (idx + 1, false);
+          vals[idx] = !vals[idx];
+          internal->stats.extended++;
+#ifndef CADICAL_QUIET
+          flipped++;
+#endif
+        }
+        CADICAL_assert (i != begin);
+      }
+    }
+  }
+  PHASE ("extend", internal->stats.extensions,
+         "flipped %" PRId64 " literals during extension", flipped);
+  extended = true;
+  LOG ("extended");
+  STOP (extend);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool External::traverse_witnesses_backward (WitnessIterator &it) {
+  if (internal->unsat)
+    return true;
+  vector<int> clause, witness;
+  const auto begin = extension.begin ();
+  auto i = extension.end ();
+  while (i != begin) {
+    int lit;
+    while ((lit = *--i))
+      clause.push_back (lit);
+    CADICAL_assert (!lit);
+    --i;
+    const int64_t id =
+        ((int64_t) * (i - 1) << 32) + static_cast<int64_t> (*i);
+    CADICAL_assert (id);
+    i -= 2;
+    CADICAL_assert (!*i);
+    CADICAL_assert (i != begin);
+    while ((lit = *--i))
+      witness.push_back (lit);
+    reverse (clause.begin (), clause.end ());
+    reverse (witness.begin (), witness.end ());
+    LOG (clause, "traversing clause");
+    if (!it.witness (clause, witness, id))
+      return false;
+    clause.clear ();
+    witness.clear ();
+  }
+  return true;
+}
+
+bool External::traverse_witnesses_forward (WitnessIterator &it) {
+  if (internal->unsat)
+    return true;
+  vector<int> clause, witness;
+  const auto end = extension.end ();
+  auto i = extension.begin ();
+  if (i != end) {
+    int lit = *i++;
+    do {
+      CADICAL_assert (!lit), (void) lit;
+      while ((lit = *i++))
+        witness.push_back (lit);
+      CADICAL_assert (!lit);
+      CADICAL_assert (i != end);
+      CADICAL_assert (!*i);
+      const int64_t id =
+          ((int64_t) *i << 32) + static_cast<int64_t> (*(i + 1));
+      CADICAL_assert (id > 0);
+      i += 3;
+      CADICAL_assert (*i);
+      CADICAL_assert (i != end);
+      while (i != end && (lit = *i++))
+        clause.push_back (lit);
+      if (!it.witness (clause, witness, id))
+        return false;
+      clause.clear ();
+      witness.clear ();
+    } while (i != end);
+  }
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::conclude_sat () {
+  if (!internal->proof || concluded)
+    return;
+  concluded = true;
+  if (!extended)
+    extend ();
+  vector<int> model;
+  for (int idx = 1; idx <= max_var; idx++) {
+    if (ervars[idx])
+      continue;
+    const int lit = ival (idx);
+    model.push_back (lit);
+  }
+  internal->proof->conclude_sat (model);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_external.cpp b/src/sat/cadical/cadical_external.cpp
new file mode 100644
index 000000000..67d1f918d
--- /dev/null
+++ b/src/sat/cadical/cadical_external.cpp
@@ -0,0 +1,1028 @@
+#include "global.h"
+
+#include "internal.hpp"
+#include <cstdint>
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+External::External (Internal *i)
+    : internal (i), max_var (0), vsize (0), extended (false),
+      concluded (false), terminator (0), learner (0), fixed_listener (0),
+      propagator (0), solution (0), vars (max_var) {
+  CADICAL_assert (internal);
+  CADICAL_assert (!internal->external);
+  internal->external = this;
+}
+
+External::~External () {
+  if (solution)
+    delete[] solution;
+}
+
+void External::enlarge (int new_max_var) {
+
+  CADICAL_assert (!extended);
+
+  size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) new_max_var;
+  while (new_vsize <= (size_t) new_max_var)
+    new_vsize *= 2;
+  LOG ("enlarge external size from %zd to new size %zd", vsize, new_vsize);
+  vsize = new_vsize;
+}
+
+void External::init (int new_max_var, bool extension) {
+  CADICAL_assert (!extended);
+  if (new_max_var <= max_var)
+    return;
+  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_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) {
+    CADICAL_assert (e2i.empty ());
+    e2i.push_back (0);
+    ext_units.push_back (0);
+    ext_units.push_back (0);
+    ext_flags.push_back (0);
+    ervars.push_back (0);
+    CADICAL_assert (internal->i2e.empty ());
+    internal->i2e.push_back (0);
+  } else {
+    CADICAL_assert (e2i.size () == (size_t) max_var + 1);
+    CADICAL_assert (internal->i2e.size () == (size_t) old_internal_max_var + 1);
+  }
+  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);
+    CADICAL_assert (e2i.size () == eidx);
+    e2i.push_back (iidx);
+    ext_units.push_back (0);
+    ext_units.push_back (0);
+    ext_flags.push_back (0);
+    ervars.push_back (0);
+    internal->i2e.push_back (eidx);
+    CADICAL_assert (internal->i2e[iidx] == (int) eidx);
+    CADICAL_assert (e2i[eidx] == (int) iidx);
+  }
+  if (extension)
+    internal->stats.variables_extension += new_vars;
+  else
+    internal->stats.variables_original += new_vars;
+  if (new_max_var >= (int64_t) is_observed.size ())
+    is_observed.resize (1 + (size_t) new_max_var, false);
+  if (internal->opts.checkfrozen)
+    if (new_max_var >= (int64_t) moltentab.size ())
+      moltentab.resize (1 + (size_t) new_max_var, false);
+  CADICAL_assert (iidx == (size_t) new_internal_max_var + 1);
+  CADICAL_assert (eidx == (size_t) new_max_var + 1);
+  CADICAL_assert (ext_units.size () == (size_t) new_max_var * 2 + 2);
+  max_var = new_max_var;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::reset_assumptions () {
+  assumptions.clear ();
+  internal->reset_assumptions ();
+}
+
+void External::reset_concluded () {
+  concluded = false;
+  internal->reset_concluded ();
+}
+
+void External::reset_constraint () {
+  constraint.clear ();
+  internal->reset_constraint ();
+}
+
+void External::reset_extended () {
+  if (!extended)
+    return;
+  LOG ("reset extended");
+  extended = false;
+}
+
+void External::reset_limits () { internal->reset_limits (); }
+
+/*------------------------------------------------------------------------*/
+
+// when extension is true, elit should be a fresh variable and
+// we can set a flag that it is an extension variable.
+// This is then used in the API contracts, that extension variables are
+// never part of the input
+int External::internalize (int elit, bool extension) {
+  int ilit;
+  if (elit) {
+    CADICAL_assert (elit != INT_MIN);
+    const int eidx = abs (elit);
+    if (extension && eidx <= max_var)
+      FATAL ("can not add a definition for an already used variable %d",
+             eidx);
+    if (eidx > max_var) {
+      init (eidx, extension);
+    }
+    if (extension) {
+      CADICAL_assert (ervars.size () > (size_t) eidx);
+      ervars[eidx] = true;
+    }
+    ilit = e2i[eidx];
+    if (elit < 0)
+      ilit = -ilit;
+    if (!ilit) {
+      CADICAL_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;
+      internal->i2e.push_back (eidx);
+      CADICAL_assert (internal->i2e[ilit] == eidx);
+      CADICAL_assert (e2i[eidx] == ilit);
+      if (elit < 0)
+        ilit = -ilit;
+    }
+    if (internal->opts.checkfrozen) {
+      CADICAL_assert (eidx < (int64_t) moltentab.size ());
+      if (moltentab[eidx])
+        FATAL ("can not reuse molten literal %d", eidx);
+    }
+    Flags &f = internal->flags (ilit);
+    if (f.status == Flags::UNUSED)
+      internal->mark_active (ilit);
+    else if (f.status != Flags::ACTIVE && f.status != Flags::FIXED)
+      internal->reactivate (ilit);
+    if (!marked (tainted, elit) && marked (witness, -elit)) {
+      CADICAL_assert (!internal->opts.checkfrozen);
+      LOG ("marking tainted %d", elit);
+      mark (tainted, elit);
+    }
+  } else
+    ilit = 0;
+  return ilit;
+}
+
+void External::add (int elit) {
+  CADICAL_assert (elit != INT_MIN);
+  reset_extended ();
+
+  bool forgettable = false;
+
+  if (internal->opts.check &&
+      (internal->opts.checkwitness || internal->opts.checkfailed)) {
+
+    forgettable =
+        internal->from_propagator && internal->ext_clause_forgettable;
+
+    // Forgettable clauses (coming from the external propagator) are not
+    // saved into the external 'original' stack. They are stored separately
+    // in external 'forgettable_original', from where they are deleted when
+    // the corresponding clause is deleted (actually deleted, not just
+    // marked as garbage).
+    if (!forgettable)
+      original.push_back (elit);
+  }
+
+  const int ilit = internalize (elit);
+  CADICAL_assert (!elit == !ilit);
+
+  // The external literals of the new clause must be saved for later
+  // when the proof is printed during add_original_lit (0)
+  if (elit && (internal->proof || forgettable)) {
+    eclause.push_back (elit);
+    if (internal->lrat) {
+      // actually find unit of -elit (flips elit < 0)
+      unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
+      CADICAL_assert ((size_t) eidx < ext_units.size ());
+      const int64_t id = ext_units[eidx];
+      bool added = ext_flags[abs (elit)];
+      if (id && !added) {
+        ext_flags[abs (elit)] = true;
+        internal->lrat_chain.push_back (id);
+      }
+    }
+  }
+
+  if (!elit && internal->proof && internal->lrat) {
+    for (const auto &elit : eclause) {
+      ext_flags[abs (elit)] = false;
+    }
+  }
+
+  if (elit)
+    LOG ("adding external %d as internal %d", elit, ilit);
+  internal->add_original_lit (ilit);
+
+  // Clean-up saved external literals once proof line is printed
+  if (!elit && (internal->proof || forgettable))
+    eclause.clear ();
+}
+
+void External::assume (int elit) {
+  CADICAL_assert (elit);
+  reset_extended ();
+  if (internal->proof)
+    internal->proof->add_assumption (elit);
+  assumptions.push_back (elit);
+  const int ilit = internalize (elit);
+  CADICAL_assert (ilit);
+  LOG ("assuming external %d as internal %d", elit, ilit);
+  internal->assume (ilit);
+}
+
+bool External::flip (int elit) {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  CADICAL_assert (!propagator);
+
+  int eidx = abs (elit);
+  if (eidx > max_var)
+    return false;
+  if (marked (witness, elit))
+    return false;
+  int ilit = e2i[eidx];
+  if (!ilit)
+    return false;
+  bool res = internal->flip (ilit);
+  if (res && extended)
+    reset_extended ();
+  return res;
+}
+
+bool External::flippable (int elit) {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  CADICAL_assert (!propagator);
+
+  int eidx = abs (elit);
+  if (eidx > max_var)
+    return false;
+  if (marked (witness, elit))
+    return false;
+  int ilit = e2i[eidx];
+  if (!ilit)
+    return false;
+  return internal->flippable (ilit);
+}
+
+bool External::failed (int elit) {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var)
+    return 0;
+  int ilit = e2i[eidx];
+  if (!ilit)
+    return 0;
+  if (elit < 0)
+    ilit = -ilit;
+  return internal->failed (ilit);
+}
+
+void External::constrain (int elit) {
+  if (constraint.size () && !constraint.back ()) {
+    LOG (constraint, "replacing previous constraint");
+    reset_constraint ();
+  }
+  CADICAL_assert (elit != INT_MIN);
+  reset_extended ();
+  const int ilit = internalize (elit);
+  CADICAL_assert (!elit == !ilit);
+  if (elit)
+    LOG ("adding external %d as internal %d to constraint", elit, ilit);
+  else if (!elit && internal->proof) {
+    internal->proof->add_constraint (constraint);
+  }
+  constraint.push_back (elit);
+  internal->constrain (ilit);
+}
+
+bool External::failed_constraint () {
+  return internal->failed_constraint ();
+}
+
+void External::phase (int elit) {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  const int ilit = internalize (elit);
+  internal->phase (ilit);
+}
+
+void External::unphase (int elit) {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var) {
+  UNUSED:
+    LOG ("resetting forced phase of unused external %d ignored", elit);
+    return;
+  }
+  int ilit = e2i[eidx];
+  if (!ilit)
+    goto UNUSED;
+  if (elit < 0)
+    ilit = -ilit;
+  internal->unphase (ilit);
+}
+
+/*------------------------------------------------------------------------*/
+
+// External propagation related functions
+//
+// Note that when an already assigned variable is added as observed, the
+// solver will backtrack to undo this assignment.
+//
+void External::add_observed_var (int elit) {
+  if (!propagator) {
+    LOG ("No connected propagator that could observe the variable, "
+         "observed flag is not set.");
+    return;
+  }
+
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  reset_extended (); // tainting!
+
+  int eidx = abs (elit);
+  if (eidx <= max_var &&
+      (marked (witness, elit) || marked (witness, -elit))) {
+    LOG ("Error, only clean variables are allowed to become observed.");
+    CADICAL_assert (false);
+
+    // TODO: here needs to come the taint and restore of the newly
+    // observed variable. Restore_clauses must be called before continue.
+    // LOG ("marking tainted %d", elit);
+    // mark (tainted, elit);
+    // mark (tainted, -elit);
+    // restore_clauses ...
+  }
+
+  if (eidx >= (int64_t) is_observed.size ())
+    is_observed.resize (1 + (size_t) eidx, false);
+
+  if (is_observed[eidx])
+    return;
+
+  LOG ("marking %d as externally watched", eidx);
+
+  // Will do the necessary internalization
+  freeze (elit);
+  is_observed[eidx] = true;
+
+  int ilit = internalize (elit);
+  // internal add-observed-var backtracks to a lower decision level to
+  // unassign the variable in case it was already assigned previously (but
+  // not on the current level)
+  internal->add_observed_var (ilit);
+
+  if (propagator->is_lazy)
+    return;
+
+  // In case this variable was already assigned (e.g. via unit clause) and
+  // got compacted to map to another (not observed) variable, it can not be
+  // unnasigned so it must be notified explicitly now. (-> Can lead to
+  // repeated fixed assignment notifications, in case it was unobserved and
+  // observed again. But a repeated notification is less error-prone than
+  // never notifying an assignment.)
+  const int tmp = fixed (elit);
+  if (!tmp)
+    return;
+  int unit = tmp < 0 ? -elit : elit;
+
+  LOG ("notify propagator about fixed assignment upon observe for %d",
+       unit);
+
+  // internal add-observed-var had to backtrack to root-level already
+  CADICAL_assert (!internal->level);
+
+  std::vector<int> assigned = {unit};
+  propagator->notify_assignment (assigned);
+}
+
+void External::remove_observed_var (int elit) {
+  if (!propagator) {
+    LOG ("No connected propagator that could have watched the variable");
+    return;
+  }
+  int eidx = abs (elit);
+
+  if (eidx > max_var)
+    return;
+
+  if (is_observed[eidx]) {
+    // Follow opposite order of add_observed_var, first remove internal
+    // is_observed
+    int ilit = e2i[eidx]; // internalize (elit);
+    internal->remove_observed_var (ilit);
+
+    is_observed[eidx] = false;
+    melt (elit);
+    LOG ("unmarking %d as externally watched", eidx);
+  }
+}
+
+void External::reset_observed_vars () {
+  // Shouldn't be called if there is no connected propagator
+  CADICAL_assert (propagator);
+  reset_extended ();
+
+  internal->notified = 0;
+  LOG ("reset notified counter to 0");
+
+  if (!is_observed.size ())
+    return;
+
+  CADICAL_assert (!max_var || (size_t) max_var + 1 == is_observed.size ());
+
+  for (auto elit : vars) {
+    int eidx = abs (elit);
+    CADICAL_assert (eidx <= max_var);
+    if (is_observed[eidx]) {
+      int ilit = internalize (elit);
+      internal->remove_observed_var (ilit);
+      LOG ("unmarking %d as externally watched", eidx);
+      is_observed[eidx] = false;
+      melt (elit);
+    }
+  }
+}
+
+bool External::observed (int elit) {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var)
+    return false;
+  if (eidx >= (int) is_observed.size ())
+    return false;
+
+  return is_observed[eidx];
+}
+
+bool External::is_witness (int elit) {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var)
+    return false;
+  return (marked (witness, elit) || marked (witness, -elit));
+}
+
+bool External::is_decision (int elit) {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var)
+    return false;
+
+  int ilit = internalize (elit);
+  return internal->is_decision (ilit);
+}
+
+void External::force_backtrack (size_t new_level) {
+  if (!propagator) {
+    LOG ("No connected propagator that could force backtracking");
+    return;
+  }
+  LOG ("force backtrack to level %zd", new_level);
+  internal->force_backtrack (new_level);
+}
+
+/*------------------------------------------------------------------------*/
+
+int External::propagate_assumptions () {
+  int res = internal->propagate_assumptions ();
+  if (res == 10 && !extended)
+    extend (); // Call solution reconstruction
+  check_solve_result (res);
+  reset_limits ();
+  return res;
+}
+
+void External::implied (std::vector<int> &trailed) {
+  std::vector<int> ilit_implicants;
+  internal->implied (ilit_implicants);
+
+  // Those implied literals must be filtered out that are witnesses
+  // on the reconstruction stack -> no inplace externalize is possible.
+  // (Internal does not see these marks, so no earlier filter is
+  // possible.)
+
+  trailed.clear();
+
+  for (const auto &ilit : ilit_implicants) {
+    CADICAL_assert (ilit);
+    const int elit = internal->externalize (ilit);
+    const int eidx = abs (elit);
+    const bool is_extension_var = ervars[eidx];
+    if (!marked (tainted, elit) && !is_extension_var) {
+      trailed.push_back (elit);
+    }
+  }
+}
+
+void External::conclude_unknown () {
+  if (!internal->proof || concluded)
+    return;
+  concluded = true;
+
+  vector<int> trail;
+  implied (trail);
+  internal->proof->conclude_unknown (trail);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Internal checker if 'solve' claims the formula to be satisfiable.
+
+void External::check_satisfiable () {
+  LOG ("checking satisfiable");
+  if (!extended)
+    extend ();
+  if (internal->opts.checkwitness)
+    check_assignment (&External::ival);
+  if (internal->opts.checkassumptions && !assumptions.empty ())
+    check_assumptions_satisfied ();
+  if (internal->opts.checkconstraint && !constraint.empty ())
+    check_constraint_satisfied ();
+}
+
+// Internal checker if 'solve' claims formula to be unsatisfiable.
+
+void External::check_unsatisfiable () {
+  LOG ("checking unsatisfiable");
+  if (!internal->opts.checkfailed)
+    return;
+  if (!assumptions.empty () || !constraint.empty ())
+    check_failing ();
+}
+
+// Check result of 'solve' to be correct.
+
+void External::check_solve_result (int res) {
+  if (!internal->opts.check)
+    return;
+  if (res == 10)
+    check_satisfiable ();
+  if (res == 20)
+    check_unsatisfiable ();
+}
+
+// Prepare checking that completely molten literals are not used as argument
+// of 'add' or 'assume', which is invalid under freezing semantics.  This
+// case would be caught by our 'restore' implementation so is only needed
+// for checking the deprecated 'freeze' semantics.
+
+void External::update_molten_literals () {
+  if (!internal->opts.checkfrozen)
+    return;
+  CADICAL_assert ((size_t) max_var + 1 == moltentab.size ());
+#ifdef LOGGING
+  int registered = 0, molten = 0;
+#endif
+  for (auto lit : vars) {
+    if (moltentab[lit]) {
+      LOG ("skipping already molten literal %d", lit);
+#ifdef LOGGING
+      molten++;
+#endif
+    } else if (frozen (lit))
+      LOG ("skipping currently frozen literal %d", lit);
+    else {
+      LOG ("new molten literal %d", lit);
+      moltentab[lit] = true;
+#ifdef LOGGING
+      registered++;
+      molten++;
+#endif
+    }
+  }
+  LOG ("registered %d new molten literals", registered);
+  LOG ("reached in total %d molten literals", molten);
+}
+
+int External::solve (bool preprocess_only) {
+  reset_extended ();
+  update_molten_literals ();
+  int res = internal->solve (preprocess_only);
+  check_solve_result (res);
+  reset_limits ();
+  return res;
+}
+
+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,
+                                                   int min_depth = 0) {
+  reset_extended ();
+  update_molten_literals ();
+  reset_limits ();
+  auto cubes = internal->generate_cubes (depth, min_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) {
+    (void) this;
+    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) {
+  reset_extended ();
+  int ilit = internalize (elit);
+  unsigned eidx = vidx (elit);
+  if (eidx >= frozentab.size ())
+    frozentab.resize (eidx + 1, 0);
+  unsigned &ref = frozentab[eidx];
+  if (ref < UINT_MAX) {
+    ref++;
+    LOG ("external variable %d frozen once and now frozen %u times", eidx,
+         ref);
+  } else
+    LOG ("external variable %d frozen but remains frozen forever", eidx);
+  internal->freeze (ilit);
+}
+
+void External::melt (int elit) {
+  reset_extended ();
+  int ilit = internalize (elit);
+  unsigned eidx = vidx (elit);
+  CADICAL_assert (eidx < frozentab.size ());
+  unsigned &ref = frozentab[eidx];
+  CADICAL_assert (ref > 0);
+  if (ref < UINT_MAX) {
+    if (!--ref) {
+      if (observed (elit)) {
+        ref++;
+        LOG ("external variable %d is observed, can not be completely "
+             "molten",
+             eidx);
+      } else
+        LOG ("external variable %d melted once and now completely melted",
+             eidx);
+    } else
+      LOG ("external variable %d melted once but remains frozen %u times",
+           eidx, ref);
+  } else
+    LOG ("external variable %d melted but remains frozen forever", eidx);
+  internal->melt (ilit);
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::check_assignment (int (External::*a) (int) const) {
+
+  // First check all assigned and consistent.
+  //
+  for (auto idx : vars) {
+    if (!(this->*a) (idx))
+      FATAL ("unassigned variable: %d", idx);
+    int value_idx = (this->*a) (idx);
+    int value_neg_idx = (this->*a) (-idx);
+    if (value_idx == idx)
+      CADICAL_assert (value_neg_idx == idx);
+    else {
+      CADICAL_assert (value_idx == -idx);
+      CADICAL_assert (value_neg_idx == -idx);
+    }
+    if (value_idx != value_neg_idx)
+      FATAL ("inconsistently assigned literals %d and %d", idx, -idx);
+  }
+
+  // Then check that all (saved) original clauses are satisfied.
+  //
+  bool satisfied = false;
+  const auto end = original.end ();
+  auto start = original.begin (), i = start;
+#ifndef CADICAL_QUIET
+  int64_t count = 0;
+#endif
+  for (; i != end; i++) {
+    int lit = *i;
+    if (!lit) {
+      if (!satisfied) {
+        fatal_message_start ();
+        fputs ("unsatisfied clause:\n", stderr);
+        for (auto j = start; j != i; j++)
+          fprintf (stderr, "%d ", *j);
+        fputc ('0', stderr);
+        fatal_message_end ();
+      }
+      satisfied = false;
+      start = i + 1;
+#ifndef CADICAL_QUIET
+      count++;
+#endif
+    } else if (!satisfied && (this->*a) (lit) == lit)
+      satisfied = true;
+  }
+
+  bool presence_flag;
+  // Check those forgettable external clauses that are still present, but
+  // only if the external propagator is still connected (otherwise solution
+  // reconstruction is allowed to touch the previously observed variables so
+  // there is no guarantee that the final model will satisfy these clauses.)
+  for (const auto &forgettables : forgettable_original) {
+    if (!propagator)
+      break;
+    presence_flag = true;
+    satisfied = false;
+#ifndef CADICAL_QUIET
+    count++;
+#endif
+    std::vector<int> literals;
+    for (const auto lit : forgettables.second) {
+      if (presence_flag) {
+        // First integer is a Boolean flag, not a literal
+        if (!lit) {
+          // Deleted clauses can be ignored, they count as satisfied
+          satisfied = true;
+          break;
+        }
+        presence_flag = false;
+        continue;
+      }
+
+      if ((this->*a) (lit) == lit) {
+        satisfied = true;
+        break;
+      }
+    }
+
+    if (!satisfied) {
+      fatal_message_start ();
+      fputs ("unsatisfied external forgettable clause:\n", stderr);
+      for (size_t j = 1; j < forgettables.second.size (); j++)
+        fprintf (stderr, "%d ", forgettables.second[j]);
+      fputc ('0', stderr);
+      fatal_message_end ();
+    }
+  }
+#ifndef CADICAL_QUIET
+  VERBOSE (1, "satisfying assignment checked on %" PRId64 " clauses",
+           count);
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::check_assumptions_satisfied () {
+  for (const auto &lit : assumptions) {
+    // Not 'signed char' !!!!
+    const int tmp = ival (lit);
+    if (tmp != lit)
+      FATAL ("assumption %d falsified", lit);
+    if (!tmp)
+      FATAL ("assumption %d unassigned", lit);
+  }
+  VERBOSE (1, "checked that %zd assumptions are satisfied",
+           assumptions.size ());
+}
+
+void External::check_constraint_satisfied () {
+  for (const auto lit : constraint) {
+    if (ival (lit) == lit) {
+      VERBOSE (1, "checked that constraint is satisfied");
+      return;
+    }
+  }
+  FATAL ("constraint not satisfied");
+}
+
+void External::check_failing () {
+  Solver *checker = new Solver ();
+  DeferDeletePtr<Solver> delete_checker (checker);
+  checker->prefix ("checker ");
+#ifdef LOGGING
+  if (internal->opts.log)
+    checker->set ("log", true);
+#endif
+
+  for (const auto lit : assumptions) {
+    if (!failed (lit))
+      continue;
+    LOG ("checking failed literal %d in core", lit);
+    checker->add (lit);
+    checker->add (0);
+  }
+  if (failed_constraint ()) {
+    LOG (constraint, "checking failed constraint");
+    for (const auto lit : constraint)
+      checker->add (lit);
+  } else if (constraint.size ())
+    LOG (constraint, "constraint satisfied and ignored");
+
+  // Add original clauses as last step, failing () and failed_constraint ()
+  // might add more external clauses (due to lazy explanation)
+  for (const auto lit : original)
+    checker->add (lit);
+
+  // Add every forgettable external clauses
+  for (const auto &forgettables : forgettable_original) {
+    bool presence_flag = true;
+    for (const auto lit : forgettables.second) {
+      if (presence_flag) {
+        // First integer is a Boolean flag, not a literal, ignore it here
+        presence_flag = false;
+        continue;
+      }
+      checker->add (lit);
+    }
+    checker->add (0);
+  }
+
+  int res = checker->solve ();
+  if (res != 20)
+    FATAL ("failed assumptions do not form a core");
+  delete_checker.free ();
+  VERBOSE (1, "checked that %zd failing assumptions form a core",
+           assumptions.size ());
+}
+
+/*------------------------------------------------------------------------*/
+
+// Traversal of unit clauses is implemented here.
+
+// In principle we want to traverse the clauses of the simplified formula
+// only, particularly eliminated variables should be completely removed.
+// This poses the question what to do with unit clauses.  Should they be
+// considered part of the simplified formula or of the witness to construct
+// solutions for the original formula?  Ideally they should be considered
+// to be part of the witness only, i.e., as they have been simplified away.
+
+// Therefore we distinguish frozen and non-frozen units during clause
+// traversal.  Frozen units are treated as unit clauses while non-frozen
+// units are treated as if they were already eliminated and put on the
+// extension stack as witness clauses.
+
+// Furthermore, eliminating units during 'compact' could be interpreted as
+// variable elimination, i.e., just add the resolvents (remove falsified
+// literals), then drop the clauses with the unit, and push the unit on the
+// extension stack.  This is of course only OK if the user did not freeze
+// that variable (even implicitly during assumptions).
+
+// Thanks go to Fahiem Bacchus for asking why there is a necessity to
+// distinguish these two cases (frozen and non-frozen units).  The answer is
+// that it is not strictly necessary, and this distinction could be avoided
+// by always treating units as remaining unit clauses, thus only using the
+// first of the two following functions and dropping the 'if (!frozen (idx))
+// continue;' check in it.  This has however the down-side that those units
+// are still in the simplified formula and only as units.  I would not
+// consider such a formula as really being 'simplified'. On the other hand
+// if the user explicitly freezes a literal, then it should continue to be
+// in the simplified formula during traversal.  So also only using the
+// second function is not ideal.
+
+// There is however a catch where this solution breaks down (in the sense of
+// producing less optimal results - that is keeping units in the formula
+// which better would be witness clauses).  The problem is with compact
+// preprocessing which removes eliminated but also fixed internal variables.
+// One internal unit (fixed) variable is kept and all the other external
+// literals which became unit are mapped to that internal literal (negated
+// or positively).  Compact is called non-deterministically from the point
+// of the user and thus there is no control on when this happens.  If
+// compact happens those external units are mapped to a single internal
+// literal now and then all share the same 'frozen' counter.   So if the
+// user freezes one of them all in essence get frozen, which in turn then
+// makes a difference in terms of traversing such a unit as unit clause or
+// as unit witness.
+
+bool External::traverse_all_frozen_units_as_clauses (ClauseIterator &it) {
+  if (internal->unsat)
+    return true;
+
+  vector<int> clause;
+
+  for (auto idx : vars) {
+    if (!frozen (idx))
+      continue;
+    const int tmp = fixed (idx);
+    if (!tmp)
+      continue;
+    int unit = tmp < 0 ? -idx : idx;
+    clause.push_back (unit);
+    if (!it.clause (clause))
+      return false;
+    clause.clear ();
+  }
+
+  return true;
+}
+
+bool External::traverse_all_non_frozen_units_as_witnesses (
+    WitnessIterator &it) {
+  if (internal->unsat)
+    return true;
+
+  vector<int> clause_and_witness;
+  for (auto idx : vars) {
+    if (frozen (idx))
+      continue;
+    const int tmp = fixed (idx);
+    if (!tmp)
+      continue;
+    int unit = tmp < 0 ? -idx : idx;
+    const int ilit = e2i[idx] * (tmp < 0 ? -1 : 1);
+    // heurstically add + max_var to the id to avoid reusing ids
+    const int64_t id = internal->lrat ? internal->unit_id (ilit) : 1;
+    CADICAL_assert (id);
+    clause_and_witness.push_back (unit);
+    if (!it.witness (clause_and_witness, clause_and_witness, id + max_var))
+      return false;
+    clause_and_witness.clear ();
+  }
+
+  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;
+    CADICAL_assert (this_ilit != INT_MIN);
+    CADICAL_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 () {
+  CADICAL_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) {
+  CADICAL_assert (learner);
+  if (learner->learning (1)) {
+    LOG ("exporting learned unit clause");
+    const int elit = internal->externalize (ilit);
+    CADICAL_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) {
+  CADICAL_assert (learner);
+  size_t size = clause.size ();
+  CADICAL_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);
+      CADICAL_assert (elit);
+      learner->learn (elit);
+    }
+    learner->learn (0);
+  } else
+    LOG ("not exporting learned clause of size %zu", size);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_external_propagate.cpp b/src/sat/cadical/cadical_external_propagate.cpp
new file mode 100644
index 000000000..215170c8b
--- /dev/null
+++ b/src/sat/cadical/cadical_external_propagate.cpp
@@ -0,0 +1,1232 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*----------------------------------------------------------------------------*/
+//
+// Mark a variable as an observed one. It can be a new variable. It is
+// assumed to be clean (not eliminated by previous simplifications).
+//
+void Internal::add_observed_var (int ilit) {
+  int idx = vidx (ilit);
+  if (idx >= (int64_t) relevanttab.size ())
+    relevanttab.resize (1 + (size_t) idx, 0);
+  unsigned &ref = relevanttab[idx];
+  if (ref < UINT_MAX) {
+    ref++;
+    LOG ("variable %d is observed %u times", idx, ref);
+  } else
+    LOG ("variable %d remains observed forever", idx);
+  // TODO: instead of actually backtracking, it would be enough to notify
+  // backtrack and re-play again every levels' notification to the
+  // propagator
+  if (val (ilit) && level && !fixed (ilit)) {
+    // The variable is already assigned, but we can not send a notification
+    // about it because it happened on an earlier decision level.
+    // To not break the stack-like view of the trail, we simply backtrack to
+    // undo this unnotifiable assignment.
+    const int assignment_level = var (ilit).level;
+    backtrack (assignment_level - 1);
+  } else if (level && fixed (ilit)) {
+    backtrack (0);
+  }
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Removing an observed variable should happen only once it is ensured
+// that there is no unexplained propagation in the implication
+// graph involving this variable.
+//
+void Internal::remove_observed_var (int ilit) {
+  if (!fixed (ilit) && level) {
+    backtrack ();
+  }
+
+  CADICAL_assert (fixed (ilit) || !level);
+
+  const int idx = vidx (ilit);
+  CADICAL_assert ((size_t) idx < relevanttab.size ());
+  unsigned &ref = relevanttab[idx];
+  CADICAL_assert (fixed (ilit) || ref > 0);
+  if (fixed (ilit))
+    ref = 0;
+  else if (ref < UINT_MAX) {
+    if (!--ref) {
+      LOG ("variable %d is not observed anymore", idx);
+    } else
+      LOG ("variable %d is unobserved once but remains observed %u times",
+           ilit, ref);
+  } else
+    LOG ("variable %d remains observed forever", idx);
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Supposed to be used only by mobical.
+//
+bool Internal::observed (int ilit) const {
+  CADICAL_assert ((size_t) vidx (ilit) < relevanttab.size ());
+  return relevanttab[vidx (ilit)] > 0;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Check for unexplained propagations upon disconnecting external propagator
+//
+void Internal::set_tainted_literal () {
+  if (!opts.ilb) {
+    return;
+  }
+  for (auto idx : vars) {
+    if (!val (idx))
+      continue;
+    if (var (idx).reason != external_reason)
+      continue;
+    if (!tainted_literal) {
+      tainted_literal = idx;
+      continue;
+    }
+    CADICAL_assert (val (tainted_literal));
+    if (var (idx).level < var (tainted_literal).level) {
+      tainted_literal = idx;
+    }
+  }
+}
+
+void Internal::renotify_trail_after_ilb () {
+  if (!external_prop || external_prop_is_lazy || !trail.size () ||
+      !opts.ilb) {
+    return;
+  }
+  LOG ("notify external propagator about new assignments (after ilb)");
+#ifndef CADICAL_NDEBUG
+  LOG ("(decision level: %d, trail size: %zd, notified %zd)", level,
+       trail.size (), notified);
+#endif
+  renotify_full_trail ();
+}
+
+void Internal::renotify_trail_after_local_search () {
+  if (!external_prop || external_prop_is_lazy || !trail.size ()) {
+    return;
+  }
+  LOG ("notify external propagator about new assignments (after local "
+       "search)");
+#ifndef CADICAL_NDEBUG
+  LOG ("(decision level: %d, trail size: %zd, notified %zd)", level,
+       trail.size (), notified);
+#endif
+  renotify_full_trail ();
+}
+
+// It repeats ALL assignments of the trail, so the already notified
+// root-level assignments will be notified multiple times.
+
+void Internal::renotify_full_trail () {
+  const size_t end_of_trail = trail.size ();
+  if (level) {
+    notified = 0; // TODO: save the last notified root-level position
+                  // somewhere and use it here
+    notify_backtrack (0);
+  }
+  std::vector<int> assigned;
+
+  int prev_max_level = 0;
+  int current_level = 0;
+  int propagator_level = 0;
+
+  while (notified < end_of_trail) {
+    int ilit = trail[notified++];
+    // In theory, 0 ilit can happen due to pseudo-decision levels
+    if (!ilit)
+      current_level = prev_max_level + 1;
+    else
+      current_level = var (ilit).level;
+
+    if (current_level > propagator_level) {
+      if (assigned.size ())
+        external->propagator->notify_assignment (assigned);
+      while (current_level > propagator_level) {
+        external->propagator->notify_new_decision_level ();
+        propagator_level++;
+      }
+      assigned.clear ();
+    }
+    // Current level can be smaller than prev_max_level due to chrono
+    if (current_level > prev_max_level)
+      prev_max_level = current_level;
+
+    if (!observed (ilit))
+      continue;
+
+    int elit = externalize (ilit); // TODO: double-check tainting
+    CADICAL_assert (elit);
+    // Fixed variables might get mapped (during compact) to another
+    // non-observed but fixed variable.
+    // This happens on root level, so notification about their assignment is
+    // already done.
+    CADICAL_assert (external->observed (elit) || fixed (ilit));
+    if (!external->ervars[abs (elit)])
+      assigned.push_back (elit);
+  }
+  if (assigned.size ())
+    external->propagator->notify_assignment (assigned);
+  assigned.clear ();
+
+  // In case there are some left over empty levels on the top of the trail,
+  // the external propagtor must be notified about them so the levels are
+  // synced
+  while (level > propagator_level) {
+    external->propagator->notify_new_decision_level ();
+    propagator_level++;
+  }
+
+  return;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Check if the variable is assigned by decision.
+//
+bool Internal::is_decision (int ilit) {
+  if (!level || fixed (ilit) || !val (ilit))
+    return false;
+
+  const int idx = vidx (ilit);
+  Var &v = var (idx);
+#ifndef CADICAL_NDEBUG
+  LOG (v.reason,
+       "is_decision: i%d (current level: %d, is_fixed: %d, v.level: %d, "
+       "is_external_reason: %d, v.reason: )",
+       ilit, level, fixed (ilit), v.level, v.reason == external_reason);
+#endif
+  if (!v.level || v.reason)
+    return false;
+  CADICAL_assert (!v.reason);
+  return true;
+}
+
+void Internal::force_backtrack (size_t new_level) {
+  if (!forced_backt_allowed || level <= 0 || new_level >= (size_t) level)
+    return;
+
+#ifndef CADICAL_NDEBUG
+  LOG ("external propagator forces backtrack to decision level"
+       "%zd (from level %d)",
+       new_level, level);
+#endif
+  backtrack (new_level);
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Call external propagator to check if there is a literal to be propagated.
+// The reason of the propagation is not necessarily asked at that point.
+//
+// In case the externally propagated literal is already falsified, the
+// reason is asked and conflict analysis starts. In case the externally
+// propagated literal is already satisfied, nothing happens.
+//
+bool Internal::external_propagate () {
+  if (level)
+    require_mode (SEARCH);
+  CADICAL_assert (!unsat);
+
+  size_t before = num_assigned;
+  bool cb_repropagate_needed = true;
+  while (cb_repropagate_needed && !conflict && external_prop &&
+         !external_prop_is_lazy && !private_steps) {
+#ifndef CADICAL_NDEBUG
+    LOG ("external propagation starts (decision level: %d, trail size: "
+         "%zd, notified %zd)",
+         level, trail.size (), notified);
+#endif
+    cb_repropagate_needed = false;
+    // external->reset_extended (); //TODO for inprocessing
+
+    notify_assignments ();
+
+    int elit = external->propagator->cb_propagate ();
+    stats.ext_prop.ext_cb++;
+    stats.ext_prop.eprop_call++;
+    while (elit) {
+      CADICAL_assert (external->is_observed[abs (elit)]);
+      int ilit = external->e2i[abs (elit)];
+      if (elit < 0)
+        ilit = -ilit;
+      int tmp = val (ilit);
+#ifndef CADICAL_NDEBUG
+      CADICAL_assert (fixed (ilit) || observed (ilit));
+      LOG ("External propagation of e%d (i%d val: %d)", elit, ilit, tmp);
+#endif
+      if (!tmp) {
+        // variable is not assigned, it can be propagated
+        if (!level) {
+          Clause *res = learn_external_reason_clause (ilit, elit);
+#ifndef LOGGING
+          LOG (res, "reason clause of external propagation of %d:", elit);
+#endif
+          (void) res;
+        } else
+          search_assign_external (ilit);
+        stats.ext_prop.eprop_prop++;
+
+        if (unsat || conflict)
+          break;
+        propagate ();
+        if (unsat || conflict)
+          break;
+        notify_assignments ();
+      } else if (tmp < 0) {
+        LOG ("External propgation of %d is falsified under current trail",
+             ilit);
+        stats.ext_prop.eprop_conf++;
+        int level_before = level;
+        size_t assigned = num_assigned;
+        Clause *res = learn_external_reason_clause (ilit, elit);
+#ifndef LOGGING
+        LOG (res, "reason clause of external propagation of %d:", elit);
+#endif
+        (void) res;
+        bool trail_changed =
+            (num_assigned != assigned || level != level_before ||
+             propagated < trail.size ());
+
+        if (unsat || conflict)
+          break;
+
+        if (trail_changed) {
+          propagate ();
+          if (unsat || conflict)
+            break;
+          notify_assignments ();
+        }
+      } // else (tmp > 0) -> the case of a satisfied literal is ignored
+      elit = external->propagator->cb_propagate ();
+      stats.ext_prop.ext_cb++;
+      stats.ext_prop.eprop_call++;
+    }
+
+#ifndef CADICAL_NDEBUG
+    LOG ("External propagation ends (decision level: %d, trail size: %zd, "
+         "notified %zd)",
+         level, trail.size (), notified);
+#endif
+    if (!unsat && !conflict) {
+      int level_before = level;
+      size_t assigned = num_assigned;
+      bool has_external_clause = ask_external_clause ();
+      // New observed variable might have triggered a backtrack during this
+      // ask_external_clause call, so we need to propagate before continuing
+      stats.ext_prop.ext_cb++;
+      stats.ext_prop.elearn_call++;
+
+      bool trail_changed =
+          (num_assigned != assigned || level != level_before ||
+           propagated < trail.size ());
+      if (trail_changed) {
+        propagate (); // unsat or conflict will be caught later
+        if (!unsat || !conflict)
+          notify_assignments ();
+      }
+
+#ifndef CADICAL_NDEBUG
+      if (has_external_clause)
+        LOG ("New external clauses are to be added.");
+      else
+        LOG ("No external clauses to be added.");
+#endif
+
+      while (has_external_clause) {
+        level_before = level;
+        assigned = num_assigned;
+
+        add_external_clause (0);
+        trail_changed =
+            (num_assigned != assigned || level != level_before ||
+             propagated < trail.size ());
+        cb_repropagate_needed = true;
+
+        if (unsat || conflict) {
+          cb_repropagate_needed = false;
+          break;
+        }
+
+        if (trail_changed) {
+          propagate ();
+          if (unsat || conflict) {
+            cb_repropagate_needed = false;
+            break;
+          }
+
+          notify_assignments ();
+        }
+        has_external_clause = ask_external_clause ();
+        stats.ext_prop.ext_cb++;
+        stats.ext_prop.elearn_call++;
+      }
+    }
+#ifndef CADICAL_NDEBUG
+    LOG ("External clause addition ends on decision level %d at trail "
+         "size "
+         "%zd (notified %zd)",
+         level, trail.size (), notified);
+#endif
+  }
+  if (before < num_assigned)
+    did_external_prop = true;
+  return !conflict;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Helper function, calls 'cb_has_external_clause', while maintains the
+// related redundancy type of the clause.
+//
+
+bool Internal::ask_external_clause () {
+  ext_clause_forgettable = false;
+  bool res =
+      external->propagator->cb_has_external_clause (ext_clause_forgettable);
+
+  return res;
+}
+/*----------------------------------------------------------------------------*/
+//
+// Literals of the externally learned clause must be reordered based on the
+// assignment levels of the literals.
+//
+void Internal::move_literals_to_watch () {
+  if (clause.size () < 2)
+    return;
+  if (!level)
+    return;
+
+  for (int i = 0; i < 2; i++) {
+    int highest_position = i;
+    int highest_literal = clause[i];
+
+    int highest_level = var (highest_literal).level;
+    int highest_value = val (highest_literal);
+
+    for (size_t j = i + 1; j < clause.size (); j++) {
+      const int other = clause[j];
+      const int other_level = var (other).level;
+      const int other_value = val (other);
+
+      if (other_value < 0) {
+        if (highest_value >= 0)
+          continue;
+        if (other_level <= highest_level)
+          continue;
+      } else if (other_value > 0) {
+        if (highest_value > 0 && other_level >= highest_level)
+          continue;
+      } else {
+        if (highest_value >= 0)
+          continue;
+      }
+
+      highest_position = j;
+      highest_literal = other;
+      highest_level = other_level;
+      highest_value = other_value;
+    }
+#ifndef CADICAL_NDEBUG
+    LOG ("highest position: %d highest level: %d highest value: %d",
+         highest_position, highest_level, highest_value);
+#endif
+
+    if (highest_position == i)
+      continue;
+    if (highest_position > i) {
+      std::swap (clause[i], clause[highest_position]);
+    }
+  }
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Reads out from the external propagator the lemma/proapgation reason
+// clause literal by literal. In case propagated_elit is 0, it is about an
+// external clause via 'cb_add_external_clause_lit'. Otherwise, it is about
+// learning the reason of 'propagated_elit' via 'cb_add_reason_clause_lit'.
+// The learned clause is simplified by the current root-level assignment
+// (i.e. root-level falsified literals are removed, root satisfied clauses
+// are skipped). Duplicate literals are removed, tauotologies are detected
+// and skipped. It always adds the original (un-simplified) external clause
+// to the proof as an input clause and
+// the simplified version of it (except exceptions below) as a derived
+// clause.
+//
+// In case the external clause, after simplifications, is satisfied, no
+// clause is constructed, and the function returns 0. In case the external
+// clause, after simplifications, is empty, no clause is constructed, unsat
+// is set true and the function returns 0. In case the external clause,
+// after simplifications, is unit, no clause is constructed,
+// 'Internal::clause' has the unit literal (without 0) and the function
+// returns 0.
+//
+// In every other cases a new clause is constructed and the pointer is in
+// newest_clause
+//
+void Internal::add_external_clause (int propagated_elit,
+                                    bool no_backtrack) {
+  CADICAL_assert (original.empty ());
+  int elit = 0;
+
+  if (propagated_elit) {
+    // Propagation reason clauses are by default assumed to be forgettable
+    // irredundant. In case they would be unforgettably important, the
+    // propagator can add them as an explicit unforgettable external clause
+    // or set 'are_reasons_forgettable' to false.
+    ext_clause_forgettable = external->propagator->are_reasons_forgettable;
+#ifndef CADICAL_NDEBUG
+    LOG ("add external reason of propagated lit: %d", propagated_elit);
+#endif
+    elit = external->propagator->cb_add_reason_clause_lit (propagated_elit);
+  } else
+    elit = external->propagator->cb_add_external_clause_lit ();
+
+  // we need to be build a new LRAT chain if we are already in the middle of
+  // the analysis (like during failed assumptions)
+  LOG (lrat_chain, "lrat chain before");
+  std::vector<int64_t> lrat_chain_ext = std::move (lrat_chain);
+  lrat_chain.clear ();
+  clause.clear ();
+
+  // Read out the external lemma into original and simplify it into clause
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (original.empty ());
+
+  CADICAL_assert (!force_no_backtrack);
+  CADICAL_assert (!from_propagator);
+  force_no_backtrack = no_backtrack;
+  from_propagator = true;
+  while (elit) {
+    CADICAL_assert (external->is_observed[abs (elit)]);
+    external->add (elit);
+    if (propagated_elit)
+      elit =
+          external->propagator->cb_add_reason_clause_lit (propagated_elit);
+    else
+      elit = external->propagator->cb_add_external_clause_lit ();
+  }
+  external->add (elit);
+  CADICAL_assert (original.empty ());
+  CADICAL_assert (clause.empty ());
+  force_no_backtrack = false;
+  from_propagator = false;
+  lrat_chain = std::move (lrat_chain_ext);
+  LOG (lrat_chain, "lrat chain after");
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Recursively calls 'learn_external_reason_clause' to explain every
+// backward reachable externally propagated literal starting from 'ilit'.
+//
+void Internal::explain_reason (int ilit, Clause *reason, int &open) {
+  if (!opts.exteagerreasons)
+    return;
+#ifndef CADICAL_NDEBUG
+  LOG (reason, "explain_reason of %d (open: %d)", ilit, open);
+#endif
+  CADICAL_assert (reason);
+  CADICAL_assert (reason != external_reason);
+  for (const auto &other : *reason) {
+    if (other == ilit)
+      continue;
+    Flags &f = flags (other);
+    if (f.seen)
+      continue;
+    Var &v = var (other);
+    if (!v.level)
+      continue;
+    CADICAL_assert (val (other) < 0);
+    CADICAL_assert (v.level <= level);
+    if (v.reason == external_reason) {
+      v.reason = learn_external_reason_clause (-other, 0, true);
+    }
+    if (v.level && v.reason) {
+      f.seen = true;
+      open++;
+    }
+  }
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// In case external propagation was used, the reason clauses of the relevant
+// propagations must be learned lazily before/during conflict analysis.
+// While conflict analysis needs to analyze only the current level, lazy
+// clause learning must check every clause on every level that is backward
+// reachable from the conflicting clause to guarantee that the assignment
+// levels of the variables are accurate. So this explanation round is
+// separated from the conflict analysis, thereby guranteeing that the flags
+// and datastructures can be properly used later.
+//
+// This function must be called before the conflict analysis, in order to
+// guarantee that every relevant reason clause is indeed learned already and
+// to be sure that the levels of assignments are set correctly.
+//
+// Later TODO: experiment with bounded explanation (explain only those
+// literals that are directly used during conflict analysis +
+// minimizing/shrinking). The assignment levels are then only
+// over-approximated.
+//
+void Internal::explain_external_propagations () {
+  CADICAL_assert (conflict);
+  CADICAL_assert (clause.empty ());
+
+  Clause *reason = conflict;
+  std::vector<int> seen_lits;
+  int open = 0; // Seen but not explained literal
+
+  explain_reason (0, reason, open); // marks conflict clause lits as seen
+  int i = trail.size ();            // Start at end-of-trail
+  while (i > 0) {
+    const int lit = trail[--i];
+    if (!flags (lit).seen)
+      continue;
+    seen_lits.push_back (lit);
+    Var &v = var (lit);
+    if (!v.level)
+      continue;
+    if (v.reason) {
+      open--;
+      explain_reason (lit, v.reason, open);
+    }
+    if (!open)
+      break;
+  }
+  CADICAL_assert (!open);
+
+  if (!opts.exteagerrecalc) {
+    for (auto lit : seen_lits) {
+      Flags &f = flags (lit);
+      f.seen = false;
+    }
+#ifndef CADICAL_NDEBUG
+    for (auto idx : vars) {
+      CADICAL_assert (!flags (idx).seen);
+    }
+#endif
+  }
+
+  // Traverse now in the opposite direction (from lower to higher levels)
+  // and calculate the actual assignment level for the seen assignments.
+  for (auto it = seen_lits.rbegin (); it != seen_lits.rend (); ++it) {
+    const int lit = *it;
+    Flags &f = flags (lit);
+    Var &v = var (lit);
+    if (v.reason) {
+      int real_level = 0;
+      for (const auto &other : *v.reason) {
+        if (other == lit)
+          continue;
+        int tmp = var (other).level;
+        if (tmp > real_level)
+          real_level = tmp;
+      }
+      if (v.level && !real_level) {
+        build_chain_for_units (lit, v.reason, 1);
+        learn_unit_clause (lit);
+        lrat_chain.clear ();
+        v.reason = 0;
+      }
+      CADICAL_assert (v.level >= real_level);
+      if (v.level > real_level) {
+        v.level = real_level;
+      }
+    }
+    f.seen = false;
+  }
+
+#if 0 // has been fuzzed extensively
+  for (auto idx : vars) {
+    CADICAL_assert (!flags (idx).seen);
+  }
+#endif
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Learns the reason clause of the propagation of ilit from the
+// external propagator via 'add_external_clause'.
+// In case of falsified propagation steps, if the propagated literal is
+// already fixed to the opposite value, externalize will not necessarily
+// give back the original elit (but an equivalent one). To avoid that, in
+// falsified propagation cases the propagated elit is added as a second
+// argument.
+//
+Clause *Internal::learn_external_reason_clause (int ilit,
+                                                int falsified_elit,
+                                                bool no_backtrack) {
+  CADICAL_assert (external->propagator);
+  // we cannot modify clause during analysis
+  auto clause_tmp = std::move (clause);
+
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (original.empty ());
+
+  stats.ext_prop.eprop_expl++;
+
+  int elit = 0;
+  if (!falsified_elit) {
+    CADICAL_assert (!fixed (ilit));
+    elit = externalize (ilit);
+  } else
+    elit = falsified_elit;
+
+  LOG ("ilit: %d, elit: %d", ilit, elit);
+  add_external_clause (elit, no_backtrack);
+
+#ifndef CADICAL_NDEBUG
+  if (!falsified_elit && newest_clause) {
+    // Check if external propagation is correct wrt to the topological order
+    // defined by the trail. In case it is a falsified external propagation
+    // step, the order does not matter, the reason simply supposed to be a
+    // falsified clause.
+    const int propagated_ilit = ilit;
+    for (auto const reason_ilit : *newest_clause) {
+      CADICAL_assert (var (reason_ilit).trail <= var (propagated_ilit).trail);
+    }
+  }
+#endif
+
+  clause = std::move (clause_tmp);
+  return newest_clause;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Helper function to be able to call learn_external_reason_clause when the
+// internal clause is already used in the caller side (for example during
+// proof checking). These calls are assumed to be without a falsified elit.
+// Dont use it in general instead of learn_external_reason_clause because it
+// does not support the corner cases where a literal remains in clause.
+//
+Clause *Internal::wrapped_learn_external_reason_clause (int ilit) {
+  Clause *res;
+  std::vector<int64_t> chain_tmp{std::move (lrat_chain)};
+  lrat_chain.clear ();
+  if (clause.empty ()) {
+    res = learn_external_reason_clause (ilit, 0, true);
+  } else {
+    std::vector<int> clause_tmp{std::move (clause)};
+    clause.clear ();
+    res = learn_external_reason_clause (ilit, 0, true);
+    // The learn_external_reason clause can leave a literal in clause when
+    // there is a falsified elit arg. Here it is not allowed to
+    // happen.
+    CADICAL_assert (clause.empty ());
+
+    clause = std::move (clause_tmp);
+    clause_tmp.clear ();
+  }
+  CADICAL_assert (lrat_chain.empty ());
+  lrat_chain = std::move (chain_tmp);
+  chain_tmp.clear ();
+  return res;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Checks if the new clause forces backtracking, new assignments or conflict
+// analysis
+//
+void Internal::handle_external_clause (Clause *res) {
+  if (from_propagator)
+    stats.ext_prop.elearned++;
+  // at level 0 we have to do nothing...
+  if (!level)
+    return;
+  if (!res) {
+    if (from_propagator)
+      stats.ext_prop.elearn_prop++;
+    // new unit clause. For now just backtrack.
+    CADICAL_assert (!force_no_backtrack);
+    CADICAL_assert (level);
+    // if (!opts.chrono) {
+    backtrack ();
+    // }
+    return;
+  }
+  if (from_propagator)
+    stats.ext_prop.elearned++;
+  CADICAL_assert (res->size >= 2);
+  const int pos0 = res->literals[0];
+  const int pos1 = res->literals[1];
+  if (force_no_backtrack) {
+    CADICAL_assert (val (pos1) < 0);
+    CADICAL_assert (val (pos0) >= 0);
+    return;
+    // TODO: maybe fix levels
+  }
+  const int l1 = var (pos1).level;
+  if (val (pos0) < 0) { // conflicting or propagating clause
+    CADICAL_assert (0 < l1 && l1 <= var (pos0).level);
+    if (!opts.chrono) {
+      backtrack (l1);
+    }
+    if (val (pos0) < 0) {
+      conflict = res;
+      if (!from_propagator) {
+        // its better to backtrack instead of analyze
+        backtrack (l1 - 1);
+        conflict = 0;
+        CADICAL_assert (!val (pos0) && !val (pos1));
+      }
+    } else {
+      search_assign_driving (pos0, res);
+    }
+    if (from_propagator)
+      stats.ext_prop.elearn_conf++;
+    return;
+  }
+  if (val (pos1) < 0 && !val (pos0)) { // propagating clause
+    if (!opts.chrono) {
+      backtrack (l1);
+    }
+    search_assign_driving (pos0, res);
+    if (from_propagator)
+      stats.ext_prop.elearn_conf++;
+    return;
+  }
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Asks the external propagator if the current solution is OK
+// by calling 'cb_check_found_model (model)'.
+//
+// The checked model is built up after everything is restored
+// from the reconstruction stack and every variable is reactivated
+// and so it is not just simply the trail (i.e. it can be expensive).
+//
+// If the external propagator approves the model, the function
+// returns true.
+//
+// If the propagator does not approve the model, the solver asks
+// the propagator to add an external clause.
+// This external clause, however, does NOT have to be falsified by
+// the current model. The possible cases and reactions are described
+// below in the function. The possible states after that function:
+// - A solution was found and accepted by the external propagator
+// - A conflicting clause was learned from the external propagator
+// - The empty clause was learned due to something new learned from
+// the external propagator.
+//
+// In case only new variables were introduced, but no new clauses were
+// added, the function will return without a conflict to the outer CDCL
+// loop, where the new (not yet satisfied) variables are recognized and
+// the search continues.
+bool Internal::external_check_solution () {
+  if (!external_prop)
+    return true;
+
+  bool trail_changed = true;
+  bool added_new_clauses = false;
+  while (trail_changed || added_new_clauses) {
+    notify_assignments ();
+    if (!satisfied ())
+      break;
+    trail_changed = false; // to be on the safe side
+    added_new_clauses = false;
+    LOG ("Final check by external propagator is invoked.");
+    stats.ext_prop.echeck_call++;
+    external->reset_extended ();
+    external->extend ();
+
+    std::vector<int> etrail;
+
+    // Here the variables must be filtered by external->is_observed,
+    // because fixed variables are internally not necessarily observed
+    // anymore.
+    for (int idx = 1; idx <= external->max_var; idx++) {
+      if (!external->is_observed[idx])
+        continue;
+      const int lit = external->ival (idx);
+      etrail.push_back (lit);
+#ifndef CADICAL_NDEBUG
+#ifdef LOGGING
+      bool p = external->vals[idx];
+      LOG ("evals[%d]: %d ival(%d): %d", idx, p, idx, lit);
+#endif
+#endif
+    }
+
+    bool is_consistent =
+        external->propagator->cb_check_found_model (etrail);
+    stats.ext_prop.ext_cb++;
+    if (is_consistent) {
+      LOG ("Found solution is approved by external propagator.");
+      return true;
+    }
+
+    bool has_external_clause = ask_external_clause ();
+
+    stats.ext_prop.ext_cb++;
+    stats.ext_prop.elearn_call++;
+
+    if (has_external_clause)
+      LOG (
+          "Found solution triggered new clauses from external propagator.");
+
+    while (has_external_clause) {
+      int level_before = level;
+      size_t assigned = num_assigned;
+      add_external_clause (0);
+      bool trail_changed =
+          (num_assigned != assigned || level != level_before ||
+           propagated < trail.size ());
+      added_new_clauses = true;
+      //
+      // There are many possible scenarios here:
+      // - Learned conflicting clause: return to CDCL loop (conflict true)
+      // - Learned conflicting unit clause that after backtrack+BCP leads to
+      //   a new complete solution: force the outer loop to check the new
+      //   model (trail_changed is true, but (conflict & unsat) is false)
+      // - Learned empty clause: return to CDCL loop (unsat true)
+      // - Learned a non-conflicting unit clause:
+      //   Though it does not invalidate the current solution, the solver
+      //   will backtrack to the root level and will repropagate it. The
+      //   search will start again (saved phases hopefully make it quick),
+      //   but it is needed in order to guarantee that every fixed variable
+      //   is properly handled+notified (important for incremental use
+      //   cases).
+      // - Otherwise: the solution is considered approved and the CDCL-loop
+      //   can return with res = 10.
+      //
+      if (unsat || conflict || trail_changed)
+        break;
+      has_external_clause = ask_external_clause ();
+      stats.ext_prop.ext_cb++;
+      stats.ext_prop.elearn_call++;
+    }
+    LOG ("No more external clause to add.");
+    if (unsat || conflict)
+      break;
+  }
+
+  if (!unsat && conflict) {
+    const int conflict_level = var (conflict->literals[0]).level;
+    if (conflict_level != level) {
+      backtrack (conflict_level);
+    }
+  }
+
+  return !conflict;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Notify the external propagator that an observed variable got assigned.
+//
+void Internal::notify_assignments () {
+  if (!external_prop || external_prop_is_lazy || private_steps)
+    return;
+
+  const size_t end_of_trail = trail.size ();
+
+  if (notified >= end_of_trail)
+    return;
+
+  LOG ("notify external propagator about new assignments");
+  std::vector<int> assigned;
+
+  while (notified < end_of_trail) {
+    int ilit = trail[notified++];
+    if (!observed (ilit))
+      continue;
+
+    int elit = externalize (ilit); // TODO: double-check tainting
+    CADICAL_assert (elit);
+    if (external->ervars[abs (elit)])
+      continue;
+    // Fixed variables might get mapped (during compact) to another
+    // non-observed but fixed variable.
+    // This happens on root level, so notification about their assignment is
+    // already done.
+    CADICAL_assert (external->observed (elit) ||
+            (fixed (ilit) && !external->ervars[abs (elit)]));
+    assigned.push_back (elit);
+  }
+
+  external->propagator->notify_assignment (assigned);
+  return;
+}
+
+/*----------------------------------------------------------------------------*/
+
+void Internal::connect_propagator () {
+  if (level)
+    backtrack ();
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Notify the external propagator that a new decision level is started.
+//
+void Internal::notify_decision () {
+  if (!external_prop || external_prop_is_lazy || private_steps)
+    return;
+  external->propagator->notify_new_decision_level ();
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Notify the external propagator that backtrack to new_level.
+//
+void Internal::notify_backtrack (size_t new_level) {
+  if (!external_prop || external_prop_is_lazy || private_steps)
+    return;
+  external->propagator->notify_backtrack (new_level);
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Ask the external propagator if there is a suggested literal as next
+// decision.
+//
+int Internal::ask_decision () {
+  if (!external_prop || external_prop_is_lazy || private_steps)
+    return 0;
+
+  CADICAL_assert (!unsat);
+  CADICAL_assert (!conflict);
+  notify_assignments ();
+  int level_before = level;
+  forced_backt_allowed = true;
+  int elit = external->propagator->cb_decide ();
+  forced_backt_allowed = false;
+  stats.ext_prop.ext_cb++;
+
+  if (level_before != level) {
+
+    propagate ();
+    CADICAL_assert (!unsat);
+    CADICAL_assert (!conflict);
+    notify_assignments ();
+
+    // In case the external propagator forced to backtrack below the
+    // pseduo decision levels, we must go back to the CDCL loop instead of
+    // making a decision.
+    if ((size_t) level < assumptions.size () ||
+        ((size_t) level == assumptions.size () && constraint.size ())) {
+      return 0;
+    }
+  }
+
+  if (!elit)
+    return 0;
+  LOG ("external propagator proposes decision: %d", elit);
+  CADICAL_assert (external->is_observed[abs (elit)]);
+  if (!external->is_observed[abs (elit)])
+    return 0;
+
+  int ilit = external->e2i[abs (elit)];
+  if (elit < 0)
+    ilit = -ilit;
+
+  CADICAL_assert (fixed (ilit) || observed (ilit));
+
+  LOG ("Asking external propagator for decision returned: %d (internal: "
+       "%d, fixed: %d, val: %d)",
+       elit, ilit, fixed (ilit), val (ilit));
+
+  if (fixed (ilit) || val (ilit)) {
+    LOG ("Proposed decision variable is already assigned, falling back to "
+         "internal decision.");
+    return 0;
+  }
+
+  return ilit;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Check if the clause is a forgettable clause coming from the external
+// propagator.
+//
+bool Internal::is_external_forgettable (int64_t id) {
+  CADICAL_assert (opts.check);
+  return (external->forgettable_original.find (id) !=
+          external->forgettable_original.end ());
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// When an external forgettable clause is deleted, it is marked in the
+// 'forgettable_original' hash, so that the internal model checking can
+// ignore it.
+//
+void Internal::mark_garbage_external_forgettable (int64_t id) {
+  CADICAL_assert (opts.check);
+  CADICAL_assert (is_external_forgettable (id));
+
+  LOG (external->forgettable_original[id],
+       "forgettable external lemma is deleted:");
+  // Mark as removed by flipping the first flag to false.
+  external->forgettable_original[id][0] = 0;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Check that the literals in the clause are properly ordered. Used only
+// internally for debug purposes.
+//
+void Internal::check_watched_literal_invariants () {
+#ifndef CADICAL_NDEBUG
+  int v0 = 0;
+  int v1 = 0;
+
+  if (val (clause[0]) > 0)
+    v0 = 1;
+  else if (val (clause[0]) < 0)
+    v0 = -1;
+
+  if (val (clause[1]) > 0)
+    v1 = 1;
+  else if (val (clause[1]) < 0)
+    v1 = -1;
+  CADICAL_assert (v0 >= v1);
+#endif
+  if (val (clause[0]) > 0) {
+    if (val (clause[1]) > 0) { // Case 1: Both literals are satisfied
+      // They are ordered by lower to higher decision level
+      CADICAL_assert (var (clause[0]).level <= var (clause[1]).level);
+
+      // Every other literal of the clause is either
+      //    - satisfied at higher level
+      //    - unassigned
+      //    - falsified
+      for (size_t i = 2; i < clause.size (); i++)
+        CADICAL_assert (val (clause[i]) <= 0 ||
+                (var (clause[1]).level <= var (clause[i]).level));
+
+    } else if (val (clause[1]) ==
+               0) { // Case 2: First satisfied, next unassigned
+
+      // Every other literal of the clause is either
+      //    - unassigned
+      //    - falsified
+      for (size_t i = 2; i < clause.size (); i++)
+        CADICAL_assert (val (clause[i]) <= 0);
+
+    } else { // Case 3: First satisfied, next falsified -> could have been a
+             // reason of a previous propagation
+      // Every other literal of the clause is falsified but at a lower
+      // decision level
+      for (size_t i = 2; i < clause.size (); i++)
+        CADICAL_assert (val (clause[i]) < 0 &&
+                (var (clause[1]).level >= var (clause[i]).level));
+    }
+  } else if (val (clause[0]) == 0) {
+    if (val (clause[1]) == 0) { // Case 4: Both literals are unassigned
+
+      // Every other literal of the clause is either
+      //    - unassigned
+      //    - falsified
+      for (size_t i = 2; i < clause.size (); i++)
+        CADICAL_assert (val (clause[i]) <= 0);
+
+    } else { // Case 5: First unassigned, next falsified -> PROPAGATE
+      // Every other literal of the clause is falsified but at a lower
+      // decision level
+      for (size_t i = 2; i < clause.size (); i++)
+        CADICAL_assert (val (clause[i]) < 0 &&
+                (var (clause[1]).level >= var (clause[i]).level));
+    }
+  } else {
+    CADICAL_assert (val (clause[0]) < 0 &&
+            val (clause[1]) < 0); // Case 6: Both literals are falsified
+
+    // They are ordered by higher to lower decision level
+    CADICAL_assert (var (clause[0]).level >= var (clause[1]).level);
+
+    // Every other literal of the clause is falsified, but at a lower level
+    for (size_t i = 2; i < clause.size (); i++)
+      CADICAL_assert (val (clause[i]) < 0 &&
+              (var (clause[1]).level >= var (clause[i]).level));
+  }
+}
+
+#ifndef CADICAL_NDEBUG
+
+/*----------------------------------------------------------------------------*/
+//
+// An expensive function that can be used for deep-debug trail-related
+// issues in mobical. Do not use it unless it is really unavoidable.
+//
+// eq_class contains all the merged external literals that are currently
+// compacted to the internal literal of trail[0] and return true.
+//
+// In case trail[0] does not exists or is not on the root level, the
+// function returns false (indicating that there was no merger literal
+// found).
+//
+bool Internal::get_merged_literals (std::vector<int> &eq_class) {
+  eq_class.clear ();
+
+  if (!trail.size ())
+    return false;
+
+  int ilit = trail[0];
+  size_t lit_level = var (ilit).level;
+
+  if (!lit_level) {
+    // Collect all the variables that are merged and mapped to that ilit
+    size_t e2i_size = external->e2i.size ();
+    int ivar = abs (ilit);
+    for (size_t i = 0; i < e2i_size; i++) {
+      int other = abs (external->e2i[i]);
+      if (other == ivar) {
+        if (external->e2i[i] == ilit)
+          eq_class.push_back (i);
+        else
+          eq_class.push_back (-1 * i);
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+/*----------------------------------------------------------------------------*/
+//
+// Collect all external variables that are FIXED internally. Again an
+// expensive function that should be called only for debugging in mobical.
+//
+// Do not use it unless it is really unavoidable.
+//
+void Internal::get_all_fixed_literals (std::vector<int> &fixed_lits) {
+  fixed_lits.clear ();
+  if (!trail.size ())
+    return;
+
+  int e2i_size = external->e2i.size ();
+  int ilit;
+  for (int eidx = 1; eidx < e2i_size; eidx++) {
+    ilit = external->e2i[eidx];
+    if (ilit && !external->ervars[eidx]) {
+      Flags &f = flags (ilit);
+      if (f.status == Flags::FIXED) {
+        fixed_lits.push_back (vals[abs (ilit)] * eidx);
+      }
+    }
+  }
+}
+#endif
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_factor.cpp b/src/sat/cadical/cadical_factor.cpp
new file mode 100644
index 000000000..3fee40685
--- /dev/null
+++ b/src/sat/cadical/cadical_factor.cpp
@@ -0,0 +1,927 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+#define FACTORS 1
+#define QUOTIENT 2
+#define NOUNTED 4
+
+inline bool factor_occs_size::operator() (unsigned a, unsigned b) {
+  size_t s = internal->occs (internal->u2i (a)).size ();
+  size_t t = internal->occs (internal->u2i (b)).size ();
+  if (s > t)
+    return true;
+  if (s < t)
+    return false;
+  return a > b;
+}
+
+// do full occurence list as in elim.cpp but filter out useless clauses
+void Internal::factor_mode () {
+  reset_watches ();
+
+  CADICAL_assert (!watching ());
+  init_occs ();
+
+  const int size_limit = opts.factorsize;
+
+  vector<unsigned> bincount, largecount;
+  const unsigned max_lit = 2 * (max_var + 1);
+  enlarge_zero (bincount, max_lit);
+  if (size_limit > 2)
+    enlarge_zero (largecount, max_lit);
+
+  vector<Clause *> candidates;
+  int64_t &ticks = stats.ticks.factor;
+  ticks += 1 + cache_lines (clauses.size (), sizeof (Clause *));
+
+  // push binary clauses on the occurrence stack.
+  for (const auto &c : clauses) {
+    ticks++;
+    if (c->garbage)
+      continue;
+    if (c->redundant && c->size > 2)
+      continue;
+    if (c->size > size_limit)
+      continue;
+    if (c->size == 2) {
+      const int lit = c->literals[0];
+      const int other = c->literals[1];
+      bincount[vlit (lit)]++;
+      bincount[vlit (other)]++;
+      occs (lit).push_back (c);
+      occs (other).push_back (c);
+      continue;
+    }
+    candidates.push_back (c);
+    for (const auto &lit : *c) {
+      largecount[vlit (lit)]++;
+    }
+  }
+  if (size_limit == 2)
+    return;
+
+  // iterate counts of larger clauses rounds often
+  const unsigned rounds = opts.factorcandrounds;
+  unsigned candidates_before = 0;
+  for (unsigned round = 1; round <= rounds; round++) {
+    LOG ("factor round %d", round);
+    if (candidates.size () == candidates_before)
+      break;
+    ticks += 1 + cache_lines (candidates.size (), sizeof (Clause *));
+    candidates_before = candidates.size ();
+    vector<unsigned> newlargecount;
+    enlarge_zero (newlargecount, max_lit);
+    const auto begin = candidates.begin ();
+    auto p = candidates.begin ();
+    auto q = p;
+    const auto end = candidates.end ();
+    while (p != end) {
+      Clause *c = *q++ = *p++;
+      ticks++;
+      for (const auto &lit : *c) {
+        const auto idx = vlit (lit);
+        if (bincount[idx] + largecount[idx] < 2) {
+          q--;
+          goto CONTINUE_WITH_NEXT_CLAUSE;
+        }
+      }
+      for (const auto &lit : *c) {
+        const auto idx = vlit (lit);
+        newlargecount[idx]++;
+      }
+    CONTINUE_WITH_NEXT_CLAUSE:
+      continue;
+    }
+    candidates.resize (q - begin);
+    largecount.swap (newlargecount);
+  }
+
+  // finally push remaining clause on the occurrence stack
+  for (const auto &c : candidates)
+    for (const auto &lit : *c)
+      occs (lit).push_back (c);
+}
+
+// go back to two watch scheme
+void Internal::reset_factor_mode () {
+  reset_occs ();
+  init_watches ();
+  connect_watches ();
+}
+
+Factoring::Factoring (Internal *i, int64_t l)
+    : internal (i), limit (l), schedule (i) {
+  const unsigned max_var = internal->max_var;
+  const unsigned max_lit = 2 * (max_var + 1);
+  initial = max_var;
+  bound = internal->lim.elimbound;
+  enlarge_zero (count, max_lit);
+  quotients.first = quotients.last = 0;
+}
+
+Factoring::~Factoring () {
+  CADICAL_assert (counted.empty ());
+  CADICAL_assert (nounted.empty ());
+  CADICAL_assert (flauses.empty ());
+  internal->release_quotients (*this);
+  schedule.erase (); // actually not necessary
+}
+
+double Internal::tied_next_factor_score (int lit) {
+  double res = occs (lit).size ();
+  LOG ("watches score %g of %d", res, lit);
+  return res;
+}
+
+// the marks in cadical have 6 bits for marking but work on idx
+// to mark everything (FACTORS, QUOTIENT, NOUNTED) we shift the bits
+// depending on the sign of factor (+ bitmask)
+// i.e. if factor is positive, we apply a bitmask to only get
+// the first three bits (& 7u)
+// otherwise we leftshift by 3 (>> 3) to get the bits 4,5,6
+// use markfact, unmarkfact, getfact for this purpose.
+//
+Quotient *Internal::new_quotient (Factoring &factoring, int factor) {
+  CADICAL_assert (!getfact (factor, FACTORS));
+  markfact (factor, FACTORS);
+  Quotient *res = new Quotient (factor);
+  res->next = 0;
+  res->matched = 0;
+  Quotient *last = factoring.quotients.last;
+  res->bid = 0;
+  if (last) {
+    CADICAL_assert (factoring.quotients.first);
+    CADICAL_assert (!last->next);
+    last->next = res;
+    res->id = last->id + 1;
+  } else {
+    CADICAL_assert (!factoring.quotients.first);
+    factoring.quotients.first = res;
+    res->id = 0;
+  }
+  factoring.quotients.last = res;
+  res->prev = last;
+  LOG ("new quotient[%zu] with factor %d", res->id, factor);
+  return res;
+}
+
+void Internal::release_quotients (Factoring &factoring) {
+  for (Quotient *q = factoring.quotients.first, *next; q; q = next) {
+    next = q->next;
+    int factor = q->factor;
+    CADICAL_assert (getfact (factor, FACTORS));
+    unmarkfact (factor, FACTORS);
+    delete q;
+  }
+  factoring.quotients.first = factoring.quotients.last = 0;
+}
+
+size_t Internal::first_factor (Factoring &factoring, int factor) {
+  CADICAL_assert (!factoring.quotients.first);
+  Quotient *quotient = new_quotient (factoring, factor);
+  vector<Clause *> &qlauses = quotient->qlauses;
+  int64_t ticks = 0;
+  for (const auto &c : occs (factor)) {
+    qlauses.push_back (c);
+    ticks++;
+  }
+  size_t res = qlauses.size ();
+  LOG ("quotient[0] factor %d size %zu", factor, res);
+  // This invariant can of course be broken by previous factorings
+  // CADICAL_assert (res > 1);
+  stats.ticks.factor += ticks;
+  return res;
+}
+
+void Internal::clear_nounted (vector<int> &nounted) {
+  for (const auto &lit : nounted) {
+    CADICAL_assert (getfact (lit, NOUNTED));
+    unmarkfact (lit, NOUNTED);
+  }
+  nounted.clear ();
+}
+
+void Internal::clear_flauses (vector<Clause *> &flauses) {
+  for (auto c : flauses) {
+    CADICAL_assert (c->swept);
+    c->swept = false;
+  }
+  flauses.clear ();
+}
+
+Quotient *Internal::best_quotient (Factoring &factoring,
+                                   size_t *best_reduction_ptr) {
+  size_t factors = 1, best_reduction = 0;
+  Quotient *best = 0;
+  for (Quotient *q = factoring.quotients.first; q; q = q->next) {
+    size_t quotients = q->qlauses.size ();
+    size_t before_factorization = quotients * factors;
+    size_t after_factorization = quotients + factors;
+    if (before_factorization == after_factorization)
+      LOG ("quotient[%zu] factors %zu clauses into %zu thus no change",
+           factors - 1, before_factorization, after_factorization);
+    else if (before_factorization < after_factorization)
+      LOG ("quotient[%zu] factors %zu clauses into %zu thus %zu more",
+           factors - 1, before_factorization, after_factorization,
+           after_factorization - before_factorization);
+    else {
+      size_t delta = before_factorization - after_factorization;
+      LOG ("quotient[%zu] factors %zu clauses into %zu thus %zu less",
+           factors - 1, before_factorization, after_factorization, delta);
+      if (!best || best_reduction < delta) {
+        best_reduction = delta;
+        best = q;
+      }
+    }
+    factors++;
+  }
+  if (!best) {
+    LOG ("no decreasing quotient found");
+    return 0;
+  }
+  LOG ("best decreasing quotient[%zu] with reduction %zu", best->id,
+       best_reduction);
+  *best_reduction_ptr = best_reduction;
+  return best;
+}
+
+int Internal::next_factor (Factoring &factoring, unsigned *next_count_ptr) {
+  Quotient *last_quotient = factoring.quotients.last;
+  CADICAL_assert (last_quotient);
+  vector<Clause *> &last_clauses = last_quotient->qlauses;
+  vector<unsigned> &count = factoring.count;
+  vector<int> &counted = factoring.counted;
+  vector<Clause *> &flauses = factoring.flauses;
+  CADICAL_assert (counted.empty ());
+  CADICAL_assert (flauses.empty ());
+  const int initial = factoring.initial;
+  int64_t ticks = 1 + cache_lines (last_clauses.size (), sizeof (Clause *));
+  for (auto c : last_clauses) {
+    CADICAL_assert (!c->swept);
+    int min_lit = 0;
+    unsigned factors = 0;
+    size_t min_size = 0;
+    ticks++;
+    for (const auto &other : *c) {
+      if (getfact (other, FACTORS)) {
+        if (factors++)
+          break;
+      } else {
+        CADICAL_assert (!getfact (other, QUOTIENT));
+        markfact (other, QUOTIENT);
+        const size_t other_size = occs (other).size ();
+        if (!min_lit || other_size < min_size) {
+          min_lit = other;
+          min_size = other_size;
+        }
+      }
+    }
+    CADICAL_assert (factors);
+    if (factors == 1) {
+      CADICAL_assert (min_lit);
+      const int c_size = c->size;
+      vector<int> &nounted = factoring.nounted;
+      CADICAL_assert (nounted.empty ());
+      ticks += 1 + cache_lines (occs (min_lit).size (), sizeof (Clause *));
+      for (auto d : occs (min_lit)) {
+        if (c == d)
+          continue;
+        ticks++;
+        if (d->swept)
+          continue;
+        if (d->size != c_size)
+          continue;
+        int next = 0;
+        for (const auto &other : *d) {
+          if (getfact (other, QUOTIENT))
+            continue;
+          if (getfact (other, FACTORS))
+            goto CONTINUE_WITH_NEXT_MIN_WATCH;
+          if (getfact (other, NOUNTED))
+            goto CONTINUE_WITH_NEXT_MIN_WATCH;
+          if (next)
+            goto CONTINUE_WITH_NEXT_MIN_WATCH;
+          next = other;
+        }
+        CADICAL_assert (next);
+        if (abs (next) > abs (initial))
+          continue;
+        if (!active (next))
+          continue;
+        CADICAL_assert (!getfact (next, FACTORS));
+        CADICAL_assert (!getfact (next, NOUNTED));
+        markfact (next, NOUNTED);
+        nounted.push_back (next);
+        d->swept = true;
+        flauses.push_back (d);
+        if (!count[vlit (next)])
+          counted.push_back (next);
+        count[vlit (next)]++;
+      CONTINUE_WITH_NEXT_MIN_WATCH:;
+      }
+      clear_nounted (nounted);
+    }
+    for (const auto &other : *c)
+      if (getfact (other, QUOTIENT))
+        unmarkfact (other, QUOTIENT);
+    stats.ticks.factor += ticks;
+    ticks = 0;
+    if (stats.ticks.factor > factoring.limit)
+      break;
+  }
+  clear_flauses (flauses);
+  unsigned next_count = 0;
+  int next = 0;
+  if (stats.ticks.factor <= factoring.limit) {
+    unsigned ties = 0;
+    for (const auto &lit : counted) {
+      const unsigned lit_count = count[vlit (lit)];
+      if (lit_count < next_count)
+        continue;
+      if (lit_count == next_count) {
+        CADICAL_assert (lit_count);
+        ties++;
+      } else {
+        CADICAL_assert (lit_count > next_count);
+        next_count = lit_count;
+        next = lit;
+        ties = 1;
+      }
+    }
+    if (next_count < 2) {
+      LOG ("next factor count %u smaller than 2", next_count);
+      next = 0;
+    } else if (ties > 1) {
+      LOG ("found %u tied next factor candidate literals with count %u",
+           ties, next_count);
+      double next_score = -1;
+      for (const auto &lit : counted) {
+        const unsigned lit_count = count[vlit (lit)];
+        if (lit_count != next_count)
+          continue;
+        double lit_score = tied_next_factor_score (lit);
+        CADICAL_assert (lit_score >= 0);
+        LOG ("score %g of next factor candidate %d", lit_score, lit);
+        if (lit_score <= next_score)
+          continue;
+        next_score = lit_score;
+        next = lit;
+      }
+      CADICAL_assert (next_score >= 0);
+      CADICAL_assert (next);
+      LOG ("best score %g of next factor %d", next_score, next);
+    } else {
+      CADICAL_assert (ties == 1);
+      LOG ("single next factor %d with count %u", next, next_count);
+    }
+  }
+  for (const auto &lit : counted)
+    count[vlit (lit)] = 0;
+  counted.clear ();
+  CADICAL_assert (!next || next_count > 1);
+  *next_count_ptr = next_count;
+  return next;
+}
+
+void Internal::factorize_next (Factoring &factoring, int next,
+                               unsigned expected_next_count) {
+  Quotient *last_quotient = factoring.quotients.last;
+  Quotient *next_quotient = new_quotient (factoring, next);
+
+  CADICAL_assert (last_quotient);
+  vector<Clause *> &last_clauses = last_quotient->qlauses;
+  vector<Clause *> &next_clauses = next_quotient->qlauses;
+  vector<size_t> &matches = next_quotient->matches;
+  vector<Clause *> &flauses = factoring.flauses;
+  CADICAL_assert (flauses.empty ());
+
+  int64_t ticks = 1 + cache_lines (last_clauses.size (), sizeof (Clause *));
+
+  size_t i = 0;
+
+  for (auto c : last_clauses) {
+    CADICAL_assert (!c->swept);
+    int min_lit = 0;
+    unsigned factors = 0;
+    size_t min_size = 0;
+    ticks++;
+    for (const auto &other : *c) {
+      if (getfact (other, FACTORS)) {
+        if (factors++)
+          break;
+      } else {
+        CADICAL_assert (!getfact (other, QUOTIENT));
+        markfact (other, QUOTIENT);
+        const size_t other_size = occs (other).size ();
+        if (!min_lit || other_size < min_size) {
+          min_lit = other;
+          min_size = other_size;
+        }
+      }
+    }
+    CADICAL_assert (factors);
+    if (factors == 1) {
+      CADICAL_assert (min_lit);
+      const int c_size = c->size;
+      ticks += 1 + cache_lines (occs (min_lit).size (), sizeof (Clause *));
+      for (auto d : occs (min_lit)) {
+        if (c == d)
+          continue;
+        ticks++;
+        if (d->swept)
+          continue;
+        if (d->size != c_size)
+          continue;
+        for (const auto &other : *d) {
+          if (getfact (other, QUOTIENT))
+            continue;
+          if (other != next)
+            goto CONTINUE_WITH_NEXT_MIN_WATCH;
+        }
+        LOG (c, "matched");
+        LOG (d, "keeping");
+
+        next_clauses.push_back (d);
+        matches.push_back (i);
+        flauses.push_back (d);
+        d->swept = true;
+        break;
+
+      CONTINUE_WITH_NEXT_MIN_WATCH:;
+      }
+    }
+    for (const auto &other : *c)
+      if (getfact (other, QUOTIENT))
+        unmarkfact (other, QUOTIENT);
+    i++;
+  }
+  clear_flauses (flauses);
+  stats.ticks.factor += ticks;
+
+  CADICAL_assert (expected_next_count <= next_clauses.size ());
+  (void) expected_next_count;
+}
+
+// We only need to enlarge factoring.count as everything else is
+// initialized in internal
+void Internal::resize_factoring (Factoring &factoring, int lit) {
+  CADICAL_assert (lit > 0);
+  size_t new_var_size = lit + 1;
+  size_t new_lit_size = 2 * new_var_size;
+  enlarge_zero (factoring.count, new_lit_size);
+}
+
+void Internal::flush_unmatched_clauses (Quotient *q) {
+  Quotient *prev = q->prev;
+  vector<size_t> &q_matches = q->matches, &prev_matches = prev->matches;
+  vector<Clause *> &q_clauses = q->qlauses, &prev_clauses = prev->qlauses;
+  const size_t n = q_clauses.size ();
+  CADICAL_assert (n == q_matches.size ());
+  bool prev_is_first = !prev->id;
+  size_t i = 0;
+  while (i < q_matches.size ()) {
+    size_t j = q_matches[i];
+    q_matches[i] = i;
+    CADICAL_assert (i <= j);
+    if (!prev_is_first) {
+      size_t matches = prev_matches[j];
+      prev_matches[i] = matches;
+    }
+    Clause *c = prev_clauses[j];
+    prev_clauses[i] = c;
+    i++;
+  }
+  LOG ("flushing %zu clauses of quotient[%zu]", prev_clauses.size () - n,
+       prev->id);
+  if (!prev_is_first)
+    prev_matches.resize (n);
+  prev_clauses.resize (n);
+}
+
+// special case when we have two quotients with negated factors.
+// in this case, factoring does not make sense, and instead we
+// can resolve the clauses of the two quotients.
+// this subsumes all clauses in all quotients.
+void Internal::add_self_subsuming_factor (Quotient *q, Quotient *p) {
+  const int factor = q->factor;
+  const int not_factor = p->factor;
+  CADICAL_assert (-factor == not_factor);
+  LOG (
+      "adding self subsuming factor because blocked clause is a tautology");
+  for (auto c : q->qlauses) {
+    for (const auto &lit : *c) {
+      if (lit == factor)
+        continue;
+      clause.push_back (lit);
+    }
+    if (lrat) {
+      for (auto d : p->qlauses) {
+        bool match = true;
+        for (const auto &lit : *d) {
+          if (lit == not_factor)
+            continue;
+          if (std::find (clause.begin (), clause.end (), lit) ==
+              clause.end ()) {
+            match = false;
+            break;
+          }
+        }
+        if (match) {
+          lrat_chain.push_back (d->id);
+          break;
+        }
+      }
+      lrat_chain.push_back (c->id);
+      CADICAL_assert (lrat_chain.size () == 2);
+    }
+    if (clause.size () > 1) {
+      new_factor_clause ();
+    } else {
+      const int unit = clause[0];
+      const signed char tmp = val (unit);
+      if (!tmp)
+        assign_unit (unit);
+      else if (tmp < 0) {
+        if (lrat) {
+          int64_t id = unit_id (-unit);
+          lrat_chain.push_back (id);
+          std::reverse (lrat_chain.begin (), lrat_chain.end ());
+        }
+        learn_empty_clause ();
+        clause.clear ();
+        lrat_chain.clear ();
+        break;
+      }
+    }
+    clause.clear ();
+    lrat_chain.clear ();
+  }
+}
+
+bool Internal::self_subsuming_factor (Quotient *q) {
+  Quotient *x = 0, *y = 0;
+  bool found = false;
+  for (Quotient *p = q; p; p = p->prev) {
+    const int factor = p->factor;
+    Flags &f = flags (factor);
+    if (f.seen) {
+      CADICAL_assert (std::find (analyzed.begin (), analyzed.end (), -factor) !=
+              analyzed.end ());
+      found = true;
+      x = p;
+      for (Quotient *r = q; r; r = r->prev) {
+        if (r->factor != -factor)
+          continue;
+        y = r;
+        break;
+      }
+      break;
+    }
+    analyzed.push_back (factor);
+    f.seen = true;
+  }
+  CADICAL_assert (!found || (x && y));
+  clear_analyzed_literals ();
+  if (found) {
+    add_self_subsuming_factor (x, y);
+    return true;
+  }
+  return false;
+}
+
+// this is a pure binary clauses containing fresh and one other literal
+// it is added for all applicable quotients.
+void Internal::add_factored_divider (Quotient *q, int fresh) {
+  const int factor = q->factor;
+  LOG ("factored %d divider %d", factor, fresh);
+  clause.push_back (factor);
+  clause.push_back (fresh);
+  new_factor_clause ();
+  clause.clear ();
+  if (lrat)
+    mini_chain.push_back (-clause_id);
+}
+
+// this clause is blocked on fresh, i.e., it contains all literals from
+// the binaries above, but negated. This is only added to the proof, to
+// make checking easier.
+void Internal::blocked_clause (Quotient *q, int not_fresh) {
+  if (!proof)
+    return;
+  int64_t new_id = ++clause_id;
+  q->bid = new_id;
+  CADICAL_assert (clause.empty ());
+  for (Quotient *p = q; p; p = p->prev)
+    clause.push_back (-p->factor);
+  clause.push_back (not_fresh);
+  CADICAL_assert (!lrat || mini_chain.size ());
+  proof->add_derived_clause (new_id, true, clause, mini_chain);
+  mini_chain.clear ();
+  clause.clear ();
+}
+
+// this is the other side of the factored clauses. To derive these,
+// one can resolved the blocked clause on all matching clauses of
+// one type
+void Internal::add_factored_quotient (Quotient *q, int not_fresh) {
+  LOG ("adding factored quotient[%zu] clauses", q->id);
+  const int factor = q->factor;
+  CADICAL_assert (lrat_chain.empty ());
+  auto qlauses = q->qlauses;
+  for (unsigned idx = 0; idx < qlauses.size (); idx++) {
+    const auto c = qlauses[idx];
+    CADICAL_assert (clause.empty ());
+    for (const auto &other : *c) {
+      if (other == factor) {
+        continue;
+      }
+      clause.push_back (other);
+    }
+    if (lrat) {
+      CADICAL_assert (proof);
+      CADICAL_assert (q->bid);
+      unsigned idxtoo = idx;
+      for (Quotient *p = q; p; p = p->prev) {
+        lrat_chain.push_back (p->qlauses[idxtoo]->id);
+        if (p->prev)
+          idxtoo = p->matches[idx];
+      }
+      lrat_chain.push_back (q->bid);
+    }
+    clause.push_back (not_fresh);
+    new_factor_clause ();
+    clause.clear ();
+    lrat_chain.clear ();
+  }
+  if (proof) {
+    for (Quotient *p = q; p; p = p->prev) {
+      clause.push_back (-p->factor);
+    }
+    clause.push_back (not_fresh);
+    proof->delete_clause (q->bid, true, clause);
+    clause.clear ();
+  }
+}
+
+// remove deleted clauses once factored.
+void Internal::eagerly_remove_from_occurences (Clause *c) {
+  for (const auto &lit : *c) {
+    auto &occ = occs (lit);
+    auto p = occ.begin ();
+    auto q = occ.begin ();
+    auto begin = occ.begin ();
+    auto end = occ.end ();
+    while (p != end) {
+      *q = *p++;
+      if (*q != c)
+        q++;
+    }
+    CADICAL_assert (q + 1 == p);
+    occ.resize (q - begin);
+  }
+}
+
+// delete the factored clauses
+void Internal::delete_unfactored (Quotient *q) {
+  LOG ("deleting unfactored quotient[%zu] clauses", q->id);
+  for (auto c : q->qlauses) {
+    eagerly_remove_from_occurences (c);
+    mark_garbage (c);
+    stats.literals_unfactored += c->size;
+    stats.clauses_unfactored++;
+  }
+}
+
+// update the priority queue for scheduling
+void Internal::update_factored (Factoring &factoring, Quotient *q) {
+  const int factor = q->factor;
+  update_factor_candidate (factoring, factor);
+  update_factor_candidate (factoring, -factor);
+  for (auto c : q->qlauses) {
+    LOG (c, "deleting unfactored");
+    for (const auto &lit : *c)
+      if (lit != factor)
+        update_factor_candidate (factoring, lit);
+  }
+}
+
+bool Internal::apply_factoring (Factoring &factoring, Quotient *q) {
+  for (Quotient *p = q; p->prev; p = p->prev)
+    flush_unmatched_clauses (p);
+  if (self_subsuming_factor (q)) {
+    for (Quotient *p = q; p; p = p->prev)
+      delete_unfactored (p);
+    for (Quotient *p = q; p; p = p->prev)
+      update_factored (factoring, p);
+    return true;
+  }
+  const int fresh = get_new_extension_variable ();
+  if (!fresh)
+    return false;
+  stats.factored++;
+  factoring.fresh.push_back (fresh);
+  for (Quotient *p = q; p; p = p->prev)
+    add_factored_divider (p, fresh);
+  const int not_fresh = -fresh;
+  blocked_clause (q, not_fresh);
+  add_factored_quotient (q, not_fresh);
+  for (Quotient *p = q; p; p = p->prev)
+    delete_unfactored (p);
+  for (Quotient *p = q; p; p = p->prev)
+    update_factored (factoring, p);
+  CADICAL_assert (fresh > 0);
+  resize_factoring (factoring, fresh);
+  return true;
+}
+
+void Internal::update_factor_candidate (Factoring &factoring, int lit) {
+  FactorSchedule &schedule = factoring.schedule;
+  const size_t size = occs (lit).size ();
+  const unsigned idx = vlit (lit);
+  if (schedule.contains (idx))
+    schedule.update (idx);
+  else if (size > 1) {
+    schedule.push_back (idx);
+  }
+}
+
+void Internal::schedule_factorization (Factoring &factoring) {
+  for (const auto &idx : vars) {
+    if (active (idx)) {
+      Flags &f = flags (idx);
+      const int lit = idx;
+      const int not_lit = -lit;
+      if (f.factor & 1)
+        update_factor_candidate (factoring, lit);
+      if (f.factor & 2)
+        update_factor_candidate (factoring, not_lit);
+    }
+  }
+#ifndef CADICAL_QUIET
+  size_t size_cands = factoring.schedule.size ();
+  VERBOSE (2, "scheduled %zu factorization candidate literals %.0f %%",
+           size_cands, percent (size_cands, max_var));
+#endif
+}
+
+bool Internal::run_factorization (int64_t limit) {
+  Factoring factoring = Factoring (this, limit);
+  schedule_factorization (factoring);
+  bool done = false;
+#ifndef CADICAL_QUIET
+  unsigned factored = 0;
+#endif
+  int64_t *ticks = &stats.ticks.factor;
+  VERBOSE (3, "factorization limit of %" PRIu64 " ticks", limit - *ticks);
+
+  while (!unsat && !done && !factoring.schedule.empty ()) {
+    const unsigned ufirst = factoring.schedule.pop_front ();
+    LOG ("next factor candidate %d", ufirst);
+    const int first = u2i (ufirst);
+    const int first_idx = vidx (first);
+    if (!active (first_idx))
+      continue;
+    if (!occs (first).size ()) {
+      factoring.schedule.clear ();
+      break;
+    }
+    if (*ticks > limit) {
+      VERBOSE (2, "factorization ticks limit hit");
+      break;
+    }
+    if (terminated_asynchronously ())
+      break;
+    Flags &f = flags (first_idx);
+    const unsigned bit = 1u << (first < 0);
+    if (!(f.factor & bit))
+      continue;
+    f.factor &= ~bit;
+    const size_t first_count = first_factor (factoring, first);
+    if (first_count > 1) {
+      for (;;) {
+        unsigned next_count;
+        const int next = next_factor (factoring, &next_count);
+        if (next == 0)
+          break;
+        CADICAL_assert (next_count > 1);
+        if (next_count < 2)
+          break;
+        factorize_next (factoring, next, next_count);
+      }
+      size_t reduction;
+      Quotient *q = best_quotient (factoring, &reduction);
+      if (q && (int) reduction > factoring.bound) {
+        if (apply_factoring (factoring, q)) {
+#ifndef CADICAL_QUIET
+          factored++;
+#endif
+        } else
+          done = true;
+      }
+    }
+    release_quotients (factoring);
+  }
+
+  // since we cannot remove elements from the heap we check wether the
+  // first element in the heap has occurences
+  bool completed = factoring.schedule.empty ();
+  if (!completed) {
+    const unsigned idx = factoring.schedule.front ();
+    completed = occs (u2i (idx)).empty ();
+  }
+  // kissat initializes scores for new variables at this point, however
+  // this is actually done already during resize of internal
+#ifndef CADICAL_QUIET
+  report ('f', !factored);
+#endif
+  return completed;
+}
+
+int Internal::get_new_extension_variable () {
+  const int current_max_external = external->max_var;
+  const int new_external = current_max_external + 1;
+  const int new_internal = external->internalize (new_external, true);
+  // one sideeffect of internalize is enlarging the internal datastructures
+  // which can initialize the watches (wtab)
+  if (watching ())
+    reset_watches ();
+  // it does not enlarge otab, however, so we do this manually
+  init_occs ();
+  CADICAL_assert (vlit (new_internal));
+  return new_internal;
+}
+
+bool Internal::factor () {
+  if (unsat)
+    return false;
+  if (terminated_asynchronously ())
+    return false;
+  if (!opts.factor)
+    return false;
+  // The following CADICAL_assertion fails if there are *only* user propagator
+  // clauses (which are redundant).
+  // CADICAL_assert (stats.mark.factor || clauses.empty ());
+  if (last.factor.marked >= stats.mark.factor) {
+    VERBOSE (3,
+             "factorization skipped as no literals have been"
+             "marked to be added (%" PRIu64 " < %" PRIu64 ")",
+             last.factor.marked, stats.mark.factor);
+    return false;
+  }
+  CADICAL_assert (!level);
+
+  SET_EFFORT_LIMIT (limit, factor, stats.factor);
+  if (!stats.factor)
+    limit += opts.factoriniticks * 1e6;
+
+  START_SIMPLIFIER (factor, FACTOR);
+  stats.factor++;
+
+#ifndef CADICAL_QUIET
+  struct {
+    int64_t variables, clauses, ticks;
+  } before, after, delta;
+  before.variables = stats.variables_extension + stats.variables_original;
+  before.ticks = stats.ticks.factor;
+  before.clauses = stats.current.irredundant;
+#endif
+
+  factor_mode ();
+  bool completed = run_factorization (limit);
+  reset_factor_mode ();
+
+  propagated = 0;
+  if (!unsat && !propagate ()) {
+    learn_empty_clause ();
+  }
+
+#ifndef CADICAL_QUIET
+  after.variables = stats.variables_extension + stats.variables_original;
+  after.clauses = stats.current.irredundant;
+  after.ticks = stats.ticks.factor;
+  delta.variables = after.variables - before.variables;
+  delta.clauses = before.clauses - after.clauses;
+  delta.ticks = after.ticks - before.ticks;
+  VERBOSE (2, "used %f million factorization ticks", delta.ticks * 1e-6);
+  phase ("factorization", stats.factor,
+         "introduced %" PRId64 " extension variables %.0f%%",
+         delta.variables, percent (delta.variables, before.variables));
+  phase ("factorization", stats.factor,
+         "removed %" PRId64 " irredundant clauses %.0f%%", delta.clauses,
+         percent (delta.clauses, before.clauses));
+#endif
+
+  if (completed)
+    last.factor.marked = stats.mark.factor;
+  STOP_SIMPLIFIER (factor, FACTOR);
+  return true;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_file.cpp b/src/sat/cadical/cadical_file.cpp
new file mode 100644
index 000000000..98f19f752
--- /dev/null
+++ b/src/sat/cadical/cadical_file.cpp
@@ -0,0 +1,527 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// Some more low-level 'C' headers.
+
+extern "C" {
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+}
+
+#ifdef WIN32
+
+#include <windows.h>
+#include <io.h>
+#include <cstdio>
+
+#define access _access
+#define popen _popen
+#define pclose _pclose
+#define R_OK 4
+#define W_OK 2
+#define S_IFIFO _S_IFIFO
+#define	S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
+#define	S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)
+
+#else
+
+extern "C" {
+#include <sys/wait.h>
+#include <unistd.h>
+}
+
+#endif
+
+#if defined(__APPLE__) || defined(__MACH__)
+
+extern "C" {
+#include <libproc.h>
+#include <sys/proc_info.h>
+}
+
+#include <mutex>
+
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Private constructor.
+
+File::File (Internal *i, bool w, int c, int p, FILE *f, const char *n)
+    : internal (i),
+#if !defined(CADICAL_QUIET) || !defined(CADICAL_NDEBUG)
+      writing (w),
+#endif
+      close_file (c), child_pid (p), file (f), _name (strdup (n)),
+      _lineno (1), _bytes (0) {
+  (void) w;
+  CADICAL_assert (f), CADICAL_assert (n);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool File::exists (const char *path) {
+  struct stat buf;
+  if (stat (path, &buf))
+    return false;
+  if (access (path, R_OK))
+    return false;
+  return true;
+}
+
+bool File::writable (const char *path) {
+  int res;
+  if (!path)
+    res = 1;
+  else if (!strcmp (path, "/dev/null"))
+    res = 0;
+  else {
+    if (!*path)
+      res = 2;
+    else {
+      struct stat buf;
+      const char *p = strrchr (path, '/');
+      if (!p) {
+        if (stat (path, &buf))
+          res = ((errno == ENOENT) ? 0 : -2);
+        else if (S_ISDIR (buf.st_mode))
+          res = 3;
+        else
+          res = (access (path, W_OK) ? 4 : 0);
+      } else if (!p[1])
+        res = 5;
+      else {
+        size_t len = p - path;
+        char *dirname = new char[len + 1];
+        strncpy (dirname, path, len);
+        dirname[len] = 0;
+        if (stat (dirname, &buf))
+          res = 6;
+        else if (!S_ISDIR (buf.st_mode))
+          res = 7;
+        else if (access (dirname, W_OK))
+          res = 8;
+        else if (stat (path, &buf))
+          res = (errno == ENOENT) ? 0 : -3;
+        else
+          res = access (path, W_OK) ? 9 : 0;
+        delete[] dirname;
+      }
+    }
+  }
+  return !res;
+}
+
+bool File::piping () {
+  struct stat stat;
+  int fd = fileno (file);
+  if (fstat (fd, &stat))
+    return true;
+  return S_ISFIFO (stat.st_mode);
+}
+
+// These are signatures for supported compressed file types.  In 2018 the
+// SAT Competition was running on StarExec and used internally 'bzip2'
+// compressed files, but gave them uncompressed to the solver using exactly
+// the same path (with '.bz2' suffix).  Then 'CaDiCaL' tried to read that
+// actually uncompressed file through 'bzip2', which of course failed.  Now
+// we double check and fall back to reading the file as is, if the signature
+// does not match after issuing a warning.
+
+static int xzsig[] = {0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00, 0x00, EOF};
+static int bz2sig[] = {0x42, 0x5A, 0x68, EOF};
+static int gzsig[] = {0x1F, 0x8B, EOF};
+static int sig7z[] = {0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C, EOF};
+static int lzmasig[] = {0x5D, EOF};
+
+bool File::match (Internal *internal, const char *path, const int *sig) {
+  CADICAL_assert (path);
+  FILE *tmp = fopen (path, "r");
+  if (!tmp) {
+    WARNING ("failed to open '%s' to check signature", path);
+    return false;
+  }
+  bool res = true;
+  for (const int *p = sig; res && (*p != EOF); p++)
+    res = (cadical_getc_unlocked (tmp) == *p);
+  fclose (tmp);
+  if (!res)
+    WARNING ("file type signature check for '%s' failed", path);
+  return res;
+}
+
+size_t File::size (const char *path) {
+  struct stat buf;
+  if (stat (path, &buf))
+    return 0;
+  return (size_t) buf.st_size;
+}
+
+// Check that 'prg' is in the 'PATH' and thus can be found if executed
+// through 'popen' or 'exec'.
+
+char *File::find_program (const char *prg) {
+  size_t prglen = strlen (prg);
+  const char *c = getenv ("PATH");
+  if (!c)
+    return 0;
+  size_t len = strlen (c);
+  char *e = new char[len + 1];
+  strcpy (e, c);
+  char *res = 0;
+  for (char *p = e, *q; !res && p < e + len; p = q) {
+    for (q = p; *q && *q != ':'; q++)
+      ;
+    *q++ = 0;
+    size_t pathlen = (q - p) + prglen;
+    char *path = new char[pathlen + 1];
+    snprintf (path, pathlen + 1, "%s/%s", p, prg);
+    CADICAL_assert (strlen (path) == pathlen);
+    if (exists (path))
+      res = path;
+    else
+      delete[] path;
+  }
+  delete[] e;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+FILE *File::open_file (Internal *internal, const char *path,
+                       const char *mode) {
+  (void) internal;
+  return fopen (path, mode);
+}
+
+FILE *File::read_file (Internal *internal, const char *path) {
+  MSG ("opening file to read '%s'", path);
+  return open_file (internal, path, "r");
+}
+
+FILE *File::write_file (Internal *internal, const char *path) {
+  MSG ("opening file to write '%s'", path);
+  return open_file (internal, path, "wb");
+}
+
+/*------------------------------------------------------------------------*/
+
+void File::split_str (const char *command, std::vector<char *> &argv) {
+  const char *c = command;
+  while (*c && *c == ' ')
+    c++;
+  while (*c) {
+    const char *p = c;
+    while (*p && *p != ' ')
+      p++;
+    const size_t bytes = p - c;
+    char *arg = new char[bytes + 1];
+    (void) strncpy (arg, c, bytes);
+    arg[bytes] = 0;
+    argv.push_back (arg);
+    while (*p && *p == ' ')
+      p++;
+    c = p;
+  }
+}
+
+void File::delete_str_vector (std::vector<char *> &argv) {
+  for (auto str : argv)
+    delete[] str;
+}
+
+FILE *File::open_pipe (Internal *internal, const char *fmt,
+                       const char *path, const char *mode) {
+#ifdef CADICAL_QUIET
+  (void) internal;
+#endif
+  size_t prglen = 0;
+  while (fmt[prglen] && fmt[prglen] != ' ')
+    prglen++;
+  char *prg = new char[prglen + 1];
+  strncpy (prg, fmt, prglen);
+  prg[prglen] = 0;
+  char *found = find_program (prg);
+  if (found)
+    MSG ("found '%s' in path for '%s'", found, prg);
+  if (!found)
+    MSG ("did not find '%s' in path", prg);
+  delete[] prg;
+  if (!found)
+    return 0;
+  delete[] found;
+  size_t cmd_size = strlen (fmt) + strlen (path);
+  char *cmd = new char[cmd_size];
+  snprintf (cmd, cmd_size, fmt, path);
+  FILE *res = popen (cmd, mode);
+  delete[] cmd;
+  return res;
+}
+
+FILE *File::read_pipe (Internal *internal, const char *fmt, const int *sig,
+                       const char *path) {
+  if (!File::exists (path)) {
+    LOG ("file '%s' does not exist", path);
+    return 0;
+  }
+  LOG ("file '%s' exists", path);
+  if (sig && !File::match (internal, path, sig))
+    return 0;
+  LOG ("file '%s' matches signature for '%s'", path, fmt);
+  MSG ("opening pipe to read '%s'", path);
+  return open_pipe (internal, fmt, path, "r");
+}
+
+#ifndef _WIN32
+
+#if defined(__APPLE__) || defined(__MACH__)
+static std::mutex compressed_file_writing_mutex;
+#endif
+
+FILE *File::write_pipe (Internal *internal, const char *command,
+                        const char *path, int &child_pid) {
+  CADICAL_assert (command[0] && command[0] != ' ');
+  MSG ("writing through command '%s' to '%s'", command, path);
+#ifdef CADICAL_QUIET
+  (void) internal;
+#endif
+  std::vector<char *> args;
+  split_str (command, args);
+  CADICAL_assert (!args.empty ());
+  args.push_back (0);
+  char **argv = args.data ();
+  char *absolute_command_path = find_program (argv[0]);
+  int pipe_fds[2], out;
+  FILE *res = 0;
+#if defined(__APPLE__) || defined(__MACH__)
+  compressed_file_writing_mutex.lock ();
+#endif
+  if (!absolute_command_path)
+    MSG ("could not find '%s' in 'PATH' environment variable", argv[0]);
+  else if (::pipe (pipe_fds) < 0)
+    MSG ("could not generate pipe to '%s' command", command);
+  else if ((out = ::open (path, O_CREAT | O_TRUNC | O_WRONLY, 0644)) < 0)
+    MSG ("could not open '%s' for writing", path);
+  else if ((child_pid = ::fork ()) < 0) {
+    MSG ("could not fork process to execute '%s' command", command);
+    ::close (out);
+  } else if (child_pid) {
+    ::close (pipe_fds[0]);
+    res = ::fdopen (pipe_fds[1], "wb");
+  } else {
+
+    // Connect stdin and stdout in child
+
+    ::dup2 (pipe_fds[0], 0);
+    ::dup2 (out, 1);
+
+    // Make sure to close all non-required fds to not cause hangs.
+    // This is handled now by closefrom and remains for documentation
+    // purposes:
+    //
+    //   ::close (pipe_fds[0]);
+    //   ::close (pipe_fds[1]);
+    //   ::close (out);
+
+    // Surpress '7z' verbose output on 'stderr'.
+
+    if (command[0] == '7') {
+      ::close (2);
+    }
+
+    // Before the fork another thread could have created more fds.  These
+    // fds are cloned into the child process.  As this inhibits pipes to
+    // be closed by the parent process we have to close all of the
+    // erroneously cloned fds here.
+
+#ifndef CADICAL_NCLOSEFROM
+    ::closefrom (3);
+#else
+    // Simplistic replacement on Unix without 'closefrom'.
+    for (int fd = 3; fd != FD_SETSIZE; fd++)
+      ::close (fd);
+#endif
+    execv (absolute_command_path, argv);
+    _exit (1);
+  }
+  if (absolute_command_path)
+    delete[] absolute_command_path;
+  delete_str_vector (args);
+#ifdef CADICAL_QUIET
+  (void) internal;
+#endif
+#if defined(__APPLE__) || defined(__MACH__)
+  if (!res)
+    compressed_file_writing_mutex.unlock ();
+#endif
+  return res;
+}
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+File *File::read (Internal *internal, FILE *f, const char *n) {
+  return new File (internal, false, 0, 0, f, n);
+}
+
+File *File::write (Internal *internal, FILE *f, const char *n) {
+  return new File (internal, true, 0, 0, f, n);
+}
+
+File *File::read (Internal *internal, const char *path) {
+  FILE *file;
+  int close_input = 2;
+  if (has_suffix (path, ".xz")) {
+    file = read_pipe (internal, "xz -c -d %s", xzsig, path);
+    if (!file)
+      goto READ_FILE;
+  } else if (has_suffix (path, ".lzma")) {
+    file = read_pipe (internal, "lzma -c -d %s", lzmasig, path);
+    if (!file)
+      goto READ_FILE;
+  } else if (has_suffix (path, ".bz2")) {
+    file = read_pipe (internal, "bzip2 -c -d %s", bz2sig, path);
+    if (!file)
+      goto READ_FILE;
+  } else if (has_suffix (path, ".gz")) {
+    file = read_pipe (internal, "gzip -c -d %s", gzsig, path);
+    if (!file)
+      goto READ_FILE;
+  } else if (has_suffix (path, ".7z")) {
+    file = read_pipe (internal, "7z x -so %s 2>/dev/null", sig7z, path);
+    if (!file)
+      goto READ_FILE;
+  } else {
+  READ_FILE:
+    file = read_file (internal, path);
+    close_input = 1;
+  }
+
+  if (!file)
+    return 0;
+
+  return new File (internal, false, close_input, 0, file, path);
+}
+
+File *File::write (Internal *internal, const char *path) {
+  FILE *file;
+  int close_output = 3, child_pid = 0;
+#ifndef _WIN32
+  if (has_suffix (path, ".xz"))
+    file = write_pipe (internal, "xz -c", path, child_pid);
+  else if (has_suffix (path, ".bz2"))
+    file = write_pipe (internal, "bzip2 -c", path, child_pid);
+  else if (has_suffix (path, ".gz"))
+    file = write_pipe (internal, "gzip -c", path, child_pid);
+  else if (has_suffix (path, ".7z"))
+    file = write_pipe (internal, "7z a -an -txz -si -so", path, child_pid);
+  else
+#endif
+    file = write_file (internal, path), close_output = 1;
+
+  if (!file)
+    return 0;
+
+  return new File (internal, true, close_output, child_pid, file, path);
+}
+
+void File::close (bool print) {
+  CADICAL_assert (file);
+#ifndef CADICAL_QUIET
+  if (internal->opts.quiet)
+    print = false;
+  else if (internal->opts.verbose > 0)
+    print = true;
+#endif
+  if (close_file == 0) {
+    if (print)
+      MSG ("disconnecting from '%s'", name ());
+  }
+  if (close_file == 1) {
+    if (print)
+      MSG ("closing file '%s'", name ());
+    fclose (file);
+  }
+  if (close_file == 2) {
+    if (print)
+      MSG ("closing input pipe to read '%s'", name ());
+    pclose (file);
+  }
+#ifndef _WIN32
+  if (close_file == 3) {
+    if (print)
+      MSG ("closing output pipe to write '%s'", name ());
+    fclose (file);
+    waitpid (child_pid, 0, 0);
+#if defined(__APPLE__) || defined(__MACH__)
+    compressed_file_writing_mutex.unlock ();
+#endif
+  }
+#endif
+  file = 0; // mark as closed
+
+  // TODO what about error checking for 'fclose', 'pclose' or 'waitpid'?
+
+#ifndef CADICAL_QUIET
+  if (print) {
+    if (writing) {
+      uint64_t written_bytes = bytes ();
+      double written_mb = written_bytes / (double) (1 << 20);
+      MSG ("after writing %" PRIu64 " bytes %.1f MB", written_bytes,
+           written_mb);
+      if (close_file == 3) {
+        size_t actual_bytes = size (name ());
+        if (actual_bytes) {
+          double actual_mb = actual_bytes / (double) (1 << 20);
+          MSG ("deflated to %zd bytes %.1f MB", actual_bytes, actual_mb);
+          MSG ("factor %.2f (%.2f%% compression)",
+               relative (written_bytes, actual_bytes),
+               percent (actual_bytes, written_bytes));
+        } else
+          MSG ("but could not determine actual size of written file");
+      }
+    } else {
+      uint64_t read_bytes = bytes ();
+      double read_mb = read_bytes / (double) (1 << 20);
+      MSG ("after reading %" PRIu64 " bytes %.1f MB", read_bytes, read_mb);
+      if (close_file == 2) {
+        size_t actual_bytes = size (name ());
+        double actual_mb = actual_bytes / (double) (1 << 20);
+        MSG ("inflated from %zd bytes %.1f MB", actual_bytes, actual_mb);
+        MSG ("factor %.2f (%.2f%% compression)",
+             relative (read_bytes, actual_bytes),
+             percent (actual_bytes, read_bytes));
+      }
+    }
+  }
+#endif
+}
+
+void File::flush () {
+  CADICAL_assert (file);
+  fflush (file);
+}
+
+File::~File () {
+  if (file)
+    close ();
+  free (_name);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_flags.cpp b/src/sat/cadical/cadical_flags.cpp
new file mode 100644
index 000000000..5c06a33b4
--- /dev/null
+++ b/src/sat/cadical/cadical_flags.cpp
@@ -0,0 +1,141 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::mark_fixed (int lit) {
+  if (external->fixed_listener) {
+    int elit = externalize (lit);
+    CADICAL_assert (elit);
+    const int eidx = abs (elit);
+    if (!external->ervars[eidx])
+      external->fixed_listener->notify_fixed_assignment (elit);
+  }
+  Flags &f = flags (lit);
+  CADICAL_assert (f.status == Flags::ACTIVE);
+  f.status = Flags::FIXED;
+  LOG ("fixed %d", abs (lit));
+  stats.all.fixed++;
+  stats.now.fixed++;
+  stats.inactive++;
+  CADICAL_assert (stats.active);
+  stats.active--;
+  CADICAL_assert (!active (lit));
+  CADICAL_assert (f.fixed ());
+
+  if (external_prop && private_steps) {
+    // If pre/inprocessing found a fixed assignment, we want the propagator
+    // to know about it.
+    // But at that point it is not guaranteed to be already on the trail, so
+    // notification will happen only later.
+    CADICAL_assert (!level);
+  }
+}
+
+void Internal::mark_eliminated (int lit) {
+  Flags &f = flags (lit);
+  CADICAL_assert (f.status == Flags::ACTIVE);
+  f.status = Flags::ELIMINATED;
+  LOG ("eliminated %d", abs (lit));
+  stats.all.eliminated++;
+  stats.now.eliminated++;
+  stats.inactive++;
+  CADICAL_assert (stats.active);
+  stats.active--;
+  CADICAL_assert (!active (lit));
+  CADICAL_assert (f.eliminated ());
+}
+
+void Internal::mark_pure (int lit) {
+  Flags &f = flags (lit);
+  CADICAL_assert (f.status == Flags::ACTIVE);
+  f.status = Flags::PURE;
+  LOG ("pure %d", abs (lit));
+  stats.all.pure++;
+  stats.now.pure++;
+  stats.inactive++;
+  CADICAL_assert (stats.active);
+  stats.active--;
+  CADICAL_assert (!active (lit));
+  CADICAL_assert (f.pure ());
+}
+
+void Internal::mark_substituted (int lit) {
+  Flags &f = flags (lit);
+  CADICAL_assert (f.status == Flags::ACTIVE);
+  f.status = Flags::SUBSTITUTED;
+  LOG ("substituted %d", abs (lit));
+  stats.all.substituted++;
+  stats.now.substituted++;
+  stats.inactive++;
+  CADICAL_assert (stats.active);
+  stats.active--;
+  CADICAL_assert (!active (lit));
+  CADICAL_assert (f.substituted ());
+}
+
+void Internal::mark_active (int lit) {
+  Flags &f = flags (lit);
+  CADICAL_assert (f.status == Flags::UNUSED);
+  f.status = Flags::ACTIVE;
+  LOG ("activate %d previously unused", abs (lit));
+  CADICAL_assert (stats.inactive);
+  stats.inactive--;
+  CADICAL_assert (stats.unused);
+  stats.unused--;
+  stats.active++;
+  CADICAL_assert (active (lit));
+}
+
+void Internal::reactivate (int lit) {
+  CADICAL_assert (!active (lit));
+  Flags &f = flags (lit);
+  CADICAL_assert (f.status != Flags::FIXED);
+  CADICAL_assert (f.status != Flags::UNUSED);
+#ifdef LOGGING
+  const char *msg = 0;
+#endif
+  switch (f.status) {
+  default:
+  case Flags::ELIMINATED:
+    CADICAL_assert (f.status == Flags::ELIMINATED);
+    CADICAL_assert (stats.now.eliminated > 0);
+    stats.now.eliminated--;
+#ifdef LOGGING
+    msg = "eliminated";
+#endif
+    break;
+  case Flags::SUBSTITUTED:
+#ifdef LOGGING
+    msg = "substituted";
+#endif
+    CADICAL_assert (stats.now.substituted > 0);
+    stats.now.substituted--;
+    break;
+  case Flags::PURE:
+#ifdef LOGGING
+    msg = "pure literal";
+#endif
+    CADICAL_assert (stats.now.pure > 0);
+    stats.now.pure--;
+    break;
+  }
+#ifdef LOGGING
+  CADICAL_assert (msg);
+  LOG ("reactivate previously %s %d", msg, abs (lit));
+#endif
+  f.status = Flags::ACTIVE;
+  f.sweep = false;
+  CADICAL_assert (active (lit));
+  stats.reactivated++;
+  CADICAL_assert (stats.inactive > 0);
+  stats.inactive--;
+  stats.active++;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_flip.cpp b/src/sat/cadical/cadical_flip.cpp
new file mode 100644
index 000000000..a89e3abb7
--- /dev/null
+++ b/src/sat/cadical/cadical_flip.cpp
@@ -0,0 +1,275 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+bool Internal::flip (int lit) {
+
+  // Do not try to flip inactive literals except for unused variables.
+
+  if (!active (lit) && !flags (lit).unused ())
+    return false;
+
+  /*
+  if (flags (lit).unused ()) {
+    CADICAL_assert (lit <= max_var);
+    mark_active (lit);
+    set_val (lit, 1);
+    return true;
+  }
+  */
+
+  // TODO: Unused case is not handled yet.
+  // if (flags (lit).unused ()) return false;
+
+  // Need to reestablish proper watching invariants as if there are no
+  // blocking literals as flipping in principle does not work with them.
+
+  if (propergated < trail.size ())
+    propergate ();
+
+  LOG ("trying to flip %d", lit);
+
+  const int idx = vidx (lit);
+  const signed char original_value = vals[idx];
+  CADICAL_assert (original_value);
+  lit = original_value < 0 ? -idx : idx;
+  CADICAL_assert (val (lit) > 0);
+
+  // Here we go over all the clauses in which 'lit' is watched by 'lit' and
+  // check whether assigning 'lit' to false would break watching invariants
+  // or even make the clause false.  We also try to find replacement
+  // watches in case this fixes the watching invariant.  This code is very
+  // similar to propagation of a literal in 'Internal::propagate'.
+
+  bool res = true;
+
+  Watches &ws = watches (lit);
+  const const_watch_iterator eow = ws.end ();
+  watch_iterator bow = ws.begin ();
+
+  // We first go over binary watches/clauses first as this is cheaper and
+  // has higher chance of failure and we can not use blocking literals.
+
+  for (const_watch_iterator i = bow; i != eow; i++) {
+    const Watch w = *i;
+    if (!w.binary ())
+      continue;
+    const signed char b = val (w.blit);
+    if (b > 0)
+      continue;
+    CADICAL_assert (b < 0);
+    res = false;
+    break;
+  }
+
+  if (res) {
+    const_watch_iterator i = bow;
+    watch_iterator j = bow;
+
+    while (i != eow) {
+
+      const Watch w = *j++ = *i++;
+
+      if (w.binary ())
+        continue;
+
+      if (w.clause->garbage) {
+        j--;
+        continue;
+      }
+
+      literal_iterator lits = w.clause->begin ();
+
+      const int other = lits[0] ^ lits[1] ^ lit;
+      const signed char u = val (other);
+      if (u > 0)
+        continue;
+
+      const int size = w.clause->size;
+      const literal_iterator middle = lits + w.clause->pos;
+      const const_literal_iterator end = lits + size;
+      literal_iterator k = middle;
+
+      int r = 0;
+      signed char v = -1;
+      while (k != end && (v = val (r = *k)) < 0)
+        k++;
+      if (v < 0) {
+        k = lits + 2;
+        CADICAL_assert (w.clause->pos <= size);
+        while (k != middle && (v = val (r = *k)) < 0)
+          k++;
+      }
+
+      if (v < 0) {
+        res = false;
+        break;
+      }
+
+      CADICAL_assert (v > 0);
+      CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
+      w.clause->pos = k - lits;
+      lits[0] = other, lits[1] = r, *k = lit;
+      watch_literal (r, lit, w.clause);
+      j--;
+    }
+
+    if (j != i) {
+
+      while (i != eow)
+        *j++ = *i++;
+
+      ws.resize (j - ws.begin ());
+    }
+  }
+#ifdef LOGGING
+  if (res)
+    LOG ("literal %d can be flipped", lit);
+  else
+    LOG ("literal %d can not be flipped", lit);
+#endif
+
+  if (res) {
+
+    const int idx = vidx (lit);
+    const signed char original_value = vals[idx];
+    CADICAL_assert (original_value);
+    lit = original_value < 0 ? -idx : idx;
+    CADICAL_assert (val (lit) > 0);
+
+    LOG ("flipping value of %d = 1 to %d = -1", lit, lit);
+
+    set_val (idx, -original_value);
+    CADICAL_assert (val (-lit) > 0);
+    CADICAL_assert (val (lit) < 0);
+
+    Var &v = var (idx);
+    CADICAL_assert (trail[v.trail] == lit);
+    trail[v.trail] = -lit;
+    if (opts.ilb) {
+      if (!tainted_literal)
+        tainted_literal = lit;
+      else {
+        CADICAL_assert (val (tainted_literal));
+        if (v.level < var (tainted_literal).level) {
+          tainted_literal = lit;
+        }
+      }
+    }
+  } else
+    LOG ("flipping value of %d failed", lit);
+
+  return res;
+}
+
+bool Internal::flippable (int lit) {
+
+  // Can not check inactive literals except for unused variables.
+
+  if (!active (lit) && !flags (lit).unused ())
+    return false;
+
+  /*
+  if (flags (lit).unused ()) {
+    CADICAL_assert (lit <= max_var);
+    mark_active (lit);
+    return true;
+  }
+  */
+  // TODO: Unused case is not handled yet
+  // if (flags (lit).unused ()) return false;
+
+  // Need to reestablish proper watching invariants as if there are no
+  // blocking literals as flipping in principle does not work with them.
+
+  if (propergated < trail.size ())
+    propergate ();
+
+  LOG ("checking whether %d is flippable", lit);
+
+  const int idx = vidx (lit);
+  const signed char original_value = vals[idx];
+  CADICAL_assert (original_value);
+  lit = original_value < 0 ? -idx : idx;
+  CADICAL_assert (val (lit) > 0);
+
+  // Here we go over all the clauses in which 'lit' is watched by 'lit' and
+  // check whether assigning 'lit' to false would break watching invariants
+  // or even make the clause false.  In contrast to 'flip' we do not try to
+  // find replacement literals but do use blocking literals'.  Therefore we
+  // also do not split the traversal code into two parts.
+
+  bool res = true;
+
+  Watches &ws = watches (lit);
+  const const_watch_iterator eow = ws.end ();
+  for (watch_iterator i = ws.begin (); i != eow; i++) {
+
+    const Watch w = *i;
+    const signed char b = val (w.blit);
+    if (b > 0)
+      continue;
+    CADICAL_assert (b < 0);
+
+    if (w.binary ()) {
+      res = false;
+      break;
+    }
+
+    if (w.clause->garbage)
+      continue;
+
+    literal_iterator lits = w.clause->begin ();
+
+    const int other = lits[0] ^ lits[1] ^ lit;
+    const signed char u = val (other);
+    if (u > 0) {
+      i->blit = other;
+      continue;
+    }
+
+    const int size = w.clause->size;
+    const literal_iterator middle = lits + w.clause->pos;
+    const const_literal_iterator end = lits + size;
+    literal_iterator k = middle;
+
+    int r = 0;
+    signed char v = -1;
+    while (k != end && (v = val (r = *k)) < 0)
+      k++;
+    if (v < 0) {
+      k = lits + 2;
+      CADICAL_assert (w.clause->pos <= size);
+      while (k != middle && (v = val (r = *k)) < 0)
+        k++;
+    }
+
+    if (v < 0) {
+      res = false;
+      break;
+    }
+
+    CADICAL_assert (v > 0);
+    CADICAL_assert (lits + 2 <= k);
+    CADICAL_assert (k <= w.clause->end ());
+    w.clause->pos = k - lits;
+    i->blit = r;
+  }
+
+#ifdef LOGGING
+  if (res)
+    LOG ("literal %d can be flipped", lit);
+  else
+    LOG ("literal %d can not be flipped", lit);
+#endif
+
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_format.cpp b/src/sat/cadical/cadical_format.cpp
new file mode 100644
index 000000000..942d9d74a
--- /dev/null
+++ b/src/sat/cadical/cadical_format.cpp
@@ -0,0 +1,95 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Format::enlarge () {
+  char *old = buffer;
+  buffer = new char[size = size ? 2 * size : 1];
+  memcpy (buffer, old, count);
+  delete[] old;
+}
+
+inline void Format::push_char (char ch) {
+  if (size == count)
+    enlarge ();
+  buffer[count++] = ch;
+}
+
+void Format::push_string (const char *s) {
+  char ch;
+  while ((ch = *s++))
+    push_char (ch);
+}
+
+void Format::push_int (int d) {
+  char tmp[16];
+  snprintf (tmp, sizeof tmp, "%d", d);
+  push_string (tmp);
+}
+
+void Format::push_uint64 (uint64_t u) {
+  char tmp[16];
+  snprintf (tmp, sizeof tmp, "%" PRIu64, u);
+  push_string (tmp);
+}
+
+static bool match_format (const char *&str, const char *pattern) {
+  CADICAL_assert (pattern);
+  const char *p = str;
+  const char *q = pattern;
+  while (*q)
+    if (*q++ != *p++)
+      return false;
+  str = p;
+  return true;
+}
+
+const char *Format::add (const char *fmt, va_list &ap) {
+  const char *p = fmt;
+  char ch;
+  while ((ch = *p++)) {
+    if (ch != '%')
+      push_char (ch);
+    else if (*p == 'c')
+      push_char (va_arg (ap, int)), p++;
+    else if (*p == 'd')
+      push_int (va_arg (ap, int)), p++;
+    else if (*p == 's')
+      push_string (va_arg (ap, const char *)), p++;
+    else if (match_format (p, PRIu64))
+      push_uint64 (va_arg (ap, uint64_t));
+    else {
+      push_char ('%');
+      push_char (*p);
+      break;
+    } // unsupported
+  }
+  push_char (0);
+  count--; // thus automatic append in subsequent calls.
+  return buffer;
+}
+
+const char *Format::init (const char *fmt, ...) {
+  count = 0;
+  va_list ap;
+  va_start (ap, fmt);
+  const char *res = add (fmt, ap);
+  va_end (ap);
+  return res;
+}
+
+const char *Format::append (const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  const char *res = add (fmt, ap);
+  va_end (ap);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_frattracer.cpp b/src/sat/cadical/cadical_frattracer.cpp
new file mode 100644
index 000000000..d35a18271
--- /dev/null
+++ b/src/sat/cadical/cadical_frattracer.cpp
@@ -0,0 +1,283 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+FratTracer::FratTracer (Internal *i, File *f, bool b, bool a)
+    : internal (i), file (f), binary (b), with_antecedents (a)
+#ifndef CADICAL_QUIET
+      ,
+      added (0), deleted (0), finalized (0), original (0)
+#endif
+{
+  (void) internal;
+}
+
+void FratTracer::connect_internal (Internal *i) {
+  internal = i;
+  file->connect_internal (internal);
+  LOG ("FRAT TRACER connected to internal");
+}
+
+FratTracer::~FratTracer () {
+  LOG ("FRAT TRACER delete");
+  delete file;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void FratTracer::put_binary_zero () {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  file->put ((unsigned char) 0);
+}
+
+inline void FratTracer::put_binary_lit (int lit) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  CADICAL_assert (lit != INT_MIN);
+  unsigned x = 2 * abs (lit) + (lit < 0);
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+inline void FratTracer::put_binary_id (int64_t id, bool can_be_negative) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  uint64_t x = abs (id);
+  if (can_be_negative) {
+    x = 2 * x + (id < 0);
+  }
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+/*------------------------------------------------------------------------*/
+
+void FratTracer::frat_add_original_clause (int64_t id,
+                                           const vector<int> &clause) {
+  if (binary)
+    file->put ('o');
+  else
+    file->put ("o ");
+  if (binary)
+    put_binary_id (id);
+  else
+    file->put (id), file->put ("  ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+}
+
+void FratTracer::frat_add_derived_clause (int64_t id,
+                                          const vector<int> &clause) {
+  if (binary)
+    file->put ('a');
+  else
+    file->put ("a ");
+  if (binary)
+    put_binary_id (id);
+  else
+    file->put (id), file->put ("  ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+}
+
+void FratTracer::frat_add_derived_clause (int64_t id,
+                                          const vector<int> &clause,
+                                          const vector<int64_t> &chain) {
+  if (binary)
+    file->put ('a');
+  else
+    file->put ("a ");
+  if (binary)
+    put_binary_id (id);
+  else
+    file->put (id), file->put ("  ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero (), file->put ('l');
+  else
+    file->put ("0  l ");
+  for (const auto &c : chain)
+    if (binary)
+      put_binary_id (c, true); // LRAT can have negative ids
+    else
+      file->put (c), file->put (' '); // in proof chain, so they get
+  if (binary)
+    put_binary_zero (); // since cadical has no rat-steps
+  else
+    file->put ("0\n"); // this is just 2c here
+}
+
+void FratTracer::frat_delete_clause (int64_t id,
+                                     const vector<int> &clause) {
+  if (binary)
+    file->put ('d');
+  else
+    file->put ("d ");
+  if (binary)
+    put_binary_id (id);
+  else
+    file->put (id), file->put ("  ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+}
+
+void FratTracer::frat_finalize_clause (int64_t id,
+                                       const vector<int> &clause) {
+  if (binary)
+    file->put ('f');
+  else
+    file->put ("f ");
+  if (binary)
+    put_binary_id (id);
+  else
+    file->put (id), file->put ("  ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+}
+
+/*------------------------------------------------------------------------*/
+
+void FratTracer::add_original_clause (int64_t id, bool,
+                                      const vector<int> &clause, bool) {
+  if (file->closed ())
+    return;
+  LOG ("FRAT TRACER tracing addition of original clause");
+  frat_add_original_clause (id, clause);
+}
+
+void FratTracer::add_derived_clause (int64_t id, bool,
+                                     const vector<int> &clause,
+                                     const vector<int64_t> &chain) {
+  if (file->closed ())
+    return;
+  LOG ("FRAT TRACER tracing addition of derived clause");
+  if (with_antecedents)
+    frat_add_derived_clause (id, clause, chain);
+  else
+    frat_add_derived_clause (id, clause);
+#ifndef CADICAL_QUIET
+  added++;
+#endif
+}
+
+void FratTracer::delete_clause (int64_t id, bool,
+                                const vector<int> &clause) {
+  if (file->closed ())
+    return;
+  LOG ("FRAT TRACER tracing deletion of clause");
+  frat_delete_clause (id, clause);
+#ifndef CADICAL_QUIET
+  deleted++;
+#endif
+}
+
+void FratTracer::finalize_clause (int64_t id, const vector<int> &clause) {
+  if (file->closed ())
+    return;
+  LOG ("FRAT TRACER tracing finalization of clause");
+  frat_finalize_clause (id, clause);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool FratTracer::closed () { return file->closed (); }
+
+#ifndef CADICAL_QUIET
+
+void FratTracer::print_statistics () {
+  uint64_t bytes = file->bytes ();
+  uint64_t total = original + added + deleted + finalized;
+  MSG ("FRAT %" PRId64 " original clauses %.2f%%", original,
+       percent (original, total));
+  MSG ("FRAT %" PRId64 " added clauses %.2f%%", added,
+       percent (added, total));
+  MSG ("FRAT %" PRId64 " deleted clauses %.2f%%", deleted,
+       percent (deleted, total));
+  MSG ("FRAT %" PRId64 " finalized clauses %.2f%%", finalized,
+       percent (finalized, total));
+  MSG ("FRAT %" PRId64 " bytes (%.2f MB)", bytes,
+       bytes / (double) (1 << 20));
+}
+
+#endif
+
+void FratTracer::close (bool print) {
+  CADICAL_assert (!closed ());
+  file->close ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("FRAT proof file '%s' closed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+void FratTracer::flush (bool print) {
+  CADICAL_assert (!closed ());
+  file->flush ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("FRAT proof file '%s' flushed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_gates.cpp b/src/sat/cadical/cadical_gates.cpp
new file mode 100644
index 000000000..06a73d1eb
--- /dev/null
+++ b/src/sat/cadical/cadical_gates.cpp
@@ -0,0 +1,772 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// As in our original SATeLite published at SAT'05 we are trying to find
+// gates in order to restrict the number of resolutions that need to be
+// tried.  If there is such a gate, we only need to consider resolvents
+// among gate and one non-gate clauses.  Resolvents between definitions will
+// be tautological anyhow and resolvents among non-gates can actually be
+// shown to be redundant too.
+
+/*------------------------------------------------------------------------*/
+
+// The next function returns a non-zero if the clause 'c', which is assumed
+// to contain the literal 'first', after removing falsified literals is a
+// binary clause.  Then the actual second literal is returned.
+
+int Internal::second_literal_in_binary_clause (Eliminator &eliminator,
+                                               Clause *c, int first) {
+  CADICAL_assert (!c->garbage);
+  int second = 0;
+  for (const auto &lit : *c) {
+    if (lit == first)
+      continue;
+    const signed char tmp = val (lit);
+    if (tmp < 0)
+      continue;
+    if (tmp > 0) {
+      mark_garbage (c);
+      elim_update_removed_clause (eliminator, c);
+      return 0;
+    }
+    if (second) {
+      second = INT_MIN;
+      break;
+    }
+    second = lit;
+  }
+  if (!second)
+    return 0;
+  if (second == INT_MIN)
+    return 0;
+  CADICAL_assert (active (second));
+#ifdef LOGGING
+  if (c->size == 2)
+    LOG (c, "found binary");
+  else
+    LOG (c, "found actual binary %d %d", first, second);
+#endif
+  return second;
+}
+
+/*------------------------------------------------------------------------*/
+
+// need a copy from above that does not care about garbage
+
+int Internal::second_literal_in_binary_clause_lrat (Clause *c, int first) {
+  if (c->garbage)
+    return 0;
+  int second = 0;
+  for (const auto &lit : *c) {
+    if (lit == first)
+      continue;
+    const signed char tmp = val (lit);
+    if (tmp < 0)
+      continue;
+    if (tmp > 0)
+      return 0;
+    if (!tmp) {
+      if (second) {
+        second = INT_MIN;
+        break;
+      }
+      second = lit;
+    }
+  }
+  if (!second)
+    return 0;
+  if (second == INT_MIN)
+    return 0;
+  return second;
+}
+
+// I needed to find the second clause for hyper unary resolution to build
+// LRAT this is not efficient but I could not find a better way then just
+// finding the corresponding clause in all possible clauses
+//
+Clause *Internal::find_binary_clause (int first, int second) {
+  int best = first;
+  int other = second;
+  if (occs (first).size () > occs (second).size ()) {
+    best = second;
+    other = first;
+  }
+  for (auto c : occs (best))
+    if (second_literal_in_binary_clause_lrat (c, best) == other)
+      return c;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Mark all other literals in binary clauses with 'first'.  During this
+// marking we might also detect hyper unary resolvents producing a unit.
+// If such a unit is found we propagate it and return immediately.
+
+void Internal::mark_binary_literals (Eliminator &eliminator, int first) {
+
+  if (unsat)
+    return;
+  if (val (first))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  CADICAL_assert (!marked (first));
+  CADICAL_assert (eliminator.marked.empty ());
+
+  const Occs &os = occs (first);
+  for (const auto &c : os) {
+    if (c->garbage)
+      continue;
+    const int second =
+        second_literal_in_binary_clause (eliminator, c, first);
+    if (!second)
+      continue;
+    const int tmp = marked (second);
+    if (tmp < 0) {
+      // had a bug where units could occur multiple times here
+      // solved with flags
+      LOG ("found binary resolved unit %d", first);
+      if (lrat) {
+        Clause *d = find_binary_clause (first, -second);
+        CADICAL_assert (d);
+        for (auto &lit : *d) {
+          if (lit == first || lit == -second)
+            continue;
+          CADICAL_assert (val (lit) < 0);
+          Flags &f = flags (lit);
+          if (f.seen)
+            continue;
+          analyzed.push_back (lit);
+          f.seen = true;
+          int64_t id = unit_id (-lit);
+          lrat_chain.push_back (id);
+          // LOG ("gates added id %" PRId64, id);
+        }
+        for (auto &lit : *c) {
+          if (lit == first || lit == second)
+            continue;
+          CADICAL_assert (val (lit) < 0);
+          Flags &f = flags (lit);
+          if (f.seen)
+            continue;
+          analyzed.push_back (lit);
+          f.seen = true;
+          int64_t id = unit_id (-lit);
+          lrat_chain.push_back (id);
+          // LOG ("gates added id %" PRId64, id);
+        }
+        lrat_chain.push_back (c->id);
+        lrat_chain.push_back (d->id);
+        // LOG ("gates added id %" PRId64, c->id);
+        // LOG ("gates added id %" PRId64, d->id);
+        clear_analyzed_literals ();
+      }
+      assign_unit (first);
+      elim_propagate (eliminator, first);
+      return;
+    }
+    if (tmp > 0) {
+      LOG (c, "duplicated actual binary clause");
+      elim_update_removed_clause (eliminator, c);
+      mark_garbage (c);
+      continue;
+    }
+    eliminator.marked.push_back (second);
+    mark (second);
+    LOG ("marked second literal %d in binary clause %d %d", second, first,
+         second);
+  }
+}
+
+// Unmark all literals saved on the 'marked' stack.
+
+void Internal::unmark_binary_literals (Eliminator &eliminator) {
+  LOG ("unmarking %zd literals", eliminator.marked.size ());
+  for (const auto &lit : eliminator.marked)
+    unmark (lit);
+  eliminator.marked.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find equivalence for 'pivot'.  Requires that all other literals in binary
+// clauses with 'pivot' are marked (through 'mark_binary_literals');
+
+void Internal::find_equivalence (Eliminator &eliminator, int pivot) {
+
+  if (!opts.elimequivs)
+    return;
+
+  CADICAL_assert (opts.elimsubst);
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  mark_binary_literals (eliminator, pivot);
+  if (unsat || val (pivot))
+    goto DONE;
+
+  for (const auto &c : occs (-pivot)) {
+
+    if (c->garbage)
+      continue;
+
+    const int second =
+        second_literal_in_binary_clause (eliminator, c, -pivot);
+    if (!second)
+      continue;
+    const int tmp = marked (second);
+    if (tmp > 0) {
+      LOG ("found binary resolved unit %d", second);
+      // did not find a bug where units could occur multiple times here
+      // still solved potential issues with flags
+      if (lrat) {
+        Clause *d = find_binary_clause (pivot, second);
+        CADICAL_assert (d);
+        for (auto &lit : *d) {
+          if (lit == pivot || lit == second)
+            continue;
+          CADICAL_assert (val (lit) < 0);
+          Flags &f = flags (lit);
+          if (f.seen)
+            continue;
+          analyzed.push_back (lit);
+          f.seen = true;
+          int64_t id = unit_id (-lit);
+          lrat_chain.push_back (id);
+          // LOG ("gates added id %" PRId64, id);
+        }
+        for (auto &lit : *c) {
+          if (lit == -pivot || lit == second)
+            continue;
+          CADICAL_assert (val (lit) < 0);
+          Flags &f = flags (lit);
+          if (f.seen)
+            continue;
+          analyzed.push_back (lit);
+          f.seen = true;
+          int64_t id = unit_id (-lit);
+          lrat_chain.push_back (id);
+          // LOG ("gates added id %" PRId64, id);
+        }
+        lrat_chain.push_back (c->id);
+        lrat_chain.push_back (d->id);
+        clear_analyzed_literals ();
+        // LOG ("gates added id %" PRId64, c->id);
+        // LOG ("gates added id %" PRId64, d->id);
+      }
+      assign_unit (second);
+      elim_propagate (eliminator, second);
+      if (val (pivot))
+        break;
+      if (unsat)
+        break;
+    }
+    if (tmp >= 0)
+      continue;
+
+    LOG ("found equivalence %d = %d", pivot, -second);
+    stats.elimequivs++;
+    stats.elimgates++;
+
+    LOG (c, "first gate clause");
+    CADICAL_assert (!c->gate);
+    c->gate = true;
+    eliminator.gates.push_back (c);
+
+    Clause *d = 0;
+    const Occs &ps = occs (pivot);
+    for (const auto &e : ps) {
+      if (e->garbage)
+        continue;
+      const int other =
+          second_literal_in_binary_clause (eliminator, e, pivot);
+      if (other == -second) {
+        d = e;
+        break;
+      }
+    }
+    CADICAL_assert (d);
+
+    LOG (d, "second gate clause");
+    CADICAL_assert (!d->gate);
+    d->gate = true;
+    eliminator.gates.push_back (d);
+    eliminator.gatetype = EQUI;
+
+    break;
+  }
+
+DONE:
+  unmark_binary_literals (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and gates for 'pivot' with a long clause, in which the pivot occurs
+// positively.  Requires that all other literals in binary clauses with
+// 'pivot' are marked (through 'mark_binary_literals');
+
+void Internal::find_and_gate (Eliminator &eliminator, int pivot) {
+
+  if (!opts.elimands)
+    return;
+
+  CADICAL_assert (opts.elimsubst);
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  mark_binary_literals (eliminator, pivot);
+  if (unsat || val (pivot))
+    goto DONE;
+
+  for (const auto &c : occs (-pivot)) {
+
+    if (c->garbage)
+      continue;
+    if (c->size < 3)
+      continue;
+
+    bool all_literals_marked = true;
+    unsigned arity = 0;
+    int satisfied = 0;
+
+    for (const auto &lit : *c) {
+      if (lit == -pivot)
+        continue;
+      CADICAL_assert (lit != pivot);
+      signed char tmp = val (lit);
+      if (tmp < 0)
+        continue;
+      if (tmp > 0) {
+        satisfied = lit;
+        break;
+      }
+      tmp = marked (lit);
+      if (tmp < 0) {
+        arity++;
+        continue;
+      }
+      all_literals_marked = false;
+      break;
+    }
+
+    if (!all_literals_marked)
+      continue;
+
+    if (satisfied) {
+      LOG (c, "satisfied by %d candidate base clause", satisfied);
+      mark_garbage (c);
+      continue;
+    }
+
+#ifdef LOGGING
+    if (opts.log) {
+      Logger::print_log_prefix (this);
+      tout.magenta ();
+      printf ("found arity %u AND gate %d = ", arity, -pivot);
+      bool first = true;
+      for (const auto &lit : *c) {
+        if (lit == -pivot)
+          continue;
+        CADICAL_assert (lit != pivot);
+        if (!first)
+          fputs (" & ", stdout);
+        printf ("%d", -lit);
+        first = false;
+      }
+      fputc ('\n', stdout);
+      tout.normal ();
+      fflush (stdout);
+    }
+#endif
+    stats.elimands++;
+    stats.elimgates++;
+    eliminator.gatetype = AND;
+
+    (void) arity;
+    CADICAL_assert (!c->gate);
+    c->gate = true;
+    eliminator.gates.push_back (c);
+    for (const auto &lit : *c) {
+      if (lit == -pivot)
+        continue;
+      CADICAL_assert (lit != pivot);
+      signed char tmp = val (lit);
+      if (tmp < 0)
+        continue;
+      CADICAL_assert (!tmp);
+      CADICAL_assert (marked (lit) < 0);
+      marks[vidx (lit)] *= 2;
+    }
+
+    unsigned count = 0;
+    for (const auto &d : occs (pivot)) {
+      if (d->garbage)
+        continue;
+      const int other =
+          second_literal_in_binary_clause (eliminator, d, pivot);
+      if (!other)
+        continue;
+      const int tmp = marked (other);
+      if (tmp != 2)
+        continue;
+      LOG (d, "AND gate binary side clause");
+      CADICAL_assert (!d->gate);
+      d->gate = true;
+      eliminator.gates.push_back (d);
+      count++;
+    }
+    CADICAL_assert (count >= arity);
+    (void) count;
+
+    break;
+  }
+
+DONE:
+  unmark_binary_literals (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and extract ternary clauses.
+
+bool Internal::get_ternary_clause (Clause *d, int &a, int &b, int &c) {
+  if (d->garbage)
+    return false;
+  if (d->size < 3)
+    return false;
+  int found = 0;
+  a = b = c = 0;
+  for (const auto &lit : *d) {
+    if (val (lit))
+      continue;
+    if (++found == 1)
+      a = lit;
+    else if (found == 2)
+      b = lit;
+    else if (found == 3)
+      c = lit;
+    else
+      return false;
+  }
+  return found == 3;
+}
+
+// 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;
+  int found = 0;
+  for (const auto &lit : *d) {
+    if (val (lit))
+      continue;
+    if (a != lit && b != lit && c != lit)
+      return false;
+    found++;
+  }
+  return found == 3;
+}
+
+Clause *Internal::find_ternary_clause (int a, int b, int c) {
+  if (occs (b).size () > occs (c).size ())
+    swap (b, c);
+  if (occs (a).size () > occs (b).size ())
+    swap (a, b);
+  for (auto d : occs (a))
+    if (match_ternary_clause (d, a, b, c))
+      return d;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find if-then-else gate.
+
+void Internal::find_if_then_else (Eliminator &eliminator, int pivot) {
+
+  if (!opts.elimites)
+    return;
+
+  CADICAL_assert (opts.elimsubst);
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  const Occs &os = occs (pivot);
+  const auto end = os.end ();
+  for (auto i = os.begin (); i != end; i++) {
+    Clause *di = *i;
+    int ai, bi, ci;
+    if (!get_ternary_clause (di, ai, bi, ci))
+      continue;
+    if (bi == pivot)
+      swap (ai, bi);
+    if (ci == pivot)
+      swap (ai, ci);
+    CADICAL_assert (ai == pivot);
+    for (auto j = i + 1; j != end; j++) {
+      Clause *dj = *j;
+      int aj, bj, cj;
+      if (!get_ternary_clause (dj, aj, bj, cj))
+        continue;
+      if (bj == pivot)
+        swap (aj, bj);
+      if (cj == pivot)
+        swap (aj, cj);
+      CADICAL_assert (aj == pivot);
+      if (abs (bi) == abs (cj))
+        swap (bj, cj);
+      if (abs (ci) == abs (cj))
+        continue;
+      if (bi != -bj)
+        continue;
+      Clause *d1 = find_ternary_clause (-pivot, bi, -ci);
+      if (!d1)
+        continue;
+      Clause *d2 = find_ternary_clause (-pivot, bj, -cj);
+      if (!d2)
+        continue;
+      LOG (di, "1st if-then-else");
+      LOG (dj, "2nd if-then-else");
+      LOG (d1, "3rd if-then-else");
+      LOG (d2, "4th if-then-else");
+      LOG ("found ITE gate %d == (%d ? %d : %d)", pivot, -bi, -ci, -cj);
+      CADICAL_assert (!di->gate);
+      CADICAL_assert (!dj->gate);
+      CADICAL_assert (!d1->gate);
+      CADICAL_assert (!d2->gate);
+      di->gate = true;
+      dj->gate = true;
+      d1->gate = true;
+      d2->gate = true;
+      eliminator.gates.push_back (di);
+      eliminator.gates.push_back (dj);
+      eliminator.gates.push_back (d1);
+      eliminator.gates.push_back (d2);
+      stats.elimgates++;
+      stats.elimites++;
+      eliminator.gatetype = ITE;
+      return;
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and extract clause.
+
+bool Internal::get_clause (Clause *c, vector<int> &l) {
+  if (c->garbage)
+    return false;
+  l.clear ();
+  for (const auto &lit : *c) {
+    if (val (lit) < 0)
+      continue;
+    if (val (lit) > 0) {
+      l.clear ();
+      return false;
+    }
+    l.push_back (lit);
+  }
+  return true;
+}
+
+// Check whether 'c' contains only the literals in 'l'.
+
+bool Internal::is_clause (Clause *c, const vector<int> &lits) {
+  if (c->garbage)
+    return false;
+  int size = lits.size ();
+  if (c->size < size)
+    return false;
+  int found = 0;
+  for (const auto &lit : *c) {
+    if (val (lit) < 0)
+      continue;
+    if (val (lit) > 0)
+      return false;
+    const auto it = find (lits.begin (), lits.end (), lit);
+    if (it == lits.end ())
+      return false;
+    if (++found > size)
+      return false;
+  }
+  return found == size;
+}
+
+Clause *Internal::find_clause (const vector<int> &lits) {
+  int best = 0;
+  size_t len = 0;
+  for (const auto &lit : lits) {
+    size_t l = occs (lit).size ();
+    if (best && l >= len)
+      continue;
+    len = l, best = lit;
+  }
+  for (auto c : occs (best))
+    if (is_clause (c, lits))
+      return c;
+  return 0;
+}
+
+void Internal::find_xor_gate (Eliminator &eliminator, int pivot) {
+
+  if (!opts.elimxors)
+    return;
+
+  CADICAL_assert (opts.elimsubst);
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  vector<int> lits;
+
+  for (auto d : occs (pivot)) {
+
+    if (!get_clause (d, lits))
+      continue;
+
+    const int size = lits.size (); // clause size
+    const int arity = size - 1;    // arity of XOR
+
+    if (size < 3)
+      continue;
+    if (arity > opts.elimxorlim)
+      continue;
+
+    CADICAL_assert (eliminator.gates.empty ());
+
+    unsigned needed = (1u << arity) - 1; // additional clauses
+    unsigned signs = 0;                  // literals to negate
+
+    do {
+      const unsigned prev = signs;
+      while (parity (++signs))
+        ;
+      for (int j = 0; j < size; j++) {
+        const unsigned bit = 1u << j;
+        int lit = lits[j];
+        if ((prev & bit) != (signs & bit))
+          lits[j] = lit = -lit;
+      }
+      Clause *e = find_clause (lits);
+      if (!e)
+        break;
+      eliminator.gates.push_back (e);
+    } while (--needed);
+
+    if (needed) {
+      eliminator.gates.clear ();
+      continue;
+    }
+
+    eliminator.gates.push_back (d);
+    CADICAL_assert (eliminator.gates.size () == (1u << arity));
+
+#ifdef LOGGING
+    if (opts.log) {
+      Logger::print_log_prefix (this);
+      tout.magenta ();
+      printf ("found arity %u XOR gate %d = ", arity, -pivot);
+      bool first = true;
+      for (const auto &lit : *d) {
+        if (lit == pivot)
+          continue;
+        CADICAL_assert (lit != -pivot);
+        if (!first)
+          fputs (" ^ ", stdout);
+        printf ("%d", lit);
+        first = false;
+      }
+      fputc ('\n', stdout);
+      tout.normal ();
+      fflush (stdout);
+    }
+#endif
+    stats.elimgates++;
+    stats.elimxors++;
+    const auto end = eliminator.gates.end ();
+    auto j = eliminator.gates.begin ();
+    for (auto i = j; i != end; i++) {
+      Clause *e = *i;
+      if (e->gate)
+        continue;
+      e->gate = true;
+      LOG (e, "contributing");
+      *j++ = e;
+    }
+    eliminator.gates.resize (j - eliminator.gates.begin ());
+    eliminator.gatetype = XOR;
+    break;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find a gate for 'pivot'.  If such a gate is found, the gate clauses are
+// marked and pushed on the stack of gates.  Further hyper unary resolution
+// might detect units, which are propagated.  This might assign the pivot or
+// even produce the empty clause.
+
+void Internal::find_gate_clauses (Eliminator &eliminator, int pivot) {
+  if (!opts.elimsubst)
+    return;
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+
+  CADICAL_assert (eliminator.gates.empty ());
+
+  find_equivalence (eliminator, pivot);
+  find_and_gate (eliminator, pivot);
+  find_and_gate (eliminator, -pivot);
+  find_if_then_else (eliminator, pivot);
+  find_xor_gate (eliminator, pivot);
+  find_definition (eliminator, pivot);
+}
+
+void Internal::unmark_gate_clauses (Eliminator &eliminator) {
+  LOG ("unmarking %zd gate clauses", eliminator.gates.size ());
+  for (const auto &c : eliminator.gates) {
+    CADICAL_assert (c->gate);
+    c->gate = false;
+  }
+  eliminator.gates.clear ();
+  eliminator.definition_unit = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_idruptracer.cpp b/src/sat/cadical/cadical_idruptracer.cpp
new file mode 100644
index 000000000..ec6467163
--- /dev/null
+++ b/src/sat/cadical/cadical_idruptracer.cpp
@@ -0,0 +1,572 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+IdrupTracer::IdrupTracer (Internal *i, File *f, bool b)
+    : internal (i), file (f), binary (b), num_clauses (0), size_clauses (0),
+      clauses (0), last_hash (0), last_id (0), last_clause (0)
+#ifndef CADICAL_QUIET
+      ,
+      added (0), deleted (0)
+#endif
+{
+  (void) internal;
+
+  // Initialize random number table for hash function.
+  //
+  Random random (42);
+  for (unsigned n = 0; n < num_nonces; n++) {
+    uint64_t nonce = random.next ();
+    if (!(nonce & 1))
+      nonce++;
+    CADICAL_assert (nonce), CADICAL_assert (nonce & 1);
+    nonces[n] = nonce;
+  }
+#ifndef CADICAL_NDEBUG
+  binary = b;
+#else
+  (void) b;
+#endif
+  piping = file->piping ();
+}
+
+void IdrupTracer::connect_internal (Internal *i) {
+  internal = i;
+  file->connect_internal (internal);
+  LOG ("IDRUP TRACER connected to internal");
+}
+
+IdrupTracer::~IdrupTracer () {
+  LOG ("IDRUP TRACER delete");
+  delete file;
+  for (size_t i = 0; i < size_clauses; i++)
+    for (IdrupClause *c = clauses[i], *next; c; c = next)
+      next = c->next, delete_clause (c);
+  delete[] clauses;
+}
+
+/*------------------------------------------------------------------------*/
+
+void IdrupTracer::enlarge_clauses () {
+  CADICAL_assert (num_clauses == size_clauses);
+  const uint64_t new_size_clauses = size_clauses ? 2 * size_clauses : 1;
+  LOG ("IDRUP Tracer enlarging clauses of tracer from %" PRIu64
+       " to %" PRIu64,
+       (uint64_t) size_clauses, (uint64_t) new_size_clauses);
+  IdrupClause **new_clauses;
+  new_clauses = new IdrupClause *[new_size_clauses];
+  clear_n (new_clauses, new_size_clauses);
+  for (uint64_t i = 0; i < size_clauses; i++) {
+    for (IdrupClause *c = clauses[i], *next; c; c = next) {
+      next = c->next;
+      const uint64_t h = reduce_hash (c->hash, new_size_clauses);
+      c->next = new_clauses[h];
+      new_clauses[h] = c;
+    }
+  }
+  delete[] clauses;
+  clauses = new_clauses;
+  size_clauses = new_size_clauses;
+}
+
+IdrupClause *IdrupTracer::new_clause () {
+  const size_t size = imported_clause.size ();
+  CADICAL_assert (size <= UINT_MAX);
+  const int off = size ? -1 : 0;
+  const size_t bytes = sizeof (IdrupClause) + (size - off) * sizeof (int);
+  IdrupClause *res = (IdrupClause *) new char[bytes];
+  res->next = 0;
+  res->hash = last_hash;
+  res->id = last_id;
+  res->size = size;
+  int *literals = res->literals, *p = literals;
+  for (const auto &lit : imported_clause) {
+    *p++ = lit;
+  }
+  last_clause = res;
+  num_clauses++;
+  return res;
+}
+
+void IdrupTracer::delete_clause (IdrupClause *c) {
+  CADICAL_assert (c);
+  num_clauses--;
+  delete[] (char *) c;
+}
+
+uint64_t IdrupTracer::reduce_hash (uint64_t hash, uint64_t size) {
+  CADICAL_assert (size > 0);
+  unsigned shift = 32;
+  uint64_t res = hash;
+  while ((((uint64_t) 1) << shift) > size) {
+    res ^= res >> shift;
+    shift >>= 1;
+  }
+  res &= size - 1;
+  CADICAL_assert (res < size);
+  return res;
+}
+
+uint64_t IdrupTracer::compute_hash (const int64_t id) {
+  CADICAL_assert (id > 0);
+  unsigned j = id % num_nonces;
+  uint64_t tmp = nonces[j] * (uint64_t) id;
+  return last_hash = tmp;
+}
+
+bool IdrupTracer::find_and_delete (const int64_t id) {
+  if (!num_clauses)
+    return false;
+  IdrupClause **res = 0, *c;
+  const uint64_t hash = compute_hash (id);
+  const uint64_t h = reduce_hash (hash, size_clauses);
+  for (res = clauses + h; (c = *res); res = &c->next) {
+    if (c->hash == hash && c->id == id) {
+      break;
+    }
+    if (!c->next)
+      return false;
+  }
+  if (!c)
+    return false;
+  CADICAL_assert (c && res);
+  *res = c->next;
+  int *begin = c->literals;
+  for (size_t i = 0; i < c->size; i++) {
+    imported_clause.push_back (begin[i]);
+  }
+  delete_clause (c);
+  return true;
+}
+
+void IdrupTracer::insert () {
+  if (num_clauses == size_clauses)
+    enlarge_clauses ();
+  const uint64_t h = reduce_hash (compute_hash (last_id), size_clauses);
+  IdrupClause *c = new_clause ();
+  c->next = clauses[h];
+  clauses[h] = c;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void IdrupTracer::flush_if_piping () {
+  if (piping)
+    file->flush ();
+}
+
+inline void IdrupTracer::put_binary_zero () {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  file->put ((unsigned char) 0);
+}
+
+inline void IdrupTracer::put_binary_lit (int lit) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  CADICAL_assert (lit != INT_MIN);
+  unsigned x = 2 * abs (lit) + (lit < 0);
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+inline void IdrupTracer::put_binary_id (int64_t id, bool can_be_negative) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  uint64_t x = abs (id);
+  if (can_be_negative) {
+    x = 2 * x + (id < 0);
+  }
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+/*------------------------------------------------------------------------*/
+
+void IdrupTracer::idrup_add_restored_clause (const vector<int> &clause) {
+  if (binary)
+    file->put ('r');
+  else
+    file->put ("r ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  // flush_if_piping ();
+}
+
+void IdrupTracer::idrup_add_derived_clause (const vector<int> &clause) {
+  if (binary)
+    file->put ('l');
+  else
+    file->put ("l ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  // flush_if_piping ();
+}
+
+void IdrupTracer::idrup_add_original_clause (const vector<int> &clause) {
+  if (binary)
+    file->put ('i');
+  else
+    file->put ("i ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  // flush_if_piping ();
+}
+
+void IdrupTracer::idrup_delete_clause (int64_t id,
+                                       const vector<int> &clause) {
+  if (find_and_delete (id)) {
+    CADICAL_assert (imported_clause.empty ());
+    if (binary)
+      file->put ('w');
+    else
+      file->put ("w ");
+#ifndef CADICAL_QUIET
+    weakened++;
+#endif
+  } else {
+    if (binary)
+      file->put ('d');
+    else
+      file->put ("d ");
+#ifndef CADICAL_QUIET
+    deleted++;
+#endif
+  }
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  // flush_if_piping ();
+}
+
+void IdrupTracer::idrup_conclude_and_delete (
+    const vector<int64_t> &conclusion) {
+  uint64_t size = conclusion.size ();
+  if (size > 1) {
+    if (binary) {
+      file->put ('U');
+      put_binary_id (size);
+    } else {
+      file->put ("U ");
+      file->put (size), file->put ("\n");
+    }
+  }
+  for (auto &id : conclusion) {
+    if (binary)
+      file->put ('u');
+    else
+      file->put ("u ");
+    (void) find_and_delete (id);
+    for (const auto &external_lit : imported_clause) {
+      // flip sign...
+      const auto not_elit = -external_lit;
+      if (binary)
+        put_binary_lit (not_elit);
+      else
+        file->put (not_elit), file->put (' ');
+    }
+    if (binary)
+      put_binary_zero ();
+    else
+      file->put ("0\n");
+    imported_clause.clear ();
+  }
+  flush_if_piping ();
+}
+
+void IdrupTracer::idrup_report_status (int status) {
+  if (binary)
+    file->put ('s');
+  else
+    file->put ("s ");
+  if (status == SATISFIABLE)
+    file->put ("SATISFIABLE");
+  else if (status == UNSATISFIABLE)
+    file->put ("UNSATISFIABLE");
+  else
+    file->put ("UNKNOWN");
+  if (!binary)
+    file->put ("\n");
+  flush_if_piping ();
+}
+
+void IdrupTracer::idrup_conclude_sat (const vector<int> &model) {
+  if (binary)
+    file->put ('m');
+  else
+    file->put ("m ");
+  for (auto &lit : model) {
+    if (binary)
+      put_binary_lit (lit);
+    else
+      file->put (lit), file->put (' ');
+  }
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  flush_if_piping ();
+}
+
+void IdrupTracer::idrup_conclude_unknown (const vector<int> &trail) {
+  if (binary)
+    file->put ('e');
+  else
+    file->put ("e ");
+  for (auto &lit : trail) {
+    if (binary)
+      put_binary_lit (lit);
+    else
+      file->put (lit), file->put (' ');
+  }
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  flush_if_piping ();
+}
+
+void IdrupTracer::idrup_solve_query () {
+  if (binary)
+    file->put ('q');
+  else
+    file->put ("q ");
+  for (auto &lit : assumptions) {
+    if (binary)
+      put_binary_lit (lit);
+    else
+      file->put (lit), file->put (' ');
+  }
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  flush_if_piping ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void IdrupTracer::add_derived_clause (int64_t, bool,
+                                      const vector<int> &clause,
+                                      const vector<int64_t> &) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG (clause, "IDRUP TRACER tracing addition of derived clause");
+  idrup_add_derived_clause (clause);
+#ifndef CADICAL_QUIET
+  added++;
+#endif
+}
+
+void IdrupTracer::add_assumption_clause (int64_t id,
+                                         const vector<int> &clause,
+                                         const vector<int64_t> &) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG (clause, "IDRUP TRACER tracing addition of assumption clause");
+  for (auto &lit : clause)
+    imported_clause.push_back (lit);
+  last_id = id;
+  insert ();
+  imported_clause.clear ();
+}
+
+void IdrupTracer::delete_clause (int64_t id, bool,
+                                 const vector<int> &clause) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG ("IDRUP TRACER tracing deletion of clause[%" PRId64 "]", id);
+  idrup_delete_clause (id, clause);
+}
+
+void IdrupTracer::weaken_minus (int64_t id, const vector<int> &) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG ("IDRUP TRACER tracing weaken minus of clause[%" PRId64 "]", id);
+  last_id = id;
+  insert ();
+#ifndef CADICAL_QUIET
+  weakened++;
+#endif
+}
+
+void IdrupTracer::conclude_unsat (ConclusionType,
+                                  const vector<int64_t> &conclusion) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG (conclusion, "IDRUP TRACER tracing conclusion of clause(s)");
+  idrup_conclude_and_delete (conclusion);
+}
+
+void IdrupTracer::add_original_clause (int64_t id, bool,
+                                       const vector<int> &clause,
+                                       bool restored) {
+  if (file->closed ())
+    return;
+  if (!restored) {
+    LOG (clause, "IDRUP TRACER tracing addition of original clause");
+#ifndef CADICAL_QUIET
+    original++;
+#endif
+    return idrup_add_original_clause (clause);
+  }
+  CADICAL_assert (restored);
+  if (find_and_delete (id)) {
+    LOG (clause,
+         "IDRUP TRACER the clause was not yet weakened, so no restore");
+    return;
+  }
+  LOG (clause, "IDRUP TRACER tracing addition of restored clause");
+  idrup_add_restored_clause (clause);
+#ifndef CADICAL_QUIET
+  restore++;
+#endif
+}
+
+void IdrupTracer::report_status (int status, int64_t) {
+  if (file->closed ())
+    return;
+  LOG ("IDRUP TRACER tracing report of status %d", status);
+  idrup_report_status (status);
+}
+
+void IdrupTracer::conclude_sat (const vector<int> &model) {
+  if (file->closed ())
+    return;
+  LOG (model, "IDRUP TRACER tracing conclusion of model");
+  idrup_conclude_sat (model);
+}
+
+void IdrupTracer::conclude_unknown (const vector<int> &trail) {
+  if (file->closed ())
+    return;
+  LOG (trail, "IDRUP TRACER tracing conclusion of unknown state");
+  idrup_conclude_unknown (trail);
+}
+
+void IdrupTracer::solve_query () {
+  if (file->closed ())
+    return;
+  LOG (assumptions, "IDRUP TRACER tracing solve query with assumptions");
+  idrup_solve_query ();
+#ifndef CADICAL_QUIET
+  solved++;
+#endif
+}
+
+void IdrupTracer::add_assumption (int lit) {
+  LOG ("IDRUP TRACER tracing addition of assumption %d", lit);
+  assumptions.push_back (lit);
+}
+
+void IdrupTracer::reset_assumptions () {
+  LOG (assumptions, "IDRUP TRACER tracing reset of assumptions");
+  assumptions.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+bool IdrupTracer::closed () { return file->closed (); }
+
+#ifndef CADICAL_QUIET
+
+void IdrupTracer::print_statistics () {
+  // TODO complete this.
+  uint64_t bytes = file->bytes ();
+  uint64_t total = added + deleted + weakened + restore + original;
+  MSG ("LIDRUP %" PRId64 " original clauses %.2f%%", original,
+       percent (original, total));
+  MSG ("LIDRUP %" PRId64 " learned clauses %.2f%%", added,
+       percent (added, total));
+  MSG ("LIDRUP %" PRId64 " deleted clauses %.2f%%", deleted,
+       percent (deleted, total));
+  MSG ("LIDRUP %" PRId64 " weakened clauses %.2f%%", weakened,
+       percent (weakened, total));
+  MSG ("LIDRUP %" PRId64 " restored clauses %.2f%%", restore,
+       percent (restore, total));
+  MSG ("LIDRUP %" PRId64 " queries %.2f", solved, relative (solved, total));
+  MSG ("IDRUP %" PRId64 " bytes (%.2f MB)", bytes,
+       bytes / (double) (1 << 20));
+}
+
+#endif
+
+void IdrupTracer::close (bool print) {
+  CADICAL_assert (!closed ());
+  file->close ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("IDRUP proof file '%s' closed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+void IdrupTracer::flush (bool print) {
+  CADICAL_assert (!closed ());
+  file->flush ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("IDRUP proof file '%s' flushed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_instantiate.cpp b/src/sat/cadical/cadical_instantiate.cpp
new file mode 100644
index 000000000..2c34015b2
--- /dev/null
+++ b/src/sat/cadical/cadical_instantiate.cpp
@@ -0,0 +1,371 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This provides an implementation of variable instantiation, a technique
+// for removing literals with few occurrence (see also 'instantiate.hpp').
+
+/*------------------------------------------------------------------------*/
+
+// Triggered at the end of a variable elimination round ('elim_round').
+
+void Internal::collect_instantiation_candidates (
+    Instantiator &instantiator) {
+  CADICAL_assert (occurring ());
+  for (auto idx : vars) {
+    if (frozen (idx))
+      continue;
+    if (!active (idx))
+      continue;
+    if (flags (idx).elim)
+      continue; // BVE attempt pending
+    for (int sign = -1; sign <= 1; sign += 2) {
+      const int lit = sign * idx;
+      if (noccs (lit) > opts.instantiateocclim)
+        continue;
+      Occs &os = occs (lit);
+      for (const auto &c : os) {
+        if (c->garbage)
+          continue;
+        if (opts.instantiateonce && c->instantiated)
+          continue;
+        if (c->size < opts.instantiateclslim)
+          continue;
+        bool satisfied = false;
+        int unassigned = 0;
+        for (const auto &other : *c) {
+          const signed char tmp = val (other);
+          if (tmp > 0)
+            satisfied = true;
+          if (!tmp)
+            unassigned++;
+        }
+        if (satisfied)
+          continue;
+        if (unassigned < 3)
+          continue; // avoid learning units
+        size_t negoccs = occs (-lit).size ();
+        LOG (c,
+             "instantiation candidate literal %d "
+             "with %zu negative occurrences in",
+             lit, negoccs);
+        instantiator.candidate (lit, c, c->size, negoccs);
+      }
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Specialized propagation and assignment routines for instantiation.
+
+inline void Internal::inst_assign (int lit) {
+  LOG ("instantiate assign %d", lit);
+  CADICAL_assert (!val (lit));
+  CADICAL_assert ((int) num_assigned < max_var);
+  num_assigned++;
+  set_val (lit, 1);
+  trail.push_back (lit);
+}
+
+// Conflict analysis is only needed to do valid resolution proofs.
+// We remember propagated clauses in order of assignment (in inst_chain)
+// which allows us to do a variant of conflict analysis if the instantiation
+// attempt succeeds.
+//
+bool Internal::inst_propagate () { // Adapted from 'propagate'.
+  START (propagate);
+  int64_t before = propagated;
+  bool ok = true;
+  while (ok && propagated != trail.size ()) {
+    const int lit = -trail[propagated++];
+    LOG ("instantiate propagating %d", -lit);
+    Watches &ws = watches (lit);
+    const const_watch_iterator eow = ws.end ();
+    const_watch_iterator i = ws.begin ();
+    watch_iterator j = ws.begin ();
+    while (i != eow) {
+      const Watch w = *j++ = *i++;
+      const signed char b = val (w.blit);
+      if (b > 0)
+        continue;
+      if (w.binary ()) {
+        if (b < 0) {
+          ok = false;
+          LOG (w.clause, "conflict");
+          if (lrat) {
+            inst_chain.push_back (w.clause);
+          }
+          break;
+        } else {
+          if (lrat) {
+            inst_chain.push_back (w.clause);
+          }
+          inst_assign (w.blit);
+        }
+      } else {
+        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 {
+          const int size = w.clause->size;
+          const const_literal_iterator end = lits + size;
+          const literal_iterator middle = lits + w.clause->pos;
+          literal_iterator k = middle;
+          signed char v = -1;
+          int r = 0;
+          while (k != end && (v = val (r = *k)) < 0)
+            k++;
+          if (v < 0) {
+            k = lits + 2;
+            CADICAL_assert (w.clause->pos <= size);
+            while (k != middle && (v = val (r = *k)) < 0)
+              k++;
+          }
+          w.clause->pos = k - lits;
+          CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
+          if (v > 0) {
+            j[-1].blit = r;
+          } else if (!v) {
+            LOG (w.clause, "unwatch %d in", r);
+            lits[1] = r;
+            *k = lit;
+            watch_literal (r, lit, w.clause);
+            j--;
+          } else if (!u) {
+            CADICAL_assert (v < 0);
+            if (lrat) {
+              inst_chain.push_back (w.clause);
+            }
+            inst_assign (other);
+          } else {
+            CADICAL_assert (u < 0);
+            CADICAL_assert (v < 0);
+            if (lrat) {
+              inst_chain.push_back (w.clause);
+            }
+            LOG (w.clause, "conflict");
+            ok = false;
+            break;
+          }
+        }
+      }
+    }
+    if (j != i) {
+      while (i != eow)
+        *j++ = *i++;
+      ws.resize (j - ws.begin ());
+    }
+  }
+  int64_t delta = propagated - before;
+  stats.propagations.instantiate += delta;
+  STOP (propagate);
+  return ok;
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the instantiation attempt.
+
+bool Internal::instantiate_candidate (int lit, Clause *c) {
+  stats.instried++;
+  if (c->garbage)
+    return false;
+  CADICAL_assert (!level);
+  bool found = false, satisfied = false, inactive = false;
+  int unassigned = 0;
+  for (const auto &other : *c) {
+    if (other == lit)
+      found = true;
+    const signed char tmp = val (other);
+    if (tmp > 0) {
+      satisfied = true;
+      break;
+    }
+    if (!tmp && !active (other)) {
+      inactive = true;
+      break;
+    }
+    if (!tmp)
+      unassigned++;
+  }
+  if (!found)
+    return false;
+  if (inactive)
+    return false;
+  if (satisfied)
+    return false;
+  if (unassigned < 3)
+    return false;
+  size_t before = trail.size ();
+  CADICAL_assert (propagated == before);
+  CADICAL_assert (active (lit));
+  CADICAL_assert (inst_chain.empty ());
+  LOG (c, "trying to instantiate %d in", lit);
+  CADICAL_assert (!c->garbage);
+  c->instantiated = true;
+  CADICAL_assert (lrat_chain.empty ());
+  level++;
+  inst_assign (lit); // Assume 'lit' to true.
+  for (const auto &other : *c) {
+    if (other == lit)
+      continue;
+    const signed char tmp = val (other);
+    if (tmp) {
+      CADICAL_assert (tmp < 0);
+      continue;
+    }
+    inst_assign (-other); // Assume other to false.
+  }
+  bool ok = inst_propagate ();  // Propagate.
+  CADICAL_assert (lrat_chain.empty ()); // chain will be built here
+  if (ok) {
+    inst_chain.clear ();
+  } else if (lrat) { // analyze conflict for lrat
+    CADICAL_assert (inst_chain.size ());
+    Clause *reason = inst_chain.back ();
+    inst_chain.pop_back ();
+    lrat_chain.push_back (reason->id);
+    for (const auto &other : *reason) {
+      Flags &f = flags (other);
+      CADICAL_assert (!f.seen);
+      f.seen = true;
+      analyzed.push_back (other);
+    }
+  }
+  while (trail.size () > before) { // Backtrack.
+    const int other = trail.back ();
+    LOG ("instantiate unassign %d", other);
+    trail.pop_back ();
+    CADICAL_assert (val (other) > 0);
+    num_assigned--;
+    set_val (other, 0);
+    // this is a variant of conflict analysis which is only needed for lrat
+    if (!ok && inst_chain.size () && lrat) {
+      Flags &f = flags (other);
+      if (f.seen) {
+        Clause *reason = inst_chain.back ();
+        lrat_chain.push_back (reason->id);
+        for (const auto &other : *reason) {
+          Flags &f = flags (other);
+          if (f.seen)
+            continue;
+          f.seen = true;
+          analyzed.push_back (other);
+        }
+        f.seen = false;
+      }
+      inst_chain.pop_back ();
+    }
+  }
+  CADICAL_assert (inst_chain.empty ());
+  // post processing step for lrat
+  if (!ok && lrat) {
+    if (flags (lit).seen)
+      lrat_chain.push_back (c->id);
+    for (const auto &other : *c) {
+      Flags &f = flags (other);
+      f.seen = false;
+    }
+    for (int other : analyzed) {
+      Flags &f = flags (other);
+      if (!f.seen) {
+        f.seen = true;
+        continue;
+      }
+      int64_t id = unit_id (-other);
+      lrat_chain.push_back (id);
+    }
+    clear_analyzed_literals ();
+    reverse (lrat_chain.begin (), lrat_chain.end ());
+  }
+  CADICAL_assert (analyzed.empty ());
+  propagated = before;
+  CADICAL_assert (level == 1);
+  level = 0;
+  if (ok) {
+    CADICAL_assert (lrat_chain.empty ());
+    LOG ("instantiation failed");
+    return false;
+  }
+  unwatch_clause (c);
+  LOG (lrat_chain, "instantiate proof chain");
+  strengthen_clause (c, lit);
+  watch_clause (c);
+  lrat_chain.clear ();
+  CADICAL_assert (c->size > 1);
+  LOG ("instantiation succeeded");
+  stats.instantiated++;
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to instantiate all candidates collected before through the
+// 'collect_instantiation_candidates' routine.
+
+void Internal::instantiate (Instantiator &instantiator) {
+  CADICAL_assert (opts.instantiate);
+  START (instantiate);
+  stats.instrounds++;
+#ifndef CADICAL_QUIET
+  const int64_t candidates = instantiator.candidates.size ();
+  int64_t tried = 0;
+#endif
+  int64_t instantiated = 0;
+  init_watches ();
+  connect_watches ();
+  if (propagated < trail.size ()) {
+    if (!propagate ()) {
+      LOG ("propagation after connecting watches failed");
+      learn_empty_clause ();
+      CADICAL_assert (unsat);
+    }
+  }
+  PHASE ("instantiate", stats.instrounds,
+         "attempting to instantiate %" PRId64
+         " candidate literal clause pairs",
+         candidates);
+  while (!unsat && !terminated_asynchronously () &&
+         !instantiator.candidates.empty ()) {
+    Instantiator::Candidate cand = instantiator.candidates.back ();
+    instantiator.candidates.pop_back ();
+#ifndef CADICAL_QUIET
+    tried++;
+#endif
+    if (!active (cand.lit))
+      continue;
+    LOG (cand.clause,
+         "trying to instantiate %d with "
+         "%zd negative occurrences in",
+         cand.lit, cand.negoccs);
+    if (!instantiate_candidate (cand.lit, cand.clause))
+      continue;
+    instantiated++;
+    VERBOSE (2,
+             "instantiation %" PRId64 " (%.1f%%) succeeded "
+             "(%.1f%%) with %zd negative occurrences in size %d clause",
+             tried, percent (tried, candidates),
+             percent (instantiated, tried), cand.negoccs, cand.size);
+  }
+  PHASE ("instantiate", stats.instrounds,
+         "instantiated %" PRId64 " candidate successfully "
+         "out of %" PRId64 " tried %.1f%%",
+         instantiated, tried, percent (instantiated, tried));
+  report ('I', !instantiated);
+  reset_watches ();
+  STOP (instantiate);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_internal.cpp b/src/sat/cadical/cadical_internal.cpp
new file mode 100644
index 000000000..abe18c59c
--- /dev/null
+++ b/src/sat/cadical/cadical_internal.cpp
@@ -0,0 +1,1196 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+static Clause external_reason_clause;
+
+Internal::Internal ()
+    : mode (SEARCH), unsat (false), iterating (false),
+      localsearching (false), lookingahead (false), preprocessing (false),
+      protected_reasons (false), force_saved_phase (false),
+      searching_lucky_phases (false), stable (false), reported (false),
+      external_prop (false), did_external_prop (false),
+      external_prop_is_lazy (true), forced_backt_allowed (false),
+
+      private_steps (false), rephased (0), vsize (0), max_var (0),
+      clause_id (0), original_id (0), reserved_ids (0), conflict_id (0),
+      saved_decisions (0), concluded (false), lrat (false), frat (false),
+      level (0), vals (0), score_inc (1.0), scores (this), conflict (0),
+      ignore (0), external_reason (&external_reason_clause),
+      newest_clause (0), force_no_backtrack (false),
+      from_propagator (false), ext_clause_forgettable (false),
+      tainted_literal (0), notified (0), probe_reason (0), propagated (0),
+      propagated2 (0), propergated (0), best_assigned (0),
+      target_assigned (0), no_conflict_until (0), unsat_constraint (false),
+      marked_failed (true), sweep_incomplete (false), citten (0),
+      num_assigned (0), proof (0), opts (this),
+#ifndef CADICAL_QUIET
+      profiles (this), force_phase_messages (false),
+#endif
+      arena (this), prefix ("c "), internal (this), external (0),
+      termination_forced (false), vars (this->max_var),
+      lits (this->max_var) {
+  control.push_back (Level (0, 0));
+
+  // The 'dummy_binary' is used in 'try_to_subsume_clause' to fake a real
+  // clause, which then can be used to subsume or strengthen the given
+  // clause in one routine for both binary and non binary clauses.  This
+  // fake binary clause is always kept non-redundant (and not-moved etc.)
+  // due to the following 'memset'.  Only literals will be changed.
+
+  // In a previous version we used local automatic allocated 'Clause' on the
+  // stack, which became incompatible with several compilers (see the
+  // discussion on flexible array member in 'Clause.cpp').
+
+  size_t bytes = Clause::bytes (2);
+  dummy_binary = (Clause *) new char[bytes];
+  memset (dummy_binary, 0, bytes);
+  dummy_binary->size = 2;
+}
+
+Internal::~Internal () {
+  // If a memory exception ocurred a profile might still be active.
+#ifndef CADICAL_QUIET
+#define PROFILE(NAME, LEVEL) \
+  if (PROFILE_ACTIVE (NAME)) \
+    STOP (NAME);
+  PROFILES
+#undef PROFILE
+#endif
+  delete[] (char *) dummy_binary;
+  for (const auto &c : clauses)
+    delete_clause (c);
+  if (proof)
+    delete proof;
+  for (auto &tracer : tracers)
+    delete tracer;
+  for (auto &filetracer : file_tracers)
+    delete filetracer;
+  for (auto &stattracer : stat_tracers)
+    delete stattracer;
+  if (vals) {
+    vals -= vsize;
+    delete[] vals;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Values in 'vals' can be accessed in the range '[-max_var,max_var]' that
+// is directly by a literal.  This is crucial for performance.  By shifting
+// the start of 'vals' appropriately, we achieve that negative offsets from
+// the start of 'vals' can be used.  We also need to set both values at
+// 'lit' and '-lit' during assignments.  In MiniSAT integer literals are
+// encoded, using the least significant bit as negation.  This avoids taking
+// the 'abs ()' (as in our solution) and thus also avoids a branch in the
+// hot-spot of the solver (clause traversal in propagation).  That solution
+// requires another (branch less) negation of the values though and
+// debugging is harder since literals occur only encoded in clauses.
+// The main draw-back of our solution is that we have to shift the memory
+// and access it through negative indices, which looks less clean (but still
+// as far I can tell is properly defined C / C++).   You might get a warning
+// by static analyzers though.  Clang with '--analyze' thought that this
+// idiom would generate a memory leak thus we use the following dummy.
+
+static signed char *ignore_clang_analyze_memory_leak_warning;
+
+void Internal::enlarge_vals (size_t new_vsize) {
+  signed char *new_vals;
+  const size_t bytes = 2u * new_vsize;
+  new_vals = new signed char[bytes]; // g++-4.8 does not like ... { 0 };
+  memset (new_vals, 0, bytes);
+  ignore_clang_analyze_memory_leak_warning = new_vals;
+  new_vals += new_vsize;
+
+  if (vals) {
+    memcpy (new_vals - max_var, vals - max_var, 2u * max_var + 1u);
+    vals -= vsize;
+    delete[] vals;
+  } else
+    CADICAL_assert (!vsize);
+  vals = new_vals;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::enlarge (int new_max_var) {
+  // New variables can be created that can invoke enlarge anytime (via calls
+  // during ipasir-up call-backs), thus assuming (!level) is not correct
+  size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) new_max_var;
+  while (new_vsize <= (size_t) new_max_var)
+    new_vsize *= 2;
+  LOG ("enlarge internal size from %zd to new size %zd", vsize, new_vsize);
+  // Ordered in the size of allocated memory (larger block first).
+  if (lrat || frat)
+    enlarge_zero (unit_clauses_idx, 2 * new_vsize);
+  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);
+  enlarge_zero (stab, new_vsize);
+  enlarge_init (ptab, 2 * new_vsize, -1);
+  enlarge_only (ftab, new_vsize);
+  enlarge_vals (new_vsize);
+  vsize = new_vsize;
+  if (external)
+    enlarge_zero (relevanttab, 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);
+  enlarge_zero (phases.min, new_vsize);
+  enlarge_zero (marks, new_vsize);
+}
+
+void Internal::init_vars (int new_max_var) {
+  if (new_max_var <= max_var)
+    return;
+  // New variables can be created that can invoke enlarge anytime (via calls
+  // during ipasir-up call-backs), thus assuming (!level) is not correct
+  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 CADICAL_NDEBUG
+  for (int64_t i = -new_max_var; i < -max_var; i++)
+    CADICAL_assert (!vals[i]);
+  for (unsigned i = max_var + 1; i <= (unsigned) new_max_var; i++)
+    CADICAL_assert (!vals[i]), CADICAL_assert (!btab[i]), CADICAL_assert (!gtab[i]);
+  for (uint64_t i = 2 * ((uint64_t) max_var + 1);
+       i <= 2 * (uint64_t) new_max_var + 1; i++)
+    CADICAL_assert (ptab[i] == -1);
+#endif
+  CADICAL_assert (!btab[0]);
+  int old_max_var = max_var;
+  max_var = new_max_var;
+  init_queue (old_max_var, new_max_var);
+  init_scores (old_max_var, new_max_var);
+  int initialized = new_max_var - old_max_var;
+  stats.vars += initialized;
+  stats.unused += initialized;
+  stats.inactive += initialized;
+  LOG ("finished initializing %d internal variables", initialized);
+}
+
+void Internal::add_original_lit (int lit) {
+  CADICAL_assert (abs (lit) <= max_var);
+  if (lit) {
+    original.push_back (lit);
+  } else {
+    const int64_t id =
+        original_id < reserved_ids ? ++original_id : ++clause_id;
+    if (proof) {
+      // Use the external form of the clause for printing in proof
+      // Externalize(internalized literal) != external literal
+      CADICAL_assert (!original.size () || !external->eclause.empty ());
+      proof->add_external_original_clause (id, false, external->eclause);
+    }
+    if (internal->opts.check &&
+        (internal->opts.checkwitness || internal->opts.checkfailed)) {
+      bool forgettable = from_propagator && ext_clause_forgettable;
+      if (forgettable && opts.check) {
+        CADICAL_assert (!original.size () || !external->eclause.empty ());
+
+        // First integer is the presence-flag (even if the clause is empty)
+        external->forgettable_original[id] = {1};
+
+        for (auto const &elit : external->eclause)
+          external->forgettable_original[id].push_back (elit);
+
+        LOG (external->eclause,
+             "clause added to external forgettable map:");
+      }
+    }
+
+    add_new_original_clause (id);
+    original.clear ();
+  }
+}
+
+void Internal::finish_added_clause_with_id (int64_t id, bool restore) {
+  if (proof) {
+    // Use the external form of the clause for printing in proof
+    // Externalize(internalized literal) != external literal
+    CADICAL_assert (!original.size () || !external->eclause.empty ());
+    proof->add_external_original_clause (id, false, external->eclause,
+                                         restore);
+  }
+  add_new_original_clause (id);
+  original.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::reserve_ids (int number) {
+  // return;
+  LOG ("reserving %d ids", number);
+  CADICAL_assert (number >= 0);
+  CADICAL_assert (!clause_id && !reserved_ids && !original_id);
+  clause_id = reserved_ids = number;
+  if (proof)
+    proof->begin_proof (reserved_ids);
+}
+
+/*------------------------------------------------------------------------*/
+
+#ifdef PROFILE_MODE
+
+// Separating these makes it easier to profile stable and unstable search.
+
+bool Internal::propagate_wrapper () {
+  if (stable)
+    return propagate_stable ();
+  else
+    return propagate_unstable ();
+}
+
+void Internal::analyze_wrapper () {
+  if (stable)
+    analyze_stable ();
+  else
+    analyze_unstable ();
+}
+
+int Internal::decide_wrapper () {
+  if (stable)
+    return decide_stable ();
+  else
+    return decide_unstable ();
+}
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+// This is the main CDCL loop with interleaved inprocessing.
+
+int Internal::cdcl_loop_with_inprocessing () {
+
+  int res = 0;
+
+  START (search);
+
+  if (stable) {
+    START (stable);
+    report ('[');
+  } else {
+    START (unstable);
+    report ('{');
+  }
+
+  while (!res) {
+    if (unsat)
+      res = 20;
+    else if (unsat_constraint)
+      res = 20;
+    else if (!propagate_wrapper ())
+      analyze_wrapper (); // propagate and analyze
+    else if (iterating)
+      iterate ();                               // report learned unit
+    else if (!external_propagate () || unsat) { // external propagation
+      if (unsat)
+        continue;
+      else
+        analyze ();
+    } else if (satisfied ()) { // found model
+      if (!external_check_solution () || unsat) {
+        if (unsat)
+          continue;
+        else
+          analyze ();
+      } else if (satisfied ())
+        res = 10;
+    } 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
+    else if (inprobing ())
+      inprobe (); // schedule of inprocessing
+    else if (ineliminating ())
+      elim (); // variable elimination
+    else if (compacting ())
+      compact (); // collect variables
+    else if (conditioning ())
+      condition (); // globally blocked clauses
+    else
+      res = decide (); // next decision
+  }
+
+  if (stable) {
+    STOP (stable);
+    report (']');
+  } else {
+    STOP (unstable);
+    report ('}');
+  }
+
+  STOP (search);
+
+  return res;
+}
+
+int Internal::propagate_assumptions () {
+  if (proof)
+    proof->solve_query ();
+  if (opts.ilb) {
+    if (opts.ilbassumptions)
+      sort_and_reuse_assumptions ();
+    stats.ilbtriggers++;
+    stats.ilbsuccess += (level > 0);
+    stats.levelsreused += level;
+    if (level) {
+      CADICAL_assert (control.size () > 1);
+      stats.literalsreused += num_assigned - control[1].trail;
+    }
+  }
+  init_search_limits ();
+  init_report_limits ();
+
+  int res = already_solved (); // root-level propagation is done here
+
+  int last_assumption_level = assumptions.size ();
+  if (constraint.size ())
+    last_assumption_level++;
+
+  if (!res) {
+    restore_clauses ();
+    while (!res) {
+      if (unsat)
+        res = 20;
+      else if (unsat_constraint)
+        res = 20;
+      else if (!propagate ()) {
+        // let analyze run to get failed assumptions
+        analyze ();
+      } else if (!external_propagate () || unsat) { // external propagation
+        if (unsat)
+          continue;
+        else
+          analyze ();
+      } else if (satisfied ()) { // found model
+        if (!external_check_solution () || unsat) {
+          if (unsat)
+            continue;
+          else
+            analyze ();
+        } else if (satisfied ())
+          res = 10;
+      } else if (search_limits_hit ())
+        break;                               // decision or conflict limit
+      else if (terminated_asynchronously ()) // externally terminated
+        break;
+      else {
+        if (level >= last_assumption_level)
+          break;
+        res = decide ();
+      }
+    }
+  }
+
+  if (unsat || unsat_constraint)
+    res = 20;
+
+  if (!res && satisfied ())
+    res = 10;
+
+  finalize (res);
+  reset_solving ();
+  report_solving (res);
+
+  return res;
+}
+
+void Internal::implied (std::vector<int> &entrailed) {
+  int last_assumption_level = assumptions.size ();
+  if (constraint.size ())
+    last_assumption_level++;
+  
+  size_t trail_limit = trail.size();
+  if (level > last_assumption_level) 
+    trail_limit = control[last_assumption_level + 1].trail;
+
+  for (size_t i = 0; i < trail_limit; i++)
+    entrailed.push_back (trail[i]);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Most of the limits are only initialized in the first 'solve' call and
+// increased as in a stand-alone non-incremental SAT call except for those
+// explicitly marked as being reset below.
+
+void Internal::init_report_limits () {
+  reported = false;
+  lim.report = 0;
+  lim.recompute_tier = 5000;
+}
+
+void Internal::init_preprocessing_limits () {
+
+  const bool incremental = lim.initialized;
+  if (incremental)
+    LOG ("reinitializing preprocessing limits incrementally");
+  else
+    LOG ("initializing preprocessing limits and increments");
+
+  const char *mode = 0;
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental)
+    mode = "keeping";
+  else {
+    last.elim.marked = -1;
+    lim.elim = stats.conflicts + scale (opts.elimint);
+    mode = "initial";
+  }
+  (void) mode;
+  LOG ("%s elim limit %" PRId64 " after %" PRId64 " conflicts", mode,
+       lim.elim, lim.elim - stats.conflicts);
+
+  // Initialize and reset elimination bounds in any case.
+
+  lim.elimbound = opts.elimboundmin;
+  LOG ("elimination bound %" PRId64 "", lim.elimbound);
+
+  /*----------------------------------------------------------------------*/
+
+  if (!incremental) {
+
+    last.ternary.marked = -1; // TODO this should not be 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 {
+    double delta = log10 (stats.added.irredundant);
+    delta = delta * delta;
+    lim.inprobe = stats.conflicts + opts.inprobeint * delta;
+    mode = "initial";
+  }
+  (void) mode;
+  LOG ("%s probe limit %" PRId64 " after %" PRId64 " conflicts", mode,
+       lim.inprobe, lim.inprobe - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  if (incremental)
+    mode = "keeping";
+  else {
+    lim.condition = stats.conflicts + opts.conditionint;
+    mode = "initial";
+  }
+  LOG ("%s condition limit %" PRId64 " increment %" PRId64, mode,
+       lim.condition, lim.condition - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  // Initial preprocessing rounds.
+
+  if (inc.preprocessing <= 0) {
+    lim.preprocessing = 0;
+    LOG ("no preprocessing");
+  } else {
+    lim.preprocessing = inc.preprocessing;
+    LOG ("limiting to %" PRId64 " 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 {
+    last.reduce.conflicts = -1;
+    lim.reduce = stats.conflicts + opts.reduceinit;
+    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);
+
+  /*----------------------------------------------------------------------*/
+
+  // Initialize or reset 'rephase' limits in any case.
+
+  lim.rephase = stats.conflicts + opts.rephaseint;
+  lim.rephased[0] = lim.rephased[1] = 0;
+  LOG ("new rephase limit %" PRId64 " after %" PRId64 " conflicts",
+       lim.rephase, lim.rephase - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  // Initialize or reset 'restart' limits in any case.
+
+  lim.restart = stats.conflicts + opts.restartint;
+  LOG ("new restart limit %" PRId64 " increment %" PRId64 "", lim.restart,
+       lim.restart - stats.conflicts);
+
+  /*----------------------------------------------------------------------*/
+
+  if (!incremental) {
+    stable = opts.stabilize && opts.stabilizeonly;
+    if (stable)
+      LOG ("starting in always forced stable phase");
+    else
+      LOG ("starting in default non-stable phase");
+    init_averages ();
+  } else if (opts.stabilize && opts.stabilizeonly) {
+    LOG ("keeping always forced stable phase");
+    CADICAL_assert (stable);
+  } else if (stable) {
+    LOG ("switching back to default non-stable phase");
+    stable = false;
+    swap_averages ();
+  } else
+    LOG ("keeping non-stable phase");
+
+  if (!incremental) {
+    inc.stabilize = 0;
+    lim.stabilize = stats.conflicts + opts.stabilizeinit;
+    LOG ("initial stabilize limit %" PRId64 " after %d conflicts",
+         lim.stabilize, (int) opts.stabilizeinit);
+  }
+
+  if (opts.stabilize && opts.reluctant) {
+    LOG ("new restart reluctant doubling sequence period %d",
+         opts.reluctant);
+    reluctant.enable (opts.reluctant, opts.reluctantmax);
+  } else
+    reluctant.disable ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Conflict and decision limits.
+
+  if (inc.conflicts < 0) {
+    lim.conflicts = -1;
+    LOG ("no limit on conflicts");
+  } else {
+    lim.conflicts = stats.conflicts + inc.conflicts;
+    LOG ("conflict limit after %" PRId64 " conflicts at %" PRId64
+         " conflicts",
+         inc.conflicts, lim.conflicts);
+  }
+
+  if (inc.decisions < 0) {
+    lim.decisions = -1;
+    LOG ("no limit on decisions");
+  } else {
+    lim.decisions = stats.decisions + inc.decisions;
+    LOG ("conflict limit after %" PRId64 " decisions at %" PRId64
+         " decisions",
+         inc.decisions, lim.decisions);
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  // Initial preprocessing rounds.
+
+  if (inc.localsearch <= 0) {
+    lim.localsearch = 0;
+    LOG ("no local search");
+  } else {
+    lim.localsearch = inc.localsearch;
+    LOG ("limiting to %" PRId64 " local search rounds", lim.localsearch);
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  lim.initialized = true;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::preprocess_round (int round) {
+  (void) round;
+  if (unsat)
+    return false;
+  if (!max_var)
+    return false;
+  START (preprocess);
+  struct {
+    int64_t vars, clauses;
+  } before, after;
+  before.vars = active ();
+  before.clauses = stats.current.irredundant;
+  stats.preprocessings++;
+  CADICAL_assert (!preprocessing);
+  preprocessing = true;
+  PHASE ("preprocessing", stats.preprocessings,
+         "starting round %d with %" PRId64 " variables and %" PRId64
+         " clauses",
+         round, before.vars, before.clauses);
+  int old_elimbound = lim.elimbound;
+  if (opts.inprobing)
+    inprobe (false);
+  if (opts.elim)
+    elim (false);
+  if (opts.condition)
+    condition (false);
+
+  after.vars = active ();
+  after.clauses = stats.current.irredundant;
+  CADICAL_assert (preprocessing);
+  preprocessing = false;
+  PHASE ("preprocessing", stats.preprocessings,
+         "finished round %d with %" PRId64 " variables and %" PRId64
+         " clauses",
+         round, after.vars, after.clauses);
+  STOP (preprocess);
+  report ('P');
+  if (unsat)
+    return false;
+  if (after.vars < before.vars)
+    return true;
+  if (old_elimbound < lim.elimbound)
+    return true;
+  return false;
+}
+
+// for now counts as one of the preprocessing rounds TODO: change this?
+void Internal::preprocess_quickly () {
+  if (unsat)
+    return;
+  if (!max_var)
+    return;
+  if (!opts.preprocesslight)
+    return;
+  START (preprocess);
+  struct {
+    int64_t vars, clauses;
+  } before, after;
+  before.vars = active ();
+  before.clauses = stats.current.irredundant;
+  // stats.preprocessings++;
+  CADICAL_assert (!preprocessing);
+  preprocessing = true;
+  PHASE ("preprocessing", stats.preprocessings,
+         "starting with %" PRId64 " variables and %" PRId64 " clauses",
+         before.vars, before.clauses);
+
+  if (extract_gates ())
+    decompose ();
+
+  if (sweep ())
+    decompose ();
+
+  if (opts.factor)
+    factor ();
+
+  if (opts.fastelim)
+    elimfast ();
+  // if (opts.condition)
+  // condition (false);
+  after.vars = active ();
+  after.clauses = stats.current.irredundant;
+  CADICAL_assert (preprocessing);
+  preprocessing = false;
+  PHASE ("preprocessing", stats.preprocessings,
+         "finished with %" PRId64 " variables and %" PRId64 " clauses",
+         after.vars, after.clauses);
+  STOP (preprocess);
+  report ('P');
+}
+
+int Internal::preprocess () {
+  preprocess_quickly ();
+  for (int i = 0; i < lim.preprocessing; i++)
+    if (!preprocess_round (i))
+      break;
+  if (unsat)
+    return 20;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::try_to_satisfy_formula_by_saved_phases () {
+  LOG ("satisfying formula by saved phases");
+  CADICAL_assert (!level);
+  CADICAL_assert (!force_saved_phase);
+  CADICAL_assert (propagated == trail.size ());
+  force_saved_phase = true;
+  if (external_prop) {
+    CADICAL_assert (!level);
+    LOG ("external notifications are turned off during preprocessing.");
+    private_steps = true;
+  }
+  int res = 0;
+  while (!res) {
+    if (satisfied ()) {
+      LOG ("formula indeed satisfied by saved phases");
+      res = 10;
+    } else if (decide ()) {
+      LOG ("inconsistent assumptions with redundant clauses and phases");
+      res = 20;
+    } else if (!propagate ()) {
+      LOG ("saved phases do not satisfy redundant clauses");
+      CADICAL_assert (level > 0);
+      backtrack ();
+      conflict = 0; // ignore conflict
+      CADICAL_assert (!res);
+      break;
+    }
+  }
+  CADICAL_assert (force_saved_phase);
+  force_saved_phase = false;
+  if (external_prop) {
+    private_steps = false;
+    LOG ("external notifications are turned back on.");
+    if (!level)
+      notify_assignments (); // In case fixed assignments were found.
+    else {
+      renotify_trail_after_local_search ();
+    }
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::produce_failed_assumptions () {
+  LOG ("producing failed assumptions");
+  CADICAL_assert (!level);
+  CADICAL_assert (!assumptions.empty ());
+  while (!unsat) {
+    CADICAL_assert (!satisfied ());
+    notify_assignments ();
+    if (decide ())
+      break;
+    while (!unsat && !propagate ())
+      analyze ();
+  }
+  notify_assignments ();
+  if (unsat)
+    LOG ("formula is actually unsatisfiable unconditionally");
+  else
+    LOG ("assumptions indeed failing");
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::local_search_round (int round) {
+
+  CADICAL_assert (round > 0);
+
+  if (unsat)
+    return false;
+  if (!max_var)
+    return false;
+
+  START_OUTER_WALK ();
+  CADICAL_assert (!localsearching);
+  localsearching = true;
+
+  // Determine propagation limit quadratically scaled with rounds.
+  //
+  int64_t limit = opts.walkmineff;
+  limit *= round;
+  if (LONG_MAX / round > limit)
+    limit *= round;
+  else
+    limit = LONG_MAX;
+
+  int res = walk_round (limit, true);
+
+  CADICAL_assert (localsearching);
+  localsearching = false;
+  STOP_OUTER_WALK ();
+
+  report ('L');
+
+  return res;
+}
+
+int Internal::local_search () {
+
+  if (unsat)
+    return 0;
+  if (!max_var)
+    return 0;
+  if (!opts.walk)
+    return 0;
+  if (constraint.size ())
+    return 0;
+
+  int res = 0;
+
+  for (int i = 1; !res && i <= lim.localsearch; i++)
+    res = local_search_round (i);
+
+  if (res == 10) {
+    LOG ("local search determined formula to be satisfiable");
+    CADICAL_assert (!stats.walk.minimum);
+    res = try_to_satisfy_formula_by_saved_phases ();
+  } else if (res == 20) {
+    LOG ("local search determined assumptions to be inconsistent");
+    CADICAL_assert (!assumptions.empty ());
+    produce_failed_assumptions ();
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// if preprocess_only is false and opts.ilb is true we do not preprocess
+// such that we do not have to backtrack to level 0.
+//
+int Internal::solve (bool preprocess_only) {
+  CADICAL_assert (clause.empty ());
+  START (solve);
+  if (proof)
+    proof->solve_query ();
+  if (opts.ilb) {
+    if (opts.ilbassumptions)
+      sort_and_reuse_assumptions ();
+    stats.ilbtriggers++;
+    stats.ilbsuccess += (level > 0);
+    stats.levelsreused += level;
+    if (level) {
+      CADICAL_assert (control.size () > 1);
+      stats.literalsreused += num_assigned - control[1].trail;
+    }
+    if (external->propagator)
+      renotify_trail_after_ilb ();
+  }
+  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 && preprocess_only && level)
+    backtrack ();
+  if (!res)
+    res = restore_clauses ();
+  if (!res || (res == 10 && external_prop)) {
+    init_preprocessing_limits ();
+    if (!preprocess_only)
+      init_search_limits ();
+  }
+  if (!preprocess_only) {
+    if (!res && !level)
+      res = local_search ();
+  }
+  if (!res && !level)
+    res = preprocess ();
+  if (!preprocess_only) {
+    if (!res && !level)
+      res = local_search ();
+    if (!res && !level)
+      res = lucky_phases ();
+    if (!res || (res == 10 && external_prop)) {
+      if (res == 10 && external_prop && level)
+        backtrack ();
+      res = cdcl_loop_with_inprocessing ();
+    }
+  }
+  finalize (res);
+  reset_solving ();
+  report_solving (res);
+  STOP (solve);
+  return res;
+}
+
+int Internal::already_solved () {
+  int res = 0;
+  if (unsat || unsat_constraint) {
+    LOG ("already inconsistent");
+    res = 20;
+  } else {
+    if (level && !opts.ilb)
+      backtrack ();
+    if (!level && !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");
+  }
+}
+
+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 ('+');
+    // remove_garbage_binaries ();
+    external->restore_clauses ();
+    internal->report ('r');
+    if (!unsat && !level && !propagate ()) {
+      LOG ("root level propagation after restore produces conflict");
+      learn_empty_clause ();
+      res = 20;
+    }
+  }
+  return res;
+}
+
+int Internal::lookahead () {
+  CADICAL_assert (clause.empty ());
+  START (lookahead);
+  CADICAL_assert (!lookingahead);
+  lookingahead = true;
+  if (external_prop) {
+    if (level) {
+      // Combining lookahead with external propagator is limited
+      // Note that lookahead_probing (); would also force backtrack anyway
+      backtrack ();
+    }
+    LOG ("external notifications are turned off during preprocessing.");
+    private_steps = 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);
+  CADICAL_assert (lookingahead);
+  lookingahead = false;
+  STOP (lookahead);
+  if (external_prop) {
+    private_steps = false;
+    LOG ("external notifications are turned back on.");
+    notify_assignments (); // In case fixed assignments were found.
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::finalize (int res) {
+  if (!proof)
+    return;
+  LOG ("finalizing");
+  // finalize external units
+  if (frat) {
+    for (const auto &evar : external->vars) {
+      CADICAL_assert (evar > 0);
+      const auto eidx = 2 * evar;
+      int sign = 1;
+      int64_t id = external->ext_units[eidx];
+      if (!id) {
+        sign = -1;
+        id = external->ext_units[eidx + 1];
+      }
+      if (id) {
+        proof->finalize_external_unit (id, evar * sign);
+      }
+    }
+    // finalize internal units
+    for (const auto &lit : lits) {
+      const auto elit = externalize (lit);
+      if (elit) {
+        const unsigned eidx = (elit < 0) + 2u * (unsigned) abs (elit);
+        const int64_t id = external->ext_units[eidx];
+        if (id) {
+          CADICAL_assert (unit_clauses (vlit (lit)) == id);
+          continue;
+        }
+      }
+      const int64_t id = unit_clauses (vlit (lit));
+      if (!id)
+        continue;
+      proof->finalize_unit (id, lit);
+    }
+    // See the discussion in 'propagate' on why garbage binary clauses stick
+    // around.
+    for (const auto &c : clauses)
+      if (!c->garbage || (c->size == 2 && !c->flushed))
+        proof->finalize_clause (c);
+
+    // finalize conflict and proof
+    if (conflict_id) {
+      proof->finalize_clause (conflict_id, {});
+    }
+  }
+  proof->report_status (res, conflict_id);
+  if (res == 10)
+    external->conclude_sat ();
+  else if (res == 20)
+    conclude_unsat ();
+  else if (!res)
+    external->conclude_unknown ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::print_statistics () {
+  stats.print (this);
+  for (auto &st : stat_tracers)
+    st->print_stats ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Only useful for debugging purposes.
+
+void Internal::dump (Clause *c) {
+  for (const auto &lit : *c)
+    printf ("%d ", lit);
+  printf ("0\n");
+}
+
+void Internal::dump () {
+  int64_t m = assumptions.size ();
+  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 (auto idx : vars) {
+    const int tmp = fixed (idx);
+    if (tmp)
+      printf ("%d 0\n", tmp < 0 ? -idx : idx);
+  }
+  for (const auto &c : clauses)
+    if (!c->garbage)
+      dump (c);
+  for (const auto &lit : assumptions)
+    printf ("%d 0\n", lit);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::traverse_constraint (ClauseIterator &it) {
+  if (constraint.empty () && !unsat_constraint)
+    return true;
+
+  vector<int> eclause;
+  if (unsat)
+    return it.clause (eclause);
+
+  LOG (constraint, "traversing constraint");
+  bool satisfied = false;
+  for (auto ilit : constraint) {
+    const int tmp = fixed (ilit);
+    if (tmp > 0) {
+      satisfied = true;
+      break;
+    }
+    if (tmp < 0)
+      continue;
+    const int elit = externalize (ilit);
+    eclause.push_back (elit);
+  }
+  if (!satisfied && !it.clause (eclause))
+    return false;
+
+  return true;
+}
+/*------------------------------------------------------------------------*/
+
+bool Internal::traverse_clauses (ClauseIterator &it) {
+  vector<int> eclause;
+  if (unsat)
+    return it.clause (eclause);
+  for (const auto &c : clauses) {
+    if (c->garbage)
+      continue;
+    if (c->redundant)
+      continue;
+    bool satisfied = false;
+    for (const auto &ilit : *c) {
+      const int tmp = fixed (ilit);
+      if (tmp > 0) {
+        satisfied = true;
+        break;
+      }
+      if (tmp < 0)
+        continue;
+      const int elit = externalize (ilit);
+      eclause.push_back (elit);
+    }
+    if (!satisfied && !it.clause (eclause))
+      return false;
+    eclause.clear ();
+  }
+  return true;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_ipasir.cpp b/src/sat/cadical/cadical_ipasir.cpp
new file mode 100644
index 000000000..cb88deb4b
--- /dev/null
+++ b/src/sat/cadical/cadical_ipasir.cpp
@@ -0,0 +1,46 @@
+#include "global.h"
+
+#include "ipasir.h"
+#include "ccadical.h"
+
+ABC_NAMESPACE_IMPL_START
+
+const char *ipasir_signature () { return ccadical_signature (); }
+
+void *ipasir_init () { return ccadical_init (); }
+
+void ipasir_release (void *solver) {
+  ccadical_release ((CCaDiCaL *) solver);
+}
+
+void ipasir_add (void *solver, int lit) {
+  ccadical_add ((CCaDiCaL *) solver, lit);
+}
+
+void ipasir_assume (void *solver, int lit) {
+  ccadical_assume ((CCaDiCaL *) solver, lit);
+}
+
+int ipasir_solve (void *solver) {
+  return ccadical_solve ((CCaDiCaL *) solver);
+}
+
+int ipasir_val (void *solver, int lit) {
+  return ccadical_val ((CCaDiCaL *) solver, lit);
+}
+
+int ipasir_failed (void *solver, int lit) {
+  return ccadical_failed ((CCaDiCaL *) solver, lit);
+}
+
+void ipasir_set_terminate (void *solver, void *state,
+                           int (*terminate) (void *state)) {
+  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);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_kitten.c b/src/sat/cadical/cadical_kitten.c
new file mode 100644
index 000000000..da3738980
--- /dev/null
+++ b/src/sat/cadical/cadical_kitten.c
@@ -0,0 +1,2609 @@
+#include "global.h"
+
+#include "kitten.h"
+#include "random.h"
+#include "stack.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+typedef signed char value;
+
+static void die (const char *fmt, ...) {
+  fputs ("cadical_kitten: error: ", stderr);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  exit (1);
+}
+
+static inline void *cadical_kitten_calloc (size_t n, size_t size) {
+  void *res = calloc (n, size);
+  if (n && size && !res)
+    die ("out of memory allocating '%zu * %zu' bytes", n, size);
+  return res;
+}
+
+#define CALLOC(T, P, N)                          \
+  do { \
+    (P) = (T*)cadical_kitten_calloc (N, sizeof *(P));   \
+  } while (0)
+#define DEALLOC(P, N) free (P)
+
+#undef ENLARGE_STACK
+
+#define ENLARGE_STACK(S) \
+  do { \
+    CADICAL_assert (FULL_STACK (S)); \
+    const size_t SIZE = SIZE_STACK (S); \
+    const size_t OLD_CAPACITY = CAPACITY_STACK (S); \
+    const size_t NEW_CAPACITY = OLD_CAPACITY ? 2 * OLD_CAPACITY : 1; \
+    const size_t BYTES = NEW_CAPACITY * sizeof *(S).begin; \
+    (S).begin = (unsigned*)realloc ((S).begin, BYTES);              \
+    if (!(S).begin) \
+      die ("out of memory reallocating '%zu' bytes", BYTES); \
+    (S).allocated = (S).begin + NEW_CAPACITY; \
+    (S).end = (S).begin + SIZE; \
+  } while (0)
+
+// Beside allocators above also use stand alone statistics counters.
+
+#define INC(NAME) \
+  do { \
+    statistics *statistics = &cadical_kitten->statistics; \
+    CADICAL_assert (statistics->NAME < UINT64_MAX); \
+    statistics->NAME++; \
+  } while (0)
+
+#define ADD(NAME, DELTA) \
+  do { \
+    statistics *statistics = &cadical_kitten->statistics; \
+    CADICAL_assert (statistics->NAME <= UINT64_MAX - (DELTA)); \
+    statistics->NAME += (DELTA); \
+  } while (0)
+
+#define KITTEN_TICKS (cadical_kitten->statistics.cadical_kitten_ticks)
+
+#define INVALID UINT_MAX
+#define MAX_VARS ((1u << 31) - 1)
+
+#define CORE_FLAG (1u)
+#define LEARNED_FLAG (2u)
+
+// clang-format off
+
+typedef struct kar kar;
+typedef struct kink kink;
+typedef struct klause klause;
+typedef STACK (unsigned) klauses;
+typedef unsigneds katches;
+
+// clang-format on
+
+struct kar {
+  unsigned level;
+  unsigned reason;
+};
+
+struct kink {
+  unsigned next;
+  unsigned prev;
+  uint64_t stamp;
+};
+
+struct klause {
+  unsigned aux;
+  unsigned size;
+  unsigned flags;
+  unsigned lits[1];
+};
+
+typedef struct statistics statistics;
+
+struct statistics {
+  uint64_t learned;
+  uint64_t original;
+  uint64_t cadical_kitten_flip;
+  uint64_t cadical_kitten_flipped;
+  uint64_t cadical_kitten_sat;
+  uint64_t cadical_kitten_solved;
+  uint64_t cadical_kitten_conflicts;
+  uint64_t cadical_kitten_decisions;
+  uint64_t cadical_kitten_propagations;
+  uint64_t cadical_kitten_ticks;
+  uint64_t cadical_kitten_unknown;
+  uint64_t cadical_kitten_unsat;
+};
+
+typedef struct kimits kimits;
+
+struct kimits {
+  uint64_t ticks;
+};
+
+struct cadical_kitten {
+  // First zero initialized field in 'clear_cadical_kitten' is 'status'.
+  //
+  int status;
+
+#if defined(LOGGING)
+  bool logging;
+#endif
+  bool antecedents;
+  bool learned;
+
+  unsigned level;
+  unsigned propagated;
+  unsigned unassigned;
+  unsigned inconsistent;
+  unsigned failing;
+
+  uint64_t generator;
+
+  size_t lits;
+  size_t evars;
+
+  size_t end_original_ref;
+
+  struct {
+    unsigned first, last;
+    uint64_t stamp;
+    unsigned search;
+  } queue;
+
+  // The 'size' field below is the first not zero reinitialized field
+  // by 'memset' in 'clear_cadical_kitten' (after 'kissat').
+
+  size_t size;
+  size_t esize;
+
+  kar *vars;
+  kink *links;
+  value *marks;
+  value *values;
+  bool *failed;
+  unsigned char *phases;
+  unsigned *import;
+  katches *watches;
+
+  unsigneds analyzed;
+  unsigneds assumptions;
+  unsigneds core;
+  unsigneds rcore;
+  unsigneds eclause;
+  unsigneds export_;
+  unsigneds klause;
+  unsigneds klauses;
+  unsigneds resolved;
+  unsigneds trail;
+  unsigneds units;
+  unsigneds prime[2];
+
+  kimits limits;
+  int (*terminator) (void *);
+  void *terminator_data;
+  unsigneds clause;
+  uint64_t initialized;
+  statistics statistics;
+};
+
+/*------------------------------------------------------------------------*/
+
+static inline bool is_core_klause (klause *c) {
+  return c->flags & CORE_FLAG;
+}
+
+static inline bool is_learned_klause (klause *c) {
+  return c->flags & LEARNED_FLAG;
+}
+
+static inline void set_core_klause (klause *c) { c->flags |= CORE_FLAG; }
+
+static inline void unset_core_klause (klause *c) { c->flags &= ~CORE_FLAG; }
+
+static inline klause *dereference_klause (cadical_kitten *cadical_kitten, unsigned ref) {
+  unsigned *res = BEGIN_STACK (cadical_kitten->klauses) + ref;
+  CADICAL_assert (res < END_STACK (cadical_kitten->klauses));
+  return (klause *) res;
+}
+
+static inline unsigned reference_klause (cadical_kitten *cadical_kitten, const klause *c) {
+  const unsigned *const begin = BEGIN_STACK (cadical_kitten->klauses);
+  const unsigned *p = (const unsigned *) c;
+  CADICAL_assert (begin <= p);
+  CADICAL_assert (p < END_STACK (cadical_kitten->klauses));
+  const unsigned res = p - begin;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+#define KATCHES(KIT) (cadical_kitten->watches[CADICAL_assert ((KIT) < cadical_kitten->lits), (KIT)])
+
+#define all_klauses(C) \
+  klause *C = begin_klauses (cadical_kitten), *end_##C = end_klauses (cadical_kitten); \
+  (C) != end_##C; \
+  (C) = next_klause (cadical_kitten, C)
+
+#define all_original_klauses(C) \
+  klause *C = begin_klauses (cadical_kitten), \
+         *end_##C = end_original_klauses (cadical_kitten); \
+  (C) != end_##C; \
+  (C) = next_klause (cadical_kitten, C)
+
+#define all_learned_klauses(C) \
+  klause *C = begin_learned_klauses (cadical_kitten), \
+         *end_##C = end_klauses (cadical_kitten); \
+  (C) != end_##C; \
+  (C) = next_klause (cadical_kitten, C)
+
+#define all_kits(KIT) \
+  size_t KIT = 0, KIT_##END = cadical_kitten->lits; \
+  KIT != KIT_##END; \
+  KIT++
+
+#define BEGIN_KLAUSE(C) (C)->lits
+
+#define END_KLAUSE(C) (BEGIN_KLAUSE (C) + (C)->size)
+
+#define all_literals_in_klause(KIT, C) \
+  unsigned KIT, *KIT##_PTR = BEGIN_KLAUSE (C), \
+                *KIT##_END = END_KLAUSE (C); \
+  KIT##_PTR != KIT##_END && ((KIT = *KIT##_PTR), true); \
+  ++KIT##_PTR
+
+#define all_antecedents(REF, C) \
+  unsigned REF, *REF##_PTR = antecedents (C), \
+                *REF##_END = REF##_PTR + (C)->aux; \
+  REF##_PTR != REF##_END && ((REF = *REF##_PTR), true); \
+  ++REF##_PTR
+
+#ifdef LOGGING
+
+#define logging (cadical_kitten->logging)
+
+static void log_basic (cadical_kitten *, const char *, ...)
+    __attribute__ ((format (printf, 2, 3)));
+
+static void log_basic (cadical_kitten *cadical_kitten, const char *fmt, ...) {
+  CADICAL_assert (logging);
+  printf ("c KITTEN %u ", cadical_kitten->level);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+static void log_reference (cadical_kitten *, unsigned, const char *, ...)
+    __attribute__ ((format (printf, 3, 4)));
+
+static void log_reference (cadical_kitten *cadical_kitten, unsigned ref, const char *fmt,
+                           ...) {
+  klause *c = dereference_klause (cadical_kitten, ref);
+  CADICAL_assert (logging);
+  printf ("c KITTEN %u ", cadical_kitten->level);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (is_learned_klause (c)) {
+    fputs (" learned", stdout);
+    if (c->aux)
+      printf ("[%u]", c->aux);
+  } else {
+    fputs (" original", stdout);
+    if (c->aux != INVALID)
+      printf ("[%u]", c->aux);
+  }
+  printf (" size %u clause[%u]", c->size, ref);
+  value *values = cadical_kitten->values;
+  kar *vars = cadical_kitten->vars;
+  for (all_literals_in_klause (lit, c)) {
+    printf (" %u", lit);
+    const value value = values[lit];
+    if (value)
+      printf ("@%u=%d", vars[lit / 2].level, (int) value);
+  }
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+static void log_literals (cadical_kitten *, unsigned *, unsigned, const char *, ...)
+    __attribute__ ((format (printf, 4, 5)));
+
+static void log_literals (cadical_kitten *cadical_kitten, unsigned *lits, unsigned size,
+                          const char *fmt, ...) {
+  CADICAL_assert (logging);
+  printf ("c KITTEN %u ", cadical_kitten->level);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  value *values = cadical_kitten->values;
+  kar *vars = cadical_kitten->vars;
+  for (unsigned i = 0; i < size; i++) {
+    const unsigned lit = lits[i];
+    printf (" %u", lit);
+    const value value = values[lit];
+    if (value)
+      printf ("@%u=%d", vars[lit / 2].level, (int) value);
+  }
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#define LOG(...) \
+  do { \
+    if (logging) \
+      log_basic (cadical_kitten, __VA_ARGS__); \
+  } while (0)
+
+#define ROG(...) \
+  do { \
+    if (logging) \
+      log_reference (cadical_kitten, __VA_ARGS__); \
+  } while (0)
+
+#define LOGLITS(...) \
+  do { \
+    if (logging) \
+      log_literals (cadical_kitten, __VA_ARGS__); \
+  } while (0)
+
+#else
+
+#define LOG(...) \
+  do { \
+  } while (0)
+#define ROG(...) \
+  do { \
+  } while (0)
+#define LOGLITS(...) \
+  do { \
+  } while (0)
+
+#endif
+
+static void check_queue (cadical_kitten *cadical_kitten) {
+#ifdef CHECK_KITTEN
+  const unsigned vars = cadical_kitten->lits / 2;
+  unsigned found = 0, prev = INVALID;
+  kink *links = cadical_kitten->links;
+  uint64_t stamp = 0;
+  for (unsigned idx = cadical_kitten->queue.first, next; idx != INVALID;
+       idx = next) {
+    kink *link = links + idx;
+    CADICAL_assert (link->prev == prev);
+    CADICAL_assert (!found || stamp < link->stamp);
+    CADICAL_assert (link->stamp < cadical_kitten->queue.stamp);
+    stamp = link->stamp;
+    next = link->next;
+    prev = idx;
+    found++;
+  }
+  CADICAL_assert (found == vars);
+  unsigned next = INVALID;
+  found = 0;
+  for (unsigned idx = cadical_kitten->queue.last, prev; idx != INVALID;
+       idx = prev) {
+    kink *link = links + idx;
+    CADICAL_assert (link->next == next);
+    prev = link->prev;
+    next = idx;
+    found++;
+  }
+  CADICAL_assert (found == vars);
+  value *values = cadical_kitten->values;
+  bool first = true;
+  for (unsigned idx = cadical_kitten->queue.search, next; idx != INVALID;
+       idx = next) {
+    kink *link = links + idx;
+    next = link->next;
+    const unsigned lit = 2 * idx;
+    CADICAL_assert (first || values[lit]);
+    first = false;
+  }
+#else
+  (void) cadical_kitten;
+#endif
+}
+
+static void update_search (cadical_kitten *cadical_kitten, unsigned idx) {
+  if (cadical_kitten->queue.search == idx)
+    return;
+  cadical_kitten->queue.search = idx;
+  LOG ("search updated to %u stamped %" PRIu64, idx,
+       cadical_kitten->links[idx].stamp);
+}
+
+static void enqueue (cadical_kitten *cadical_kitten, unsigned idx) {
+  LOG ("enqueue %u", idx);
+  kink *links = cadical_kitten->links;
+  kink *l = links + idx;
+  const unsigned last = cadical_kitten->queue.last;
+  if (last == INVALID)
+    cadical_kitten->queue.first = idx;
+  else
+    links[last].next = idx;
+  l->prev = last;
+  l->next = INVALID;
+  cadical_kitten->queue.last = idx;
+  l->stamp = cadical_kitten->queue.stamp++;
+  LOG ("stamp %" PRIu64, l->stamp);
+}
+
+static void dequeue (cadical_kitten *cadical_kitten, unsigned idx) {
+  LOG ("dequeue %u", idx);
+  kink *links = cadical_kitten->links;
+  kink *l = links + idx;
+  const unsigned prev = l->prev;
+  const unsigned next = l->next;
+  if (prev == INVALID)
+    cadical_kitten->queue.first = next;
+  else
+    links[prev].next = next;
+  if (next == INVALID)
+    cadical_kitten->queue.last = prev;
+  else
+    links[next].prev = prev;
+}
+
+static void init_queue (cadical_kitten *cadical_kitten, size_t old_vars, size_t new_vars) {
+  for (size_t idx = old_vars; idx < new_vars; idx++) {
+    CADICAL_assert (!cadical_kitten->values[2 * idx]);
+    CADICAL_assert (cadical_kitten->unassigned < UINT_MAX);
+    cadical_kitten->unassigned++;
+    enqueue (cadical_kitten, idx);
+  }
+  LOG ("initialized decision queue from %zu to %zu", old_vars, new_vars);
+  update_search (cadical_kitten, cadical_kitten->queue.last);
+  check_queue (cadical_kitten);
+}
+
+static void initialize_cadical_kitten (cadical_kitten *cadical_kitten) {
+  cadical_kitten->queue.first = INVALID;
+  cadical_kitten->queue.last = INVALID;
+  cadical_kitten->inconsistent = INVALID;
+  cadical_kitten->failing = INVALID;
+  cadical_kitten->queue.search = INVALID;
+  cadical_kitten->terminator = 0;
+  cadical_kitten->terminator_data = 0;
+  cadical_kitten->limits.ticks = UINT64_MAX;
+  cadical_kitten->generator = cadical_kitten->initialized++;
+}
+
+static void clear_cadical_kitten (cadical_kitten *cadical_kitten) {
+  size_t bytes = (char *) &cadical_kitten->size - (char *) &cadical_kitten->status;
+  memset (&cadical_kitten->status, 0, bytes);
+  memset (&cadical_kitten->statistics, 0, sizeof (statistics));
+  initialize_cadical_kitten (cadical_kitten);
+}
+
+#define RESIZE1(T, P)                            \
+  do { \
+    void *OLD_PTR = (P); \
+    CALLOC (T, (P), new_size / 2);                \
+    const size_t BYTES = old_vars * sizeof *(P); \
+    memcpy ((P), OLD_PTR, BYTES); \
+    void *NEW_PTR = (P); \
+    (P) = (T*)OLD_PTR;           \
+    DEALLOC ((P), old_size / 2); \
+    (P) = (T*)NEW_PTR;            \
+  } while (0)
+
+#define RESIZE2(T, P)                            \
+  do { \
+    void *OLD_PTR = (P); \
+    CALLOC (T, (P), new_size);                    \
+    const size_t BYTES = old_lits * sizeof *(P); \
+    memcpy ((P), OLD_PTR, BYTES); \
+    void *NEW_PTR = (P); \
+    (P) = (T*)OLD_PTR;       \
+    DEALLOC ((P), old_size); \
+    (P) = (T*)NEW_PTR;       \
+  } while (0)
+
+static void enlarge_internal (cadical_kitten *cadical_kitten, size_t lit) {
+  const size_t new_lits = (lit | 1) + 1;
+  const size_t old_lits = cadical_kitten->lits;
+  CADICAL_assert (old_lits <= lit);
+  CADICAL_assert (old_lits < new_lits);
+  CADICAL_assert ((lit ^ 1) < new_lits);
+  CADICAL_assert (lit < new_lits);
+  const size_t old_size = cadical_kitten->size;
+  const unsigned new_vars = new_lits / 2;
+  const unsigned old_vars = old_lits / 2;
+  if (old_size < new_lits) {
+    size_t new_size = old_size ? 2 * old_size : 2;
+    while (new_size <= lit)
+      new_size *= 2;
+    LOG ("internal literals resized to %zu from %zu (requested %zu)",
+         new_size, old_size, new_lits);
+
+    RESIZE1 (value, cadical_kitten->marks);
+    RESIZE1 (unsigned char, cadical_kitten->phases);
+    RESIZE2 (value, cadical_kitten->values);
+    RESIZE2 (bool, cadical_kitten->failed);
+    RESIZE1 (kar, cadical_kitten->vars);
+    RESIZE1 (kink, cadical_kitten->links);
+    RESIZE2 (katches, cadical_kitten->watches);
+
+    cadical_kitten->size = new_size;
+  }
+  cadical_kitten->lits = new_lits;
+  init_queue (cadical_kitten, old_vars, new_vars);
+  LOG ("internal literals activated until %zu literals", new_lits);
+  return;
+}
+
+static const char *status_to_string (int status) {
+  switch (status) {
+  case 10:
+    return "formula satisfied";
+  case 11:
+    return "formula satisfied and prime implicant computed";
+  case 20:
+    return "formula inconsistent";
+  case 21:
+    return "formula inconsistent and core computed";
+  default:
+    CADICAL_assert (!status);
+    return "formula unsolved";
+  }
+}
+
+static void invalid_api_usage (const char *fun, const char *fmt, ...) {
+  fprintf (stderr, "cadical_kitten: fatal error: invalid API usage in '%s': ", fun);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  abort ();
+}
+
+#define INVALID_API_USAGE(...) invalid_api_usage (__func__, __VA_ARGS__)
+
+#define REQUIRE_INITIALIZED() \
+  do { \
+    if (!cadical_kitten) \
+      INVALID_API_USAGE ("solver argument zero"); \
+  } while (0)
+
+#define REQUIRE_STATUS(EXPECTED) \
+  do { \
+    REQUIRE_INITIALIZED (); \
+    if (cadical_kitten->status != (EXPECTED)) \
+      INVALID_API_USAGE ("invalid status '%s' (expected '%s')", \
+                         status_to_string (cadical_kitten->status), \
+                         status_to_string (EXPECTED)); \
+  } while (0)
+
+#define UPDATE_STATUS(STATUS) \
+  do { \
+    if (cadical_kitten->status != (STATUS)) \
+      LOG ("updating status from '%s' to '%s'", \
+           status_to_string (cadical_kitten->status), status_to_string (STATUS)); \
+    else \
+      LOG ("keeping status at '%s'", status_to_string (STATUS)); \
+    cadical_kitten->status = (STATUS); \
+  } while (0)
+
+cadical_kitten *cadical_kitten_init (void) {
+  cadical_kitten *cadical_kitten;
+  CALLOC (struct cadical_kitten, cadical_kitten, 1);
+  initialize_cadical_kitten (cadical_kitten);
+  return cadical_kitten;
+}
+
+#ifdef LOGGING
+void cadical_kitten_set_logging (cadical_kitten *cadical_kitten) { logging = true; }
+#endif
+
+void cadical_kitten_track_antecedents (cadical_kitten *cadical_kitten) {
+  REQUIRE_STATUS (0);
+
+  if (cadical_kitten->learned)
+    INVALID_API_USAGE ("can not start tracking antecedents after learning");
+
+  LOG ("enabling antecedents tracking");
+  cadical_kitten->antecedents = true;
+}
+
+void cadical_kitten_randomize_phases (cadical_kitten *cadical_kitten) {
+  REQUIRE_INITIALIZED ();
+
+  LOG ("randomizing phases");
+
+  unsigned char *phases = cadical_kitten->phases;
+  const unsigned vars = cadical_kitten->size / 2;
+
+  uint64_t random = kissat_next_random64 (&cadical_kitten->generator);
+
+  unsigned i = 0;
+  const unsigned rest = vars & ~63u;
+
+  while (i != rest) {
+    uint64_t *p = (uint64_t *) (phases + i);
+    p[0] = (random >> 0) & 0x0101010101010101;
+    p[1] = (random >> 1) & 0x0101010101010101;
+    p[2] = (random >> 2) & 0x0101010101010101;
+    p[3] = (random >> 3) & 0x0101010101010101;
+    p[4] = (random >> 4) & 0x0101010101010101;
+    p[5] = (random >> 5) & 0x0101010101010101;
+    p[6] = (random >> 6) & 0x0101010101010101;
+    p[7] = (random >> 7) & 0x0101010101010101;
+    random = kissat_next_random64 (&cadical_kitten->generator);
+    i += 64;
+  }
+
+  unsigned shift = 0;
+  while (i != vars)
+    phases[i++] = (random >> shift++) & 1;
+}
+
+void cadical_kitten_flip_phases (cadical_kitten *cadical_kitten) {
+  REQUIRE_INITIALIZED ();
+
+  LOG ("flipping phases");
+
+  unsigned char *phases = cadical_kitten->phases;
+  const unsigned vars = cadical_kitten->size / 2;
+
+  unsigned i = 0;
+  const unsigned rest = vars & ~7u;
+
+  while (i != rest) {
+    uint64_t *p = (uint64_t *) (phases + i);
+    *p ^= 0x0101010101010101;
+    i += 8;
+  }
+
+  while (i != vars)
+    phases[i++] ^= 1;
+}
+
+void cadical_kitten_no_ticks_limit (cadical_kitten *cadical_kitten) {
+  REQUIRE_INITIALIZED ();
+  LOG ("forcing no ticks limit");
+  cadical_kitten->limits.ticks = UINT64_MAX;
+}
+
+uint64_t cadical_kitten_current_ticks (cadical_kitten *cadical_kitten) {
+  REQUIRE_INITIALIZED ();
+  const uint64_t current = KITTEN_TICKS;
+  return current;
+}
+
+void cadical_kitten_set_ticks_limit (cadical_kitten *cadical_kitten, uint64_t delta) {
+  REQUIRE_INITIALIZED ();
+  const uint64_t current = KITTEN_TICKS;
+  uint64_t limit;
+  if (UINT64_MAX - delta <= current) {
+    LOG ("forcing unlimited ticks limit");
+    limit = UINT64_MAX;
+  } else {
+    limit = current + delta;
+    LOG ("new limit of %" PRIu64 " ticks after %" PRIu64, limit, delta);
+  }
+
+  cadical_kitten->limits.ticks = limit;
+}
+
+void cadical_kitten_no_terminator (cadical_kitten *cadical_kitten) {
+  REQUIRE_INITIALIZED ();
+  LOG ("removing terminator");
+  cadical_kitten->terminator = 0;
+  cadical_kitten->terminator_data = 0;
+}
+
+void cadical_kitten_set_terminator (cadical_kitten *cadical_kitten, void *data,
+                            int (*terminator) (void *)) {
+  REQUIRE_INITIALIZED ();
+  LOG ("setting terminator");
+  cadical_kitten->terminator = terminator;
+  cadical_kitten->terminator_data = data;
+}
+
+static void shuffle_unsigned_array (cadical_kitten *cadical_kitten, size_t size,
+                                    unsigned *a) {
+  for (size_t i = 0; i < size; i++) {
+    const size_t j = kissat_pick_random (&cadical_kitten->generator, 0, i);
+    if (j == i)
+      continue;
+    const unsigned first = a[i];
+    const unsigned second = a[j];
+    a[i] = second;
+    a[j] = first;
+  }
+}
+
+static void shuffle_unsigned_stack (cadical_kitten *cadical_kitten, unsigneds *stack) {
+  const size_t size = SIZE_STACK (*stack);
+  unsigned *a = BEGIN_STACK (*stack);
+  shuffle_unsigned_array (cadical_kitten, size, a);
+}
+
+static void shuffle_katches (cadical_kitten *cadical_kitten) {
+  LOG ("shuffling watch lists");
+  for (size_t lit = 0; lit < cadical_kitten->lits; lit++)
+    shuffle_unsigned_stack (cadical_kitten, &KATCHES (lit));
+}
+
+static void shuffle_queue (cadical_kitten *cadical_kitten) {
+  LOG ("shuffling variable decision order");
+
+  const unsigned vars = cadical_kitten->lits / 2;
+  for (unsigned i = 0; i < vars; i++) {
+    const unsigned idx = kissat_pick_random (&cadical_kitten->generator, 0, vars);
+    dequeue (cadical_kitten, idx);
+    enqueue (cadical_kitten, idx);
+  }
+  update_search (cadical_kitten, cadical_kitten->queue.last);
+}
+
+static void shuffle_units (cadical_kitten *cadical_kitten) {
+  LOG ("shuffling units");
+  shuffle_unsigned_stack (cadical_kitten, &cadical_kitten->units);
+}
+
+void cadical_kitten_shuffle_clauses (cadical_kitten *cadical_kitten) {
+  REQUIRE_STATUS (0);
+  shuffle_queue (cadical_kitten);
+  shuffle_katches (cadical_kitten);
+  shuffle_units (cadical_kitten);
+}
+
+static inline unsigned *antecedents (klause *c) {
+  CADICAL_assert (is_learned_klause (c));
+  return c->lits + c->size;
+}
+
+static inline void watch_klause (cadical_kitten *cadical_kitten, unsigned lit,
+                                 unsigned ref) {
+  ROG (ref, "watching %u in", lit);
+  katches *watches = &KATCHES (lit);
+  PUSH_STACK (*watches, ref);
+}
+
+static inline void connect_new_klause (cadical_kitten *cadical_kitten, unsigned ref) {
+  ROG (ref, "new");
+
+  klause *c = dereference_klause (cadical_kitten, ref);
+
+  if (!c->size) {
+    if (cadical_kitten->inconsistent == INVALID) {
+      ROG (ref, "registering inconsistent empty");
+      cadical_kitten->inconsistent = ref;
+    } else
+      ROG (ref, "ignoring inconsistent empty");
+  } else if (c->size == 1) {
+    ROG (ref, "watching unit");
+    PUSH_STACK (cadical_kitten->units, ref);
+  } else {
+    watch_klause (cadical_kitten, c->lits[0], ref);
+    watch_klause (cadical_kitten, c->lits[1], ref);
+  }
+}
+
+static unsigned new_reference (cadical_kitten *cadical_kitten) {
+  size_t ref = SIZE_STACK (cadical_kitten->klauses);
+  if (ref >= INVALID) {
+    die ("maximum number of literals exhausted");
+  }
+  const unsigned res = (unsigned) ref;
+  CADICAL_assert (res != INVALID);
+  INC (cadical_kitten_ticks);
+  return res;
+}
+
+static void new_original_klause (cadical_kitten *cadical_kitten, unsigned id) {
+  unsigned res = new_reference (cadical_kitten);
+  unsigned size = SIZE_STACK (cadical_kitten->klause);
+  unsigneds *klauses = &cadical_kitten->klauses;
+  PUSH_STACK (*klauses, id);
+  PUSH_STACK (*klauses, size);
+  PUSH_STACK (*klauses, 0);
+  for (all_stack (unsigned, lit, cadical_kitten->klause))
+    PUSH_STACK (*klauses, lit);
+  connect_new_klause (cadical_kitten, res);
+  cadical_kitten->end_original_ref = SIZE_STACK (*klauses);
+  cadical_kitten->statistics.original++;
+}
+
+static void enlarge_external (cadical_kitten *cadical_kitten, size_t eidx) {
+  const size_t old_size = cadical_kitten->esize;
+  const unsigned old_evars = cadical_kitten->evars;
+  CADICAL_assert (old_evars <= eidx);
+  const unsigned new_evars = eidx + 1;
+  if (old_size <= eidx) {
+    size_t new_size = old_size ? 2 * old_size : 1;
+    while (new_size <= eidx)
+      new_size *= 2;
+    LOG ("external resizing to %zu variables from %zu (requested %u)",
+         new_size, old_size, new_evars);
+    unsigned *old_import = cadical_kitten->import;
+    CALLOC (unsigned, cadical_kitten->import, new_size);
+    const size_t bytes = old_evars * sizeof *cadical_kitten->import;
+    memcpy (cadical_kitten->import, old_import, bytes);
+    DEALLOC (old_import, old_size);
+    cadical_kitten->esize = new_size;
+  }
+  cadical_kitten->evars = new_evars;
+  LOG ("external variables enlarged to %u", new_evars);
+}
+
+static unsigned import_literal (cadical_kitten *cadical_kitten, unsigned elit) {
+  const unsigned eidx = elit / 2;
+  if (eidx >= cadical_kitten->evars)
+    enlarge_external (cadical_kitten, eidx);
+
+  unsigned iidx = cadical_kitten->import[eidx];
+  if (!iidx) {
+    iidx = SIZE_STACK (cadical_kitten->export_);
+    PUSH_STACK (cadical_kitten->export_, eidx);
+    cadical_kitten->import[eidx] = iidx + 1;
+  } else
+    iidx--;
+  unsigned ilit = 2 * iidx + (elit & 1);
+  LOG ("imported external literal %u as internal literal %u", elit, ilit);
+  if (ilit >= cadical_kitten->lits)
+    enlarge_internal (cadical_kitten, ilit);
+  return ilit;
+}
+
+static unsigned export_literal (cadical_kitten *cadical_kitten, unsigned ilit) {
+  const unsigned iidx = ilit / 2;
+  CADICAL_assert (iidx < SIZE_STACK (cadical_kitten->export_));
+  const unsigned eidx = PEEK_STACK (cadical_kitten->export_, iidx);
+  const unsigned elit = 2 * eidx + (ilit & 1);
+  return elit;
+}
+
+unsigned cadical_new_learned_klause (cadical_kitten *cadical_kitten) {
+  unsigned res = new_reference (cadical_kitten);
+  unsigneds *klauses = &cadical_kitten->klauses;
+  const size_t size = SIZE_STACK (cadical_kitten->klause);
+  CADICAL_assert (size <= UINT_MAX);
+  const size_t aux =
+      cadical_kitten->antecedents ? SIZE_STACK (cadical_kitten->resolved) : 0;
+  CADICAL_assert (aux <= UINT_MAX);
+  PUSH_STACK (*klauses, (unsigned) aux);
+  PUSH_STACK (*klauses, (unsigned) size);
+  PUSH_STACK (*klauses, LEARNED_FLAG);
+  for (all_stack (unsigned, lit, cadical_kitten->klause))
+    PUSH_STACK (*klauses, lit);
+  if (aux)
+    for (all_stack (unsigned, ref, cadical_kitten->resolved))
+      PUSH_STACK (*klauses, ref);
+  connect_new_klause (cadical_kitten, res);
+  cadical_kitten->learned = true;
+  cadical_kitten->statistics.learned++;
+  return res;
+}
+
+void cadical_kitten_clear (cadical_kitten *cadical_kitten) {
+  LOG ("clear cadical_kitten of size %zu", cadical_kitten->size);
+
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->analyzed));
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->eclause));
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->resolved));
+
+  CLEAR_STACK (cadical_kitten->assumptions);
+  CLEAR_STACK (cadical_kitten->core);
+  CLEAR_STACK (cadical_kitten->klause);
+  CLEAR_STACK (cadical_kitten->klauses);
+  CLEAR_STACK (cadical_kitten->trail);
+  CLEAR_STACK (cadical_kitten->units);
+  CLEAR_STACK (cadical_kitten->clause);
+  CLEAR_STACK (cadical_kitten->prime[0]);
+  CLEAR_STACK (cadical_kitten->prime[1]);
+
+  for (all_kits (kit))
+    CLEAR_STACK (KATCHES (kit));
+
+  while (!EMPTY_STACK (cadical_kitten->export_))
+    cadical_kitten->import[POP_STACK (cadical_kitten->export_)] = 0;
+
+  const size_t lits = cadical_kitten->size;
+  const unsigned vars = lits / 2;
+
+#ifndef CADICAL_NDEBUG
+  for (unsigned i = 0; i < vars; i++)
+    CADICAL_assert (!cadical_kitten->marks[i]);
+#endif
+
+  memset (cadical_kitten->phases, 0, vars);
+  memset (cadical_kitten->values, 0, lits);
+  memset (cadical_kitten->failed, 0, lits);
+  memset (cadical_kitten->vars, 0, vars);
+
+  clear_cadical_kitten (cadical_kitten);
+}
+
+void cadical_kitten_release (cadical_kitten *cadical_kitten) {
+  RELEASE_STACK (cadical_kitten->analyzed);
+  RELEASE_STACK (cadical_kitten->assumptions);
+  RELEASE_STACK (cadical_kitten->core);
+  RELEASE_STACK (cadical_kitten->eclause);
+  RELEASE_STACK (cadical_kitten->export_);
+  RELEASE_STACK (cadical_kitten->klause);
+  RELEASE_STACK (cadical_kitten->klauses);
+  RELEASE_STACK (cadical_kitten->resolved);
+  RELEASE_STACK (cadical_kitten->trail);
+  RELEASE_STACK (cadical_kitten->units);
+  RELEASE_STACK (cadical_kitten->clause);
+  RELEASE_STACK (cadical_kitten->prime[0]);
+  RELEASE_STACK (cadical_kitten->prime[1]);
+
+  for (size_t lit = 0; lit < cadical_kitten->size; lit++)
+    RELEASE_STACK (cadical_kitten->watches[lit]);
+
+  const size_t lits = cadical_kitten->size;
+  const unsigned vars = lits / 2;
+  DEALLOC (cadical_kitten->marks, vars);
+  DEALLOC (cadical_kitten->phases, vars);
+  DEALLOC (cadical_kitten->values, lits);
+  DEALLOC (cadical_kitten->failed, lits);
+  DEALLOC (cadical_kitten->vars, vars);
+  DEALLOC (cadical_kitten->links, vars);
+  DEALLOC (cadical_kitten->watches, lits);
+  DEALLOC (cadical_kitten->import, cadical_kitten->esize);
+  (void) vars;
+
+  free (cadical_kitten);
+}
+
+static inline void move_to_front (cadical_kitten *cadical_kitten, unsigned idx) {
+  if (idx == cadical_kitten->queue.last)
+    return;
+  LOG ("move to front variable %u", idx);
+  dequeue (cadical_kitten, idx);
+  enqueue (cadical_kitten, idx);
+  CADICAL_assert (cadical_kitten->values[2 * idx]);
+}
+
+static inline void assign (cadical_kitten *cadical_kitten, unsigned lit, unsigned reason) {
+#ifdef LOGGING
+  if (reason == INVALID)
+    LOG ("assign %u as decision", lit);
+  else
+    ROG (reason, "assign %u reason", lit);
+#endif
+  value *values = cadical_kitten->values;
+  const unsigned not_lit = lit ^ 1;
+  CADICAL_assert (!values[lit]);
+  CADICAL_assert (!values[not_lit]);
+  values[lit] = 1;
+  values[not_lit] = -1;
+  const unsigned idx = lit / 2;
+  const unsigned sign = lit & 1;
+  cadical_kitten->phases[idx] = sign;
+  PUSH_STACK (cadical_kitten->trail, lit);
+  kar *v = cadical_kitten->vars + idx;
+  v->level = cadical_kitten->level;
+  if (!v->level) {
+    CADICAL_assert (reason != INVALID);
+    klause *c = dereference_klause (cadical_kitten, reason);
+    if (c->size > 1) {
+      if (cadical_kitten->antecedents) {
+        PUSH_STACK (cadical_kitten->resolved, reason);
+        for (all_literals_in_klause (other, c))
+          if (other != lit) {
+            const unsigned other_idx = other / 2;
+            const unsigned other_ref = cadical_kitten->vars[other_idx].reason;
+            CADICAL_assert (other_ref != INVALID);
+            PUSH_STACK (cadical_kitten->resolved, other_ref);
+          }
+      }
+      PUSH_STACK (cadical_kitten->klause, lit);
+      reason = cadical_new_learned_klause (cadical_kitten);
+      CLEAR_STACK (cadical_kitten->resolved);
+      CLEAR_STACK (cadical_kitten->klause);
+    }
+  }
+  v->reason = reason;
+  CADICAL_assert (cadical_kitten->unassigned);
+  cadical_kitten->unassigned--;
+}
+
+static inline unsigned propagate_literal (cadical_kitten *cadical_kitten, unsigned lit) {
+  LOG ("propagating %u", lit);
+  value *values = cadical_kitten->values;
+  CADICAL_assert (values[lit] > 0);
+  const unsigned not_lit = lit ^ 1;
+  katches *watches = cadical_kitten->watches + not_lit;
+  unsigned conflict = INVALID;
+  unsigned *q = BEGIN_STACK (*watches);
+  const unsigned *const end_watches = END_STACK (*watches);
+  unsigned const *p = q;
+  uint64_t ticks = (((char *) end_watches - (char *) q) >> 7) + 1;
+  while (p != end_watches) {
+    const unsigned ref = *q++ = *p++;
+    klause *c = dereference_klause (cadical_kitten, ref);
+    CADICAL_assert (c->size > 1);
+    unsigned *lits = c->lits;
+    const unsigned other = lits[0] ^ lits[1] ^ not_lit;
+    const value other_value = values[other];
+    ticks++;
+    if (other_value > 0)
+      continue;
+    value replacement_value = -1;
+    unsigned replacement = INVALID;
+    const unsigned *const end_lits = lits + c->size;
+    unsigned *r;
+    for (r = lits + 2; r != end_lits; r++) {
+      replacement = *r;
+      replacement_value = values[replacement];
+      if (replacement_value >= 0)
+        break;
+    }
+    if (replacement_value >= 0) {
+      CADICAL_assert (replacement != INVALID);
+      ROG (ref, "unwatching %u in", not_lit);
+      lits[0] = other;
+      lits[1] = replacement;
+      *r = not_lit;
+      watch_klause (cadical_kitten, replacement, ref);
+      q--;
+    } else if (other_value < 0) {
+      ROG (ref, "conflict");
+      INC (cadical_kitten_conflicts);
+      conflict = ref;
+      break;
+    } else {
+      CADICAL_assert (!other_value);
+      assign (cadical_kitten, other, ref);
+    }
+  }
+  while (p != end_watches)
+    *q++ = *p++;
+  SET_END_OF_STACK (*watches, q);
+  ADD (cadical_kitten_ticks, ticks);
+  return conflict;
+}
+
+static inline unsigned propagate (cadical_kitten *cadical_kitten) {
+  CADICAL_assert (cadical_kitten->inconsistent == INVALID);
+  unsigned propagated = 0;
+  unsigned conflict = INVALID;
+  while (conflict == INVALID &&
+         cadical_kitten->propagated < SIZE_STACK (cadical_kitten->trail)) {
+    if (cadical_kitten->terminator &&
+        cadical_kitten->terminator (cadical_kitten->terminator_data)) {
+      break;
+    }
+    const unsigned lit = PEEK_STACK (cadical_kitten->trail, cadical_kitten->propagated);
+    conflict = propagate_literal (cadical_kitten, lit);
+    cadical_kitten->propagated++;
+    propagated++;
+  }
+  ADD (cadical_kitten_propagations, propagated);
+  return conflict;
+}
+
+static void bump (cadical_kitten *cadical_kitten) {
+  value *marks = cadical_kitten->marks;
+  for (all_stack (unsigned, idx, cadical_kitten->analyzed)) {
+    marks[idx] = 0;
+    move_to_front (cadical_kitten, idx);
+  }
+  check_queue (cadical_kitten);
+}
+
+static inline void unassign (cadical_kitten *cadical_kitten, value *values, unsigned lit) {
+  const unsigned not_lit = lit ^ 1;
+  CADICAL_assert (values[lit]);
+  CADICAL_assert (values[not_lit]);
+  const unsigned idx = lit / 2;
+#ifdef LOGGING
+  kar *var = cadical_kitten->vars + idx;
+  cadical_kitten->level = var->level;
+  LOG ("unassign %u", lit);
+#endif
+  values[lit] = values[not_lit] = 0;
+  CADICAL_assert (cadical_kitten->unassigned < cadical_kitten->lits / 2);
+  cadical_kitten->unassigned++;
+  kink *links = cadical_kitten->links;
+  kink *link = links + idx;
+  if (link->stamp > links[cadical_kitten->queue.search].stamp)
+    update_search (cadical_kitten, idx);
+}
+
+static void backtrack (cadical_kitten *cadical_kitten, unsigned jump) {
+  check_queue (cadical_kitten);
+  CADICAL_assert (jump < cadical_kitten->level);
+  LOG ("back%s to level %u",
+       (cadical_kitten->level == jump + 1 ? "tracking" : "jumping"), jump);
+  kar *vars = cadical_kitten->vars;
+  value *values = cadical_kitten->values;
+  unsigneds *trail = &cadical_kitten->trail;
+  while (!EMPTY_STACK (*trail)) {
+    const unsigned lit = TOP_STACK (*trail);
+    const unsigned idx = lit / 2;
+    const unsigned level = vars[idx].level;
+    if (level == jump)
+      break;
+    (void) POP_STACK (*trail);
+    unassign (cadical_kitten, values, lit);
+  }
+  cadical_kitten->propagated = SIZE_STACK (*trail);
+  cadical_kitten->level = jump;
+  check_queue (cadical_kitten);
+}
+
+void cadical_completely_backtrack_to_root_level (cadical_kitten *cadical_kitten) {
+  check_queue (cadical_kitten);
+  LOG ("completely backtracking to level 0");
+  value *values = cadical_kitten->values;
+  unsigneds *trail = &cadical_kitten->trail;
+  unsigneds *units = &cadical_kitten->units;
+#ifndef CADICAL_NDEBUG
+  kar *vars = cadical_kitten->vars;
+#endif
+  for (all_stack (unsigned, lit, *trail)) {
+    CADICAL_assert (vars[lit / 2].level);
+    unassign (cadical_kitten, values, lit);
+  }
+  CLEAR_STACK (*trail);
+  for (all_stack (unsigned, ref, *units)) {
+    klause *c = dereference_klause (cadical_kitten, ref);
+    CADICAL_assert (c->size == 1);
+    const unsigned unit = c->lits[0];
+    const value value = values[unit];
+    if (value <= 0)
+      continue;
+    unassign (cadical_kitten, values, unit);
+  }
+  cadical_kitten->propagated = 0;
+  cadical_kitten->level = 0;
+  check_queue (cadical_kitten);
+}
+
+static void analyze (cadical_kitten *cadical_kitten, unsigned conflict) {
+  CADICAL_assert (cadical_kitten->level);
+  CADICAL_assert (cadical_kitten->inconsistent == INVALID);
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->analyzed));
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->resolved));
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->klause));
+  PUSH_STACK (cadical_kitten->klause, INVALID);
+  unsigned reason = conflict;
+  value *marks = cadical_kitten->marks;
+  const kar *const vars = cadical_kitten->vars;
+  const unsigned level = cadical_kitten->level;
+  unsigned const *p = END_STACK (cadical_kitten->trail);
+  unsigned open = 0, jump = 0, size = 1, uip;
+  for (;;) {
+    CADICAL_assert (reason != INVALID);
+    klause *c = dereference_klause (cadical_kitten, reason);
+    CADICAL_assert (c);
+    ROG (reason, "analyzing");
+    PUSH_STACK (cadical_kitten->resolved, reason);
+    for (all_literals_in_klause (lit, c)) {
+      const unsigned idx = lit / 2;
+      if (marks[idx])
+        continue;
+      CADICAL_assert (cadical_kitten->values[lit] < 0);
+      LOG ("analyzed %u", lit);
+      marks[idx] = true;
+      PUSH_STACK (cadical_kitten->analyzed, idx);
+      const kar *const v = vars + idx;
+      const unsigned tmp = v->level;
+      if (tmp < level) {
+        if (tmp > jump) {
+          jump = tmp;
+          if (size > 1) {
+            const unsigned other = PEEK_STACK (cadical_kitten->klause, 1);
+            POKE_STACK (cadical_kitten->klause, 1, lit);
+            lit = other;
+          }
+        }
+        PUSH_STACK (cadical_kitten->klause, lit);
+        size++;
+      } else
+        open++;
+    }
+    unsigned idx;
+    do {
+      CADICAL_assert (BEGIN_STACK (cadical_kitten->trail) < p);
+      uip = *--p;
+    } while (!marks[idx = uip / 2]);
+    CADICAL_assert (open);
+    if (!--open)
+      break;
+    reason = vars[idx].reason;
+  }
+  const unsigned not_uip = uip ^ 1;
+  LOG ("first UIP %u jump level %u size %u", not_uip, jump, size);
+  POKE_STACK (cadical_kitten->klause, 0, not_uip);
+  bump (cadical_kitten);
+  CLEAR_STACK (cadical_kitten->analyzed);
+  const unsigned learned_ref = cadical_new_learned_klause (cadical_kitten);
+  CLEAR_STACK (cadical_kitten->resolved);
+  CLEAR_STACK (cadical_kitten->klause);
+  backtrack (cadical_kitten, jump);
+  assign (cadical_kitten, not_uip, learned_ref);
+}
+
+static void failing (cadical_kitten *cadical_kitten) {
+  CADICAL_assert (cadical_kitten->inconsistent == INVALID);
+  CADICAL_assert (!EMPTY_STACK (cadical_kitten->assumptions));
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->analyzed));
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->resolved));
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->klause));
+  LOG ("analyzing failing assumptions");
+  const value *const values = cadical_kitten->values;
+  const kar *const vars = cadical_kitten->vars;
+  unsigned failed_clashing = INVALID;
+  unsigned first_failed = INVALID;
+  unsigned failed_unit = INVALID;
+  for (all_stack (unsigned, lit, cadical_kitten->assumptions)) {
+    if (values[lit] >= 0)
+      continue;
+    if (first_failed == INVALID)
+      first_failed = lit;
+    const unsigned failed_idx = lit / 2;
+    const kar *const failed_var = vars + failed_idx;
+    if (!failed_var->level) {
+      failed_unit = lit;
+      break;
+    }
+    if (failed_clashing == INVALID && failed_var->reason == INVALID)
+      failed_clashing = lit;
+  }
+  unsigned failed;
+  if (failed_unit != INVALID)
+    failed = failed_unit;
+  else if (failed_clashing != INVALID)
+    failed = failed_clashing;
+  else
+    failed = first_failed;
+  CADICAL_assert (failed != INVALID);
+  const unsigned failed_idx = failed / 2;
+  const kar *const failed_var = vars + failed_idx;
+  const unsigned failed_reason = failed_var->reason;
+  LOG ("first failed assumption %u", failed);
+  cadical_kitten->failed[failed] = true;
+
+  if (failed_unit != INVALID) {
+    CADICAL_assert (dereference_klause (cadical_kitten, failed_reason)->size == 1);
+    LOG ("root-level falsified assumption %u", failed);
+    cadical_kitten->failing = failed_reason;
+    ROG (cadical_kitten->failing, "failing reason");
+    return;
+  }
+
+  const unsigned not_failed = failed ^ 1;
+  if (failed_clashing != INVALID) {
+    LOG ("clashing with negated assumption %u", not_failed);
+    cadical_kitten->failed[not_failed] = true;
+    CADICAL_assert (cadical_kitten->failing == INVALID);
+    return;
+  }
+
+  value *marks = cadical_kitten->marks;
+  CADICAL_assert (!marks[failed_idx]);
+  marks[failed_idx] = true;
+  PUSH_STACK (cadical_kitten->analyzed, failed_idx);
+  PUSH_STACK (cadical_kitten->klause, not_failed);
+
+  unsigneds work;
+  INIT_STACK (work);
+
+  LOGLITS (BEGIN_STACK (cadical_kitten->trail), SIZE_STACK (cadical_kitten->trail),
+           "trail");
+
+  CADICAL_assert (SIZE_STACK (cadical_kitten->trail));
+  unsigned const *p = END_STACK (cadical_kitten->trail);
+  unsigned open = 1;
+  for (;;) {
+    if (!open)
+      break;
+    open--;
+    unsigned idx, uip;
+    do {
+      CADICAL_assert (BEGIN_STACK (cadical_kitten->trail) < p);
+      uip = *--p;
+    } while (!marks[idx = uip / 2]);
+
+    const kar *var = vars + idx;
+    const unsigned reason = var->reason;
+    if (reason == INVALID) {
+      unsigned lit = 2 * idx;
+      if (values[lit] < 0)
+        lit ^= 1;
+      LOG ("failed assumption %u", lit);
+      CADICAL_assert (!cadical_kitten->failed[lit]);
+      cadical_kitten->failed[lit] = true;
+      const unsigned not_lit = lit ^ 1;
+      PUSH_STACK (cadical_kitten->klause, not_lit);
+    } else {
+      ROG (reason, "analyzing");
+      PUSH_STACK (cadical_kitten->resolved, reason);
+      klause *c = dereference_klause (cadical_kitten, reason);
+      for (all_literals_in_klause (other, c)) {
+        const unsigned other_idx = other / 2;
+        if (marks[other_idx])
+          continue;
+        CADICAL_assert (other_idx != idx);
+        marks[other_idx] = true;
+        CADICAL_assert (values[other]);
+        if (vars[other_idx].level)
+          open++;
+        else
+          PUSH_STACK (work, other_idx);
+        PUSH_STACK (cadical_kitten->analyzed, other_idx);
+
+        LOG ("analyzing final literal %u", other ^ 1);
+      }
+    }
+  }
+  for (size_t next = 0; next < SIZE_STACK (work); next++) {
+    const unsigned idx = PEEK_STACK (work, next);
+    const kar *var = vars + idx;
+    const unsigned reason = var->reason;
+    if (reason == INVALID) {
+      unsigned lit = 2 * idx;
+      if (values[lit] < 0)
+        lit ^= 1;
+      LOG ("failed assumption %u", lit);
+      CADICAL_assert (!cadical_kitten->failed[lit]);
+      cadical_kitten->failed[lit] = true;
+      const unsigned not_lit = lit ^ 1;
+      PUSH_STACK (cadical_kitten->klause, not_lit);
+    } else {
+      ROG (reason, "analyzing unit");
+      PUSH_STACK (cadical_kitten->resolved, reason);
+    }
+  }
+
+  // this is bfs not dfs so it does not work for lrat :/
+  /*
+  for (size_t next = 0; next < SIZE_STACK (cadical_kitten->analyzed); next++) {
+    const unsigned idx = PEEK_STACK (cadical_kitten->analyzed, next);
+    CADICAL_assert (marks[idx]);
+    const kar *var = vars + idx;
+    const unsigned reason = var->reason;
+    if (reason == INVALID) {
+      unsigned lit = 2 * idx;
+      if (values[lit] < 0)
+        lit ^= 1;
+      LOG ("failed assumption %u", lit);
+      CADICAL_assert (!cadical_kitten->failed[lit]);
+      cadical_kitten->failed[lit] = true;
+      const unsigned not_lit = lit ^ 1;
+      PUSH_STACK (cadical_kitten->klause, not_lit);
+    } else {
+      ROG (reason, "analyzing");
+      PUSH_STACK (cadical_kitten->resolved, reason);
+      klause *c = dereference_klause (cadical_kitten, reason);
+      for (all_literals_in_klause (other, c)) {
+        const unsigned other_idx = other / 2;
+        if (other_idx == idx)
+          continue;
+        if (marks[other_idx])
+          continue;
+        marks[other_idx] = true;
+        PUSH_STACK (cadical_kitten->analyzed, other_idx);
+        LOG ("analyzing final literal %u", other ^ 1);
+      }
+    }
+  }
+  */
+
+  for (all_stack (unsigned, idx, cadical_kitten->analyzed))
+    CADICAL_assert (marks[idx]), marks[idx] = 0;
+  CLEAR_STACK (cadical_kitten->analyzed);
+
+  RELEASE_STACK (work);
+
+  const size_t resolved = SIZE_STACK (cadical_kitten->resolved);
+  CADICAL_assert (resolved);
+
+  if (resolved == 1) {
+    cadical_kitten->failing = PEEK_STACK (cadical_kitten->resolved, 0);
+    ROG (cadical_kitten->failing, "reusing as core");
+  } else {
+    cadical_kitten->failing = cadical_new_learned_klause (cadical_kitten);
+    ROG (cadical_kitten->failing, "new core");
+  }
+
+  CLEAR_STACK (cadical_kitten->resolved);
+  CLEAR_STACK (cadical_kitten->klause);
+}
+
+static void flush_trail (cadical_kitten *cadical_kitten) {
+  unsigneds *trail = &cadical_kitten->trail;
+  LOG ("flushing %zu root-level literals from trail", SIZE_STACK (*trail));
+  CADICAL_assert (!cadical_kitten->level);
+  cadical_kitten->propagated = 0;
+  CLEAR_STACK (*trail);
+}
+
+static int decide (cadical_kitten *cadical_kitten) {
+  if (!cadical_kitten->level && !EMPTY_STACK (cadical_kitten->trail))
+    flush_trail (cadical_kitten);
+
+  const value *const values = cadical_kitten->values;
+  unsigned decision = INVALID;
+  const size_t assumptions = SIZE_STACK (cadical_kitten->assumptions);
+  while (cadical_kitten->level < assumptions) {
+    unsigned assumption = PEEK_STACK (cadical_kitten->assumptions, cadical_kitten->level);
+    value value = values[assumption];
+    if (value < 0) {
+      LOG ("found failing assumption %u", assumption);
+      failing (cadical_kitten);
+      return 20;
+    } else if (value > 0) {
+
+      cadical_kitten->level++;
+      LOG ("pseudo decision level %u for already satisfied assumption %u",
+           cadical_kitten->level, assumption);
+    } else {
+      decision = assumption;
+      LOG ("using assumption %u as decision", decision);
+      break;
+    }
+  }
+
+  if (!cadical_kitten->unassigned)
+    return 10;
+
+  if (KITTEN_TICKS >= cadical_kitten->limits.ticks) {
+    LOG ("ticks limit %" PRIu64 " hit after %" PRIu64 " ticks",
+         cadical_kitten->limits.ticks, KITTEN_TICKS);
+    return -1;
+  }
+
+  if (cadical_kitten->terminator && cadical_kitten->terminator (cadical_kitten->terminator_data)) {
+    LOG ("terminator requested termination");
+    return -1;
+  }
+
+  if (decision == INVALID) {
+    unsigned idx = cadical_kitten->queue.search;
+    const kink *const links = cadical_kitten->links;
+    for (;;) {
+      CADICAL_assert (idx != INVALID);
+      if (!values[2 * idx])
+        break;
+      idx = links[idx].prev;
+    }
+    update_search (cadical_kitten, idx);
+    const unsigned phase = cadical_kitten->phases[idx];
+    decision = 2 * idx + phase;
+    LOG ("decision %u variable %u phase %u", decision, idx, phase);
+  }
+  INC (cadical_kitten_decisions);
+  cadical_kitten->level++;
+  assign (cadical_kitten, decision, INVALID);
+  return 0;
+}
+
+static void inconsistent (cadical_kitten *cadical_kitten, unsigned ref) {
+  CADICAL_assert (ref != INVALID);
+  CADICAL_assert (cadical_kitten->inconsistent == INVALID);
+
+  if (!cadical_kitten->antecedents) {
+    cadical_kitten->inconsistent = ref;
+    ROG (ref, "registering inconsistent virtually empty");
+    return;
+  }
+
+  unsigneds *analyzed = &cadical_kitten->analyzed;
+  unsigneds *resolved = &cadical_kitten->resolved;
+
+  CADICAL_assert (EMPTY_STACK (*analyzed));
+  CADICAL_assert (EMPTY_STACK (*resolved));
+
+  value *marks = cadical_kitten->marks;
+  const kar *const vars = cadical_kitten->vars;
+  unsigned next = 0;
+
+  for (;;) {
+    CADICAL_assert (ref != INVALID);
+    klause *c = dereference_klause (cadical_kitten, ref);
+    CADICAL_assert (c);
+    ROG (ref, "analyzing inconsistent");
+    PUSH_STACK (*resolved, ref);
+    for (all_literals_in_klause (lit, c)) {
+      const unsigned idx = lit / 2;
+      CADICAL_assert (!vars[idx].level);
+      if (marks[idx])
+        continue;
+      CADICAL_assert (cadical_kitten->values[lit] < 0);
+      LOG ("analyzed %u", lit);
+      marks[idx] = true;
+      PUSH_STACK (cadical_kitten->analyzed, idx);
+    }
+    if (next == SIZE_STACK (cadical_kitten->analyzed))
+      break;
+    const unsigned idx = PEEK_STACK (cadical_kitten->analyzed, next);
+    next++;
+    const kar *const v = vars + idx;
+    CADICAL_assert (!v->level);
+    ref = v->reason;
+  }
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->klause));
+  ref = cadical_new_learned_klause (cadical_kitten);
+  ROG (ref, "registering final inconsistent empty");
+  cadical_kitten->inconsistent = ref;
+
+  for (all_stack (unsigned, idx, *analyzed))
+    marks[idx] = 0;
+
+  CLEAR_STACK (*analyzed);
+  CLEAR_STACK (*resolved);
+}
+
+static int propagate_units (cadical_kitten *cadical_kitten) {
+  if (cadical_kitten->inconsistent != INVALID)
+    return 20;
+
+  if (EMPTY_STACK (cadical_kitten->units)) {
+    LOG ("no root level unit clauses");
+    return 0;
+  }
+
+  LOG ("propagating %zu root level unit clauses",
+       SIZE_STACK (cadical_kitten->units));
+
+  const value *const values = cadical_kitten->values;
+
+  for (size_t next = 0; next < SIZE_STACK (cadical_kitten->units); next++) {
+    const unsigned ref = PEEK_STACK (cadical_kitten->units, next);
+    CADICAL_assert (ref != INVALID);
+    klause *c = dereference_klause (cadical_kitten, ref);
+    CADICAL_assert (c->size == 1);
+    ROG (ref, "propagating unit");
+    const unsigned unit = c->lits[0];
+    const value value = values[unit];
+    if (value > 0)
+      continue;
+    if (value < 0) {
+      inconsistent (cadical_kitten, ref);
+      return 20;
+    }
+    assign (cadical_kitten, unit, ref);
+  }
+  const unsigned conflict = propagate (cadical_kitten);
+  if (conflict == INVALID)
+    return 0;
+  inconsistent (cadical_kitten, conflict);
+  return 20;
+}
+
+/*------------------------------------------------------------------------*/
+
+static klause *begin_klauses (cadical_kitten *cadical_kitten) {
+  return (klause *) BEGIN_STACK (cadical_kitten->klauses);
+}
+
+static klause *end_original_klauses (cadical_kitten *cadical_kitten) {
+  return (klause *) (BEGIN_STACK (cadical_kitten->klauses) +
+                     cadical_kitten->end_original_ref);
+}
+
+static klause *end_klauses (cadical_kitten *cadical_kitten) {
+  return (klause *) END_STACK (cadical_kitten->klauses);
+}
+
+static klause *next_klause (cadical_kitten *cadical_kitten, klause *c) {
+  CADICAL_assert (begin_klauses (cadical_kitten) <= c);
+  CADICAL_assert (c < end_klauses (cadical_kitten));
+  unsigned *res = c->lits + c->size;
+  if (cadical_kitten->antecedents && is_learned_klause (c))
+    res += c->aux;
+  return (klause *) res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void reset_core (cadical_kitten *cadical_kitten) {
+  LOG ("resetting core clauses");
+  size_t reset = 0;
+  for (all_klauses (c))
+    if (is_core_klause (c))
+      unset_core_klause (c), reset++;
+  LOG ("reset %zu core clauses", reset);
+  CLEAR_STACK (cadical_kitten->core);
+}
+
+static void reset_assumptions (cadical_kitten *cadical_kitten) {
+  LOG ("reset %zu assumptions", SIZE_STACK (cadical_kitten->assumptions));
+  while (!EMPTY_STACK (cadical_kitten->assumptions)) {
+    const unsigned assumption = POP_STACK (cadical_kitten->assumptions);
+    cadical_kitten->failed[assumption] = false;
+  }
+#ifndef CADICAL_NDEBUG
+  for (size_t i = 0; i < cadical_kitten->size; i++)
+    CADICAL_assert (!cadical_kitten->failed[i]);
+#endif
+  CLEAR_STACK (cadical_kitten->assumptions);
+  if (cadical_kitten->failing != INVALID) {
+    ROG (cadical_kitten->failing, "reset failed assumption reason");
+    cadical_kitten->failing = INVALID;
+  }
+}
+
+static void reset_incremental (cadical_kitten *cadical_kitten) {
+  // if (cadical_kitten->level)
+  cadical_completely_backtrack_to_root_level (cadical_kitten);
+  if (!EMPTY_STACK (cadical_kitten->assumptions))
+    reset_assumptions (cadical_kitten);
+  else
+    CADICAL_assert (cadical_kitten->failing == INVALID);
+  if (cadical_kitten->status == 21)
+    reset_core (cadical_kitten);
+  UPDATE_STATUS (0);
+}
+
+/*------------------------------------------------------------------------*/
+
+static bool flip_literal (cadical_kitten *cadical_kitten, unsigned lit) {
+  INC (cadical_kitten_flip);
+  signed char *values = cadical_kitten->values;
+  if (values[lit] < 0)
+    lit ^= 1;
+  LOG ("trying to flip value of satisfied literal %u", lit);
+  CADICAL_assert (values[lit] > 0);
+  katches *watches = cadical_kitten->watches + lit;
+  unsigned *q = BEGIN_STACK (*watches);
+  const unsigned *const end_watches = END_STACK (*watches);
+  unsigned const *p = q;
+  uint64_t ticks = (((char *) end_watches - (char *) q) >> 7) + 1;
+  bool res = true;
+  while (p != end_watches) {
+    const unsigned ref = *q++ = *p++;
+    klause *c = dereference_klause (cadical_kitten, ref);
+    unsigned *lits = c->lits;
+    const unsigned other = lits[0] ^ lits[1] ^ lit;
+    const value other_value = values[other];
+    ticks++;
+    if (other_value > 0)
+      continue;
+    value replacement_value = -1;
+    unsigned replacement = INVALID;
+    const unsigned *const end_lits = lits + c->size;
+    unsigned *r;
+    for (r = lits + 2; r != end_lits; r++) {
+      replacement = *r;
+      CADICAL_assert (replacement != lit);
+      replacement_value = values[replacement];
+      CADICAL_assert (replacement_value);
+      if (replacement_value > 0)
+        break;
+    }
+    if (replacement_value > 0) {
+      CADICAL_assert (replacement != INVALID);
+      ROG (ref, "unwatching %u in", lit);
+      lits[0] = other;
+      lits[1] = replacement;
+      *r = lit;
+      watch_klause (cadical_kitten, replacement, ref);
+      q--;
+    } else {
+      CADICAL_assert (replacement_value < 0);
+      ROG (ref, "single satisfied");
+      res = false;
+      break;
+    }
+  }
+  while (p != end_watches)
+    *q++ = *p++;
+  SET_END_OF_STACK (*watches, q);
+  ADD (cadical_kitten_ticks, ticks);
+  if (res) {
+    LOG ("flipping value of %u", lit);
+    values[lit] = -1;
+    const unsigned not_lit = lit ^ 1;
+    values[not_lit] = 1;
+    INC (cadical_kitten_flipped);
+  } else
+    LOG ("failed to flip value of %u", lit);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// this cadical specific clause addition avoids copying clauses multiple
+// times just to convert literals to unsigned representation.
+//
+static unsigned int2u (int lit) {
+  CADICAL_assert (lit != 0);
+  int idx = abs (lit) - 1;
+  return (lit < 0) + 2u * (unsigned) idx;
+}
+
+void cadical_kitten_assume (cadical_kitten *cadical_kitten, unsigned elit) {
+  REQUIRE_INITIALIZED ();
+  if (cadical_kitten->status)
+    reset_incremental (cadical_kitten);
+  const unsigned ilit = import_literal (cadical_kitten, elit);
+  LOG ("registering assumption %u", ilit);
+  PUSH_STACK (cadical_kitten->assumptions, ilit);
+}
+
+void cadical_kitten_assume_signed (cadical_kitten *cadical_kitten, int elit) {
+  unsigned kelit = int2u (elit);
+  cadical_kitten_assume (cadical_kitten, kelit);
+}
+
+void cadical_kitten_clause_with_id_and_exception (cadical_kitten *cadical_kitten, unsigned id,
+                                          size_t size,
+                                          const unsigned *elits,
+                                          unsigned except) {
+  REQUIRE_INITIALIZED ();
+  if (cadical_kitten->status)
+    reset_incremental (cadical_kitten);
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->klause));
+  const unsigned *const end = elits + size;
+  for (const unsigned *p = elits; p != end; p++) {
+    const unsigned elit = *p;
+    if (elit == except)
+      continue;
+    const unsigned ilit = import_literal (cadical_kitten, elit);
+    CADICAL_assert (ilit < cadical_kitten->lits);
+    const unsigned iidx = ilit / 2;
+    if (cadical_kitten->marks[iidx])
+      INVALID_API_USAGE ("variable '%u' of literal '%u' occurs twice",
+                         elit / 2, elit);
+    cadical_kitten->marks[iidx] = true;
+    PUSH_STACK (cadical_kitten->klause, ilit);
+  }
+  for (unsigned *p = cadical_kitten->klause.begin; p != cadical_kitten->klause.end; p++)
+    cadical_kitten->marks[*p / 2] = false;
+  new_original_klause (cadical_kitten, id);
+  CLEAR_STACK (cadical_kitten->klause);
+}
+
+void citten_clause_with_id_and_exception (cadical_kitten *cadical_kitten, unsigned id,
+                                          size_t size, const int *elits,
+                                          unsigned except) {
+  REQUIRE_INITIALIZED ();
+  if (cadical_kitten->status)
+    reset_incremental (cadical_kitten);
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->klause));
+  const int *const end = elits + size;
+  for (const int *p = elits; p != end; p++) {
+    const unsigned elit = int2u (*p); // this is the conversion
+    if (elit == except)
+      continue;
+    const unsigned ilit = import_literal (cadical_kitten, elit);
+    CADICAL_assert (ilit < cadical_kitten->lits);
+    const unsigned iidx = ilit / 2;
+    if (cadical_kitten->marks[iidx])
+      INVALID_API_USAGE ("variable '%u' of literal '%u' occurs twice",
+                         elit / 2, elit);
+    cadical_kitten->marks[iidx] = true;
+    PUSH_STACK (cadical_kitten->klause, ilit);
+  }
+  for (unsigned *p = cadical_kitten->klause.begin; p != cadical_kitten->klause.end; p++)
+    cadical_kitten->marks[*p / 2] = false;
+  new_original_klause (cadical_kitten, id);
+  CLEAR_STACK (cadical_kitten->klause);
+}
+
+void citten_clause_with_id_and_equivalence (cadical_kitten *cadical_kitten, unsigned id,
+                                            size_t size, const int *elits,
+                                            unsigned lit, unsigned other) {
+  REQUIRE_INITIALIZED ();
+  if (cadical_kitten->status)
+    reset_incremental (cadical_kitten);
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->klause));
+  bool sat = false;
+  const int *const end = elits + size;
+  for (const int *p = elits; p != end; p++) {
+    const unsigned elit = int2u (*p); // this is the conversion
+    if (elit == (lit ^ 1u) || elit == (other ^ 1u))
+      continue;
+    if (elit == lit || elit == other) {
+      sat = true;
+      break;
+    }
+    const unsigned ilit = import_literal (cadical_kitten, elit);
+    CADICAL_assert (ilit < cadical_kitten->lits);
+    const unsigned iidx = ilit / 2;
+    if (cadical_kitten->marks[iidx])
+      INVALID_API_USAGE ("variable '%u' of literal '%u' occurs twice",
+                         elit / 2, elit);
+    cadical_kitten->marks[iidx] = true;
+    PUSH_STACK (cadical_kitten->klause, ilit);
+  }
+  for (unsigned *p = cadical_kitten->klause.begin; p != cadical_kitten->klause.end; p++)
+    cadical_kitten->marks[*p / 2] = false;
+  if (!sat)
+    new_original_klause (cadical_kitten, id);
+  CLEAR_STACK (cadical_kitten->klause);
+}
+
+void cadical_kitten_clause (cadical_kitten *cadical_kitten, size_t size, unsigned *elits) {
+  cadical_kitten_clause_with_id_and_exception (cadical_kitten, INVALID, size, elits,
+                                       INVALID);
+}
+
+void citten_clause_with_id (cadical_kitten *cadical_kitten, unsigned id, size_t size,
+                            int *elits) {
+  citten_clause_with_id_and_exception (cadical_kitten, id, size, elits, INVALID);
+}
+
+void cadical_kitten_unit (cadical_kitten *cadical_kitten, unsigned lit) {
+  cadical_kitten_clause (cadical_kitten, 1, &lit);
+}
+
+void cadical_kitten_binary (cadical_kitten *cadical_kitten, unsigned a, unsigned b) {
+  unsigned clause[2] = {a, b};
+  cadical_kitten_clause (cadical_kitten, 2, clause);
+}
+
+int cadical_kitten_solve (cadical_kitten *cadical_kitten) {
+  REQUIRE_INITIALIZED ();
+  if (cadical_kitten->status)
+    reset_incremental (cadical_kitten);
+  else // if (cadical_kitten->level)
+    cadical_completely_backtrack_to_root_level (cadical_kitten);
+
+  LOG ("starting solving under %zu assumptions",
+       SIZE_STACK (cadical_kitten->assumptions));
+
+  INC (cadical_kitten_solved);
+
+  int res = propagate_units (cadical_kitten);
+  while (!res) {
+    const unsigned conflict = propagate (cadical_kitten);
+    if (cadical_kitten->terminator &&
+        cadical_kitten->terminator (cadical_kitten->terminator_data)) {
+      LOG ("terminator requested termination");
+      res = -1;
+      break;
+    }
+    if (conflict != INVALID) {
+      if (cadical_kitten->level)
+        analyze (cadical_kitten, conflict);
+      else {
+        inconsistent (cadical_kitten, conflict);
+        res = 20;
+      }
+    } else
+      res = decide (cadical_kitten);
+  }
+
+  if (res < 0)
+    res = 0;
+
+  if (!res && !EMPTY_STACK (cadical_kitten->assumptions))
+    reset_assumptions (cadical_kitten);
+
+  UPDATE_STATUS (res);
+
+  if (res == 10)
+    INC (cadical_kitten_sat);
+  else if (res == 20)
+    INC (cadical_kitten_unsat);
+  else
+    INC (cadical_kitten_unknown);
+
+  LOG ("finished solving with result %d", res);
+
+  return res;
+}
+
+int cadical_kitten_status (cadical_kitten *cadical_kitten) { return cadical_kitten->status; }
+
+unsigned cadical_kitten_compute_clausal_core (cadical_kitten *cadical_kitten,
+                                      uint64_t *learned_ptr) {
+  REQUIRE_STATUS (20);
+
+  if (!cadical_kitten->antecedents)
+    INVALID_API_USAGE ("antecedents not tracked");
+
+  LOG ("computing clausal core");
+
+  unsigneds *resolved = &cadical_kitten->resolved;
+  CADICAL_assert (EMPTY_STACK (*resolved));
+
+  unsigned original = 0;
+  uint64_t learned = 0;
+
+  unsigned reason_ref = cadical_kitten->inconsistent;
+
+  if (reason_ref == INVALID) {
+    CADICAL_assert (!EMPTY_STACK (cadical_kitten->assumptions));
+    reason_ref = cadical_kitten->failing;
+    if (reason_ref == INVALID) {
+      LOG ("assumptions mutually inconsistent");
+      //goto DONE;
+        if (learned_ptr)
+          *learned_ptr = learned;
+        
+        LOG ("clausal core of %u original clauses", original);
+        LOG ("clausal core of %" PRIu64 " learned clauses", learned);
+        cadical_kitten->statistics.original = original;
+        cadical_kitten->statistics.learned = 0;
+        UPDATE_STATUS (21);
+        
+        return original;
+    }
+  }
+
+  PUSH_STACK (*resolved, reason_ref);
+  unsigneds *core = &cadical_kitten->core;
+  CADICAL_assert (EMPTY_STACK (*core));
+
+  while (!EMPTY_STACK (*resolved)) {
+    const unsigned c_ref = POP_STACK (*resolved);
+    if (c_ref == INVALID) {
+      const unsigned d_ref = POP_STACK (*resolved);
+      ROG (d_ref, "core[%zu]", SIZE_STACK (*core));
+      PUSH_STACK (*core, d_ref);
+      klause *d = dereference_klause (cadical_kitten, d_ref);
+      CADICAL_assert (!is_core_klause (d));
+      set_core_klause (d);
+      if (is_learned_klause (d))
+        learned++;
+      else
+        original++;
+    } else {
+      klause *c = dereference_klause (cadical_kitten, c_ref);
+      if (is_core_klause (c))
+        continue;
+      PUSH_STACK (*resolved, c_ref);
+      PUSH_STACK (*resolved, INVALID);
+      ROG (c_ref, "analyzing antecedent core");
+      if (!is_learned_klause (c))
+        continue;
+      for (all_antecedents (d_ref, c)) {
+        klause *d = dereference_klause (cadical_kitten, d_ref);
+        if (!is_core_klause (d))
+          PUSH_STACK (*resolved, d_ref);
+      }
+    }
+  }
+
+  //DONE:
+
+  if (learned_ptr)
+    *learned_ptr = learned;
+
+  LOG ("clausal core of %u original clauses", original);
+  LOG ("clausal core of %" PRIu64 " learned clauses", learned);
+  cadical_kitten->statistics.original = original;
+  cadical_kitten->statistics.learned = 0;
+  UPDATE_STATUS (21);
+
+  return original;
+}
+
+void cadical_kitten_traverse_core_ids (cadical_kitten *cadical_kitten, void *state,
+                               void (*traverse) (void *, unsigned)) {
+  REQUIRE_STATUS (21);
+
+  LOG ("traversing core of original clauses");
+
+  unsigned traversed = 0;
+
+  for (all_original_klauses (c)) {
+    // only happens for 'true' incremental calls, i.e. if add happens after
+    // solve
+    if (is_learned_klause (c))
+      continue;
+    if (!is_core_klause (c))
+      continue;
+    ROG (reference_klause (cadical_kitten, c), "traversing");
+    traverse (state, c->aux);
+    traversed++;
+  }
+
+  LOG ("traversed %u original core clauses", traversed);
+  (void) traversed;
+
+  CADICAL_assert (cadical_kitten->status == 21);
+}
+
+void cadical_kitten_traverse_core_clauses (cadical_kitten *cadical_kitten, void *state,
+                                   void (*traverse) (void *, bool, size_t,
+                                                     const unsigned *)) {
+  REQUIRE_STATUS (21);
+
+  LOG ("traversing clausal core");
+
+  unsigned traversed = 0;
+
+  for (all_stack (unsigned, c_ref, cadical_kitten->core)) {
+    klause *c = dereference_klause (cadical_kitten, c_ref);
+    CADICAL_assert (is_core_klause (c));
+    const bool learned = is_learned_klause (c);
+    unsigneds *eclause = &cadical_kitten->eclause;
+    CADICAL_assert (EMPTY_STACK (*eclause));
+    for (all_literals_in_klause (ilit, c)) {
+      const unsigned elit = export_literal (cadical_kitten, ilit);
+      PUSH_STACK (*eclause, elit);
+    }
+    const size_t size = SIZE_STACK (*eclause);
+    const unsigned *elits = eclause->begin;
+    ROG (reference_klause (cadical_kitten, c), "traversing");
+    traverse (state, learned, size, elits);
+    CLEAR_STACK (*eclause);
+    traversed++;
+  }
+
+  LOG ("traversed %u core clauses", traversed);
+  (void) traversed;
+
+  CADICAL_assert (cadical_kitten->status == 21);
+}
+
+void cadical_kitten_traverse_core_clauses_with_id (
+    cadical_kitten *cadical_kitten, void *state,
+    void (*traverse) (void *state, unsigned, bool learned, size_t,
+                      const unsigned *)) {
+  REQUIRE_STATUS (21);
+
+  LOG ("traversing clausal core");
+
+  unsigned traversed = 0;
+
+  for (all_stack (unsigned, c_ref, cadical_kitten->core)) {
+    klause *c = dereference_klause (cadical_kitten, c_ref);
+    CADICAL_assert (is_core_klause (c));
+    const bool learned = is_learned_klause (c);
+    unsigneds *eclause = &cadical_kitten->eclause;
+    CADICAL_assert (EMPTY_STACK (*eclause));
+    for (all_literals_in_klause (ilit, c)) {
+      const unsigned elit = export_literal (cadical_kitten, ilit);
+      PUSH_STACK (*eclause, elit);
+    }
+    const size_t size = SIZE_STACK (*eclause);
+    const unsigned *elits = eclause->begin;
+    ROG (reference_klause (cadical_kitten, c), "traversing");
+    unsigned ctag = learned ? 0 : c->aux;
+    traverse (state, ctag, learned, size, elits);
+    CLEAR_STACK (*eclause);
+    traversed++;
+  }
+
+  LOG ("traversed %u core clauses", traversed);
+  (void) traversed;
+
+  CADICAL_assert (cadical_kitten->status == 21);
+}
+
+void cadical_kitten_trace_core (cadical_kitten *cadical_kitten, void *state,
+                        void (*trace) (void *, unsigned, unsigned, bool,
+                                       size_t, const unsigned *, size_t,
+                                       const unsigned *)) {
+  REQUIRE_STATUS (21);
+
+  LOG ("tracing clausal core");
+
+  unsigned traced = 0;
+
+  for (all_stack (unsigned, c_ref, cadical_kitten->core)) {
+    klause *c = dereference_klause (cadical_kitten, c_ref);
+    CADICAL_assert (is_core_klause (c));
+    const bool learned = is_learned_klause (c);
+    unsigneds *eclause = &cadical_kitten->eclause;
+    CADICAL_assert (EMPTY_STACK (*eclause));
+    for (all_literals_in_klause (ilit, c)) {
+      const unsigned elit = export_literal (cadical_kitten, ilit);
+      PUSH_STACK (*eclause, elit);
+    }
+    const size_t size = SIZE_STACK (*eclause);
+    const unsigned *elits = eclause->begin;
+
+    unsigneds *resolved = &cadical_kitten->resolved;
+    CADICAL_assert (EMPTY_STACK (*resolved));
+    if (learned) {
+      for (all_antecedents (ref, c)) {
+        PUSH_STACK (*resolved, ref);
+      }
+    }
+    const size_t rsize = SIZE_STACK (*resolved);
+    const unsigned *rids = resolved->begin;
+
+    unsigned cid = reference_klause (cadical_kitten, c);
+    unsigned ctag = learned ? 0 : c->aux;
+    ROG (cid, "tracing");
+    trace (state, cid, ctag, learned, size, elits, rsize, rids);
+    CLEAR_STACK (*eclause);
+    CLEAR_STACK (*resolved);
+    traced++;
+  }
+
+  LOG ("traced %u core clauses", traced);
+  (void) traced;
+
+  CADICAL_assert (cadical_kitten->status == 21);
+}
+
+void cadical_kitten_shrink_to_clausal_core (cadical_kitten *cadical_kitten) {
+  REQUIRE_STATUS (21);
+
+  LOG ("shrinking formula to core of original clauses");
+
+  CLEAR_STACK (cadical_kitten->trail);
+
+  cadical_kitten->unassigned = cadical_kitten->lits / 2;
+  cadical_kitten->propagated = 0;
+  cadical_kitten->level = 0;
+
+  update_search (cadical_kitten, cadical_kitten->queue.last);
+
+  memset (cadical_kitten->values, 0, cadical_kitten->lits);
+
+  for (all_kits (lit))
+    CLEAR_STACK (KATCHES (lit));
+
+  CADICAL_assert (cadical_kitten->inconsistent != INVALID);
+  klause *inconsistent = dereference_klause (cadical_kitten, cadical_kitten->inconsistent);
+  if (is_learned_klause (inconsistent) || inconsistent->size) {
+    ROG (cadical_kitten->inconsistent, "resetting inconsistent");
+    cadical_kitten->inconsistent = INVALID;
+  } else
+    ROG (cadical_kitten->inconsistent, "keeping inconsistent");
+
+  CLEAR_STACK (cadical_kitten->units);
+
+  klause *begin = begin_klauses (cadical_kitten), *q = begin;
+  klause const *const end = end_original_klauses (cadical_kitten);
+#ifdef LOGGING
+  unsigned original = 0;
+#endif
+  for (klause *c = begin, *next; c != end; c = next) {
+    next = next_klause (cadical_kitten, c);
+    // CADICAL_assert (!is_learned_klause (c)); not necessarily true
+    if (is_learned_klause (c))
+      continue;
+    if (!is_core_klause (c))
+      continue;
+    unset_core_klause (c);
+    const unsigned dst = (unsigned *) q - (unsigned *) begin;
+    const unsigned size = c->size;
+    if (!size) {
+      if (cadical_kitten->inconsistent != INVALID)
+        cadical_kitten->inconsistent = dst;
+    } else if (size == 1) {
+      PUSH_STACK (cadical_kitten->units, dst);
+      ROG (dst, "keeping");
+    } else {
+      watch_klause (cadical_kitten, c->lits[0], dst);
+      watch_klause (cadical_kitten, c->lits[1], dst);
+    }
+    if (c == q)
+      q = next;
+    else {
+      const size_t bytes = (char *) next - (char *) c;
+      memmove (q, c, bytes);
+      q = (klause *) ((char *) q + bytes);
+    }
+#ifdef LOGGING
+    original++;
+#endif
+  }
+  SET_END_OF_STACK (cadical_kitten->klauses, (unsigned *) q);
+  cadical_kitten->end_original_ref = SIZE_STACK (cadical_kitten->klauses);
+  LOG ("end of original clauses at %zu", cadical_kitten->end_original_ref);
+  LOG ("%u original clauses left", original);
+
+  CLEAR_STACK (cadical_kitten->core);
+
+  UPDATE_STATUS (0);
+}
+
+signed char cadical_kitten_signed_value (cadical_kitten *cadical_kitten, int selit) {
+  REQUIRE_STATUS (10);
+  const unsigned elit = int2u (selit);
+  const unsigned eidx = elit / 2;
+  if (eidx >= cadical_kitten->evars)
+    return 0;
+  unsigned iidx = cadical_kitten->import[eidx];
+  if (!iidx)
+    return 0;
+  const unsigned ilit = 2 * (iidx - 1) + (elit & 1);
+  return cadical_kitten->values[ilit];
+}
+
+signed char cadical_kitten_value (cadical_kitten *cadical_kitten, unsigned elit) {
+  REQUIRE_STATUS (10);
+  const unsigned eidx = elit / 2;
+  if (eidx >= cadical_kitten->evars)
+    return 0;
+  unsigned iidx = cadical_kitten->import[eidx];
+  if (!iidx)
+    return 0;
+  const unsigned ilit = 2 * (iidx - 1) + (elit & 1);
+  return cadical_kitten->values[ilit];
+}
+
+signed char cadical_kitten_fixed (cadical_kitten *cadical_kitten, unsigned elit) {
+  const unsigned eidx = elit / 2;
+  if (eidx >= cadical_kitten->evars)
+    return 0;
+  unsigned iidx = cadical_kitten->import[eidx];
+  if (!iidx)
+    return 0;
+  iidx--;
+  const unsigned ilit = 2 * iidx + (elit & 1);
+  signed char res = cadical_kitten->values[ilit];
+  if (!res)
+    return 0;
+  kar *v = cadical_kitten->vars + iidx;
+  if (v->level)
+    return 0;
+  return res;
+}
+
+signed char cadical_kitten_fixed_signed (cadical_kitten *cadical_kitten, int elit) {
+  unsigned kelit = int2u (elit);
+  return cadical_kitten_fixed (cadical_kitten, kelit);
+}
+
+bool cadical_kitten_flip_literal (cadical_kitten *cadical_kitten, unsigned elit) {
+  REQUIRE_STATUS (10);
+  const unsigned eidx = elit / 2;
+  if (eidx >= cadical_kitten->evars)
+    return false;
+  unsigned iidx = cadical_kitten->import[eidx];
+  if (!iidx)
+    return false;
+  const unsigned ilit = 2 * (iidx - 1) + (elit & 1);
+  if (cadical_kitten_fixed (cadical_kitten, elit))
+    return false;
+  return flip_literal (cadical_kitten, ilit);
+}
+
+bool cadical_kitten_flip_signed_literal (cadical_kitten *cadical_kitten, int elit) {
+  REQUIRE_STATUS (10);
+  unsigned kelit = int2u (elit);
+  return cadical_kitten_flip_literal (cadical_kitten, kelit);
+}
+
+bool cadical_kitten_failed (cadical_kitten *cadical_kitten, unsigned elit) {
+  REQUIRE_STATUS (20);
+  const unsigned eidx = elit / 2;
+  if (eidx >= cadical_kitten->evars)
+    return false;
+  unsigned iidx = cadical_kitten->import[eidx];
+  if (!iidx)
+    return false;
+  const unsigned ilit = 2 * (iidx - 1) + (elit & 1);
+  return cadical_kitten->failed[ilit];
+}
+
+// checks both watches for clauses with only one literal positively
+// assigned. if such a clause is found, return false. Otherwise fix watch
+// invariant and return true
+static bool prime_propagate (cadical_kitten *cadical_kitten, const unsigned idx,
+                             void *state, const bool ignoring,
+                             bool (*ignore) (void *, unsigned)) {
+  unsigned lit = 2 * idx;
+  unsigned conflict = INVALID;
+  value *values = cadical_kitten->values;
+  for (int i = 0; i < 2; i++) {
+    if (conflict != INVALID)
+      break;
+    lit = lit ^ i;
+    const unsigned not_lit = lit ^ 1;
+    katches *watches = cadical_kitten->watches + not_lit;
+    unsigned *q = BEGIN_STACK (*watches);
+    const unsigned *const end_watches = END_STACK (*watches);
+    unsigned const *p = q;
+    uint64_t ticks = (((char *) end_watches - (char *) q) >> 7) + 1;
+    while (p != end_watches) {
+      const unsigned ref = *q++ = *p++;
+      klause *c = dereference_klause (cadical_kitten, ref);
+      if (is_learned_klause (c) || ignore (state, c->aux) == ignoring)
+        continue;
+      CADICAL_assert (c->size > 1);
+      unsigned *lits = c->lits;
+      const unsigned other = lits[0] ^ lits[1] ^ not_lit;
+      const value other_value = values[other];
+      ticks++;
+      if (other_value > 0)
+        continue;
+      value replacement_value = -1;
+      unsigned replacement = INVALID;
+      const unsigned *const end_lits = lits + c->size;
+      unsigned *r;
+      for (r = lits + 2; r != end_lits; r++) {
+        replacement = *r;
+        replacement_value = values[replacement];
+        if (replacement_value > 0)
+          break;
+      }
+      if (replacement_value > 0) {
+        CADICAL_assert (replacement != INVALID);
+        ROG (ref, "unwatching %u in", not_lit);
+        lits[0] = other;
+        lits[1] = replacement;
+        *r = not_lit;
+        watch_klause (cadical_kitten, replacement, ref);
+        q--;
+      } else {
+        ROG (ref, "idx %u forced prime by", idx);
+        conflict = ref;
+        break;
+      }
+    }
+    while (p != end_watches)
+      *q++ = *p++;
+    SET_END_OF_STACK (*watches, q);
+    ADD (cadical_kitten_ticks, ticks);
+  }
+  return conflict == INVALID;
+}
+
+void cadical_kitten_add_prime_implicant (cadical_kitten *cadical_kitten, void *state, int side,
+                                 void (*add_implicant) (void *, int, size_t,
+                                                        const unsigned *)) {
+  REQUIRE_STATUS (11);
+  // might be possible in some edge cases
+  unsigneds *prime = &cadical_kitten->prime[side];
+  unsigneds *prime2 = &cadical_kitten->prime[!side];
+  CADICAL_assert (!EMPTY_STACK (*prime) || !EMPTY_STACK (*prime2));
+  CLEAR_STACK (*prime2);
+
+  for (all_stack (unsigned, lit, *prime)) {
+    const unsigned not_lit = lit ^ 1;
+    const unsigned elit = export_literal (cadical_kitten, not_lit);
+    PUSH_STACK (*prime2, elit);
+  }
+
+  // adds a clause which will reset cadical_kitten status and backtrack
+  add_implicant (state, side, SIZE_STACK (*prime2), BEGIN_STACK (*prime2));
+  CLEAR_STACK (*prime);
+  CLEAR_STACK (*prime2);
+}
+
+// computes two prime implicants, only considering clauses based on ignore
+// return -1 if no prime implicant has been computed, otherwise returns
+// index of shorter implicant.
+// TODO does not work if flip has been called beforehand
+int cadical_kitten_compute_prime_implicant (cadical_kitten *cadical_kitten, void *state,
+                                    bool (*ignore) (void *, unsigned)) {
+  REQUIRE_STATUS (10);
+
+  value *values = cadical_kitten->values;
+  kar *vars = cadical_kitten->vars;
+  unsigneds unassigned;
+  INIT_STACK (unassigned);
+  bool limit_hit = 0;
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->prime[0]) && EMPTY_STACK (cadical_kitten->prime[1]));
+  for (int i = 0; i < 2; i++) {
+    const bool ignoring = i;
+    for (all_stack (unsigned, lit, cadical_kitten->trail)) {
+      if (KITTEN_TICKS >= cadical_kitten->limits.ticks) {
+        LOG ("ticks limit %" PRIu64 " hit after %" PRIu64 " ticks",
+             cadical_kitten->limits.ticks, KITTEN_TICKS);
+        limit_hit = 1;
+        break;
+      }
+      CADICAL_assert (values[lit] > 0);
+      const unsigned idx = lit / 2;
+      const unsigned ref = vars[idx].reason;
+      CADICAL_assert (vars[idx].level);
+      klause *c = 0;
+      if (ref != INVALID)
+        c = dereference_klause (cadical_kitten, ref);
+      if (ref == INVALID || is_learned_klause (c) ||
+          ignore (state, c->aux) == ignoring) {
+        LOG ("non-prime candidate var %d", idx);
+        if (prime_propagate (cadical_kitten, idx, state, ignoring, ignore)) {
+          values[lit] = 0;
+          values[lit ^ 1] = 0;
+          PUSH_STACK (unassigned, lit);
+        } else
+          CADICAL_assert (values[lit] > 0);
+      }
+    }
+    unsigneds *prime = &cadical_kitten->prime[i];
+    // push on prime implicant stack.
+    for (all_kits (lit)) {
+      if (values[lit] > 0)
+        PUSH_STACK (*prime, lit);
+    }
+    // reassign all literals on
+    for (all_stack (unsigned, lit, unassigned)) {
+      CADICAL_assert (!values[lit]);
+      values[lit] = 1;
+      values[lit ^ 1] = -1;
+    }
+    CLEAR_STACK (unassigned);
+  }
+  RELEASE_STACK (unassigned);
+
+  if (limit_hit) {
+    CLEAR_STACK (cadical_kitten->prime[0]);
+    CLEAR_STACK (cadical_kitten->prime[1]);
+    return -1;
+  }
+  // the only case when one of the prime implicants is allowed to be empty
+  // is if ignore returns always true or always false.
+  CADICAL_assert (!EMPTY_STACK (cadical_kitten->prime[0]) ||
+          !EMPTY_STACK (cadical_kitten->prime[1]));
+  UPDATE_STATUS (11);
+
+  int res = SIZE_STACK (cadical_kitten->prime[0]) > SIZE_STACK (cadical_kitten->prime[1]);
+  return res;
+}
+
+static bool contains_blit (cadical_kitten *cadical_kitten, klause *c, const unsigned blit) {
+  for (all_literals_in_klause (lit, c)) {
+    if (lit == blit)
+      return true;
+  }
+  return false;
+}
+
+static bool prime_propagate_blit (cadical_kitten *cadical_kitten, const unsigned idx,
+                                  const unsigned blit) {
+  unsigned lit = 2 * idx;
+  unsigned conflict = INVALID;
+  value *values = cadical_kitten->values;
+  LOG ("prime propagating idx %u for blit %u", idx, blit);
+  for (int i = 0; i < 2; i++) {
+    if (conflict != INVALID)
+      break;
+    lit = lit ^ i;
+    if (lit == blit)
+      continue;
+    const unsigned not_lit = lit ^ 1;
+    katches *watches = cadical_kitten->watches + not_lit;
+    unsigned *q = BEGIN_STACK (*watches);
+    const unsigned *const end_watches = END_STACK (*watches);
+    unsigned const *p = q;
+    uint64_t ticks = (((char *) end_watches - (char *) q) >> 7) + 1;
+    while (p != end_watches) {
+      const unsigned ref = *q++ = *p++;
+      klause *c = dereference_klause (cadical_kitten, ref);
+      if (is_learned_klause (c))
+        continue;
+      ROG (ref, "checking with blit %u", blit);
+      CADICAL_assert (c->size > 1);
+      unsigned *lits = c->lits;
+      const unsigned other = lits[0] ^ lits[1] ^ not_lit;
+      const value other_value = values[other];
+      ticks++;
+      bool use = other == blit || not_lit == blit;
+      if (other_value > 0)
+        continue;
+      value replacement_value = -1;
+      unsigned replacement = INVALID;
+      const unsigned *const end_lits = lits + c->size;
+      unsigned *r;
+      for (r = lits + 2; r != end_lits; r++) {
+        replacement = *r;
+        replacement_value = values[replacement];
+        use = use || replacement == blit;
+        if (replacement_value > 0)
+          break;
+      }
+      if (replacement_value > 0) {
+        CADICAL_assert (replacement != INVALID);
+        ROG (ref, "unwatching %u in", not_lit);
+        lits[0] = other;
+        lits[1] = replacement;
+        *r = not_lit;
+        watch_klause (cadical_kitten, replacement, ref);
+        q--;
+      } else if (!use) {
+        continue;
+      } else {
+        ROG (ref, "idx %u forced prime by", idx);
+        conflict = ref;
+        break;
+      }
+    }
+    while (p != end_watches)
+      *q++ = *p++;
+    SET_END_OF_STACK (*watches, q);
+    ADD (cadical_kitten_ticks, ticks);
+  }
+  return conflict == INVALID;
+}
+
+static int compute_prime_implicant_for (cadical_kitten *cadical_kitten, unsigned blit) {
+  value *values = cadical_kitten->values;
+  kar *vars = cadical_kitten->vars;
+  unsigneds unassigned;
+  INIT_STACK (unassigned);
+  bool limit_hit = false;
+  CADICAL_assert (EMPTY_STACK (cadical_kitten->prime[0]) && EMPTY_STACK (cadical_kitten->prime[1]));
+  for (int i = 0; i < 2; i++) {
+    const unsigned block = blit ^ i;
+    const bool ignoring = i;
+    if (prime_propagate_blit (cadical_kitten, block / 2, block)) {
+      value tmp = values[blit];
+      CADICAL_assert (tmp);
+      values[blit] = 0;
+      values[blit ^ 1] = 0;
+      PUSH_STACK (unassigned, tmp > 0 ? blit : blit ^ 1);
+      PUSH_STACK (cadical_kitten->prime[i], block); // will be negated!
+    } else
+      CADICAL_assert (false);
+    for (all_stack (unsigned, lit, cadical_kitten->trail)) {
+      if (KITTEN_TICKS >= cadical_kitten->limits.ticks) {
+        LOG ("ticks limit %" PRIu64 " hit after %" PRIu64 " ticks",
+             cadical_kitten->limits.ticks, KITTEN_TICKS);
+        limit_hit = true;
+        break;
+      }
+      if (!values[lit])
+        continue;
+      CADICAL_assert (values[lit]); // not true when flipping is involved
+      const unsigned idx = lit / 2;
+      const unsigned ref = vars[idx].reason;
+      CADICAL_assert (vars[idx].level);
+      LOG ("non-prime candidate var %d", idx);
+      if (prime_propagate_blit (cadical_kitten, idx, block)) {
+        value tmp = values[lit];
+        CADICAL_assert (tmp);
+        values[lit] = 0;
+        values[lit ^ 1] = 0;
+        PUSH_STACK (unassigned, tmp > 0 ? lit : lit ^ 1);
+      }
+    }
+    unsigneds *prime = &cadical_kitten->prime[i];
+    // push on prime implicant stack.
+    for (all_kits (lit)) {
+      if (values[lit] > 0)
+        PUSH_STACK (*prime, lit);
+    }
+    // reassign all literals on
+    for (all_stack (unsigned, lit, unassigned)) {
+      CADICAL_assert (!values[lit]);
+      values[lit] = 1;
+      values[lit ^ 1] = -1;
+    }
+    CLEAR_STACK (unassigned);
+  }
+  RELEASE_STACK (unassigned);
+
+  if (limit_hit) {
+    CLEAR_STACK (cadical_kitten->prime[0]);
+    CLEAR_STACK (cadical_kitten->prime[1]);
+    return -1;
+  }
+  // the only case when one of the prime implicants is allowed to be empty
+  // is if ignore returns always true or always false.
+  CADICAL_assert (!EMPTY_STACK (cadical_kitten->prime[0]) ||
+          !EMPTY_STACK (cadical_kitten->prime[1]));
+  LOGLITS (BEGIN_STACK (cadical_kitten->prime[0]), SIZE_STACK (cadical_kitten->prime[0]),
+           "first implicant %u", blit);
+  LOGLITS (BEGIN_STACK (cadical_kitten->prime[1]), SIZE_STACK (cadical_kitten->prime[1]),
+           "second implicant %u", blit ^ 1);
+  UPDATE_STATUS (11);
+
+  int res = SIZE_STACK (cadical_kitten->prime[0]) > SIZE_STACK (cadical_kitten->prime[1]);
+  return res;
+}
+
+int cadical_kitten_flip_and_implicant_for_signed_literal (cadical_kitten *cadical_kitten,
+                                                  int elit) {
+  REQUIRE_STATUS (10);
+  unsigned kelit = int2u (elit);
+  if (!cadical_kitten_flip_literal (cadical_kitten, kelit)) {
+    return -2;
+  }
+  const unsigned eidx = kelit / 2;
+  unsigned iidx = cadical_kitten->import[eidx];
+  CADICAL_assert (iidx);
+  const unsigned ilit = 2 * (iidx - 1) + (kelit & 1);
+  return compute_prime_implicant_for (cadical_kitten, ilit);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_lidruptracer.cpp b/src/sat/cadical/cadical_lidruptracer.cpp
new file mode 100644
index 000000000..db07e36e6
--- /dev/null
+++ b/src/sat/cadical/cadical_lidruptracer.cpp
@@ -0,0 +1,662 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+LidrupTracer::LidrupTracer (Internal *i, File *f, bool b)
+    : internal (i), file (f), binary (b), num_clauses (0), size_clauses (0),
+      clauses (0), last_hash (0), last_id (0), last_clause (0)
+#ifndef CADICAL_QUIET
+      ,
+      added (0), deleted (0)
+#endif
+{
+  (void) internal;
+
+  // Initialize random number table for hash function.
+  //
+  Random random (42);
+  for (unsigned n = 0; n < num_nonces; n++) {
+    uint64_t nonce = random.next ();
+    if (!(nonce & 1))
+      nonce++;
+    CADICAL_assert (nonce), CADICAL_assert (nonce & 1);
+    nonces[n] = nonce;
+  }
+#ifndef CADICAL_NDEBUG
+  binary = b;
+#else
+  (void) b;
+#endif
+  piping = file->piping ();
+}
+
+void LidrupTracer::connect_internal (Internal *i) {
+  internal = i;
+  file->connect_internal (internal);
+  LOG ("LIDRUP TRACER connected to internal");
+}
+
+LidrupTracer::~LidrupTracer () {
+  LOG ("LIDRUP TRACER delete");
+  delete file;
+  for (size_t i = 0; i < size_clauses; i++)
+    for (LidrupClause *c = clauses[i], *next; c; c = next)
+      next = c->next, delete_clause (c);
+  delete[] clauses;
+}
+
+/*------------------------------------------------------------------------*/
+
+void LidrupTracer::enlarge_clauses () {
+  CADICAL_assert (num_clauses == size_clauses);
+  const uint64_t new_size_clauses = size_clauses ? 2 * size_clauses : 1;
+  LOG ("LIDRUP Tracer enlarging clauses of tracer from %" PRIu64
+       " to %" PRIu64,
+       (uint64_t) size_clauses, (uint64_t) new_size_clauses);
+  LidrupClause **new_clauses;
+  new_clauses = new LidrupClause *[new_size_clauses];
+  clear_n (new_clauses, new_size_clauses);
+  for (uint64_t i = 0; i < size_clauses; i++) {
+    for (LidrupClause *c = clauses[i], *next; c; c = next) {
+      next = c->next;
+      const uint64_t h = reduce_hash (c->hash, new_size_clauses);
+      c->next = new_clauses[h];
+      new_clauses[h] = c;
+    }
+  }
+  delete[] clauses;
+  clauses = new_clauses;
+  size_clauses = new_size_clauses;
+}
+
+LidrupClause *LidrupTracer::new_clause () {
+  LidrupClause *res = new LidrupClause;
+  res->next = 0;
+  res->hash = last_hash;
+  res->id = last_id;
+  for (const auto &id : imported_chain) {
+    res->chain.push_back (id);
+  }
+  for (const auto &lit : imported_clause) {
+    res->literals.push_back (lit);
+  }
+  last_clause = res;
+  num_clauses++;
+  return res;
+}
+
+void LidrupTracer::delete_clause (LidrupClause *c) {
+  CADICAL_assert (c);
+  num_clauses--;
+  delete c;
+}
+
+uint64_t LidrupTracer::reduce_hash (uint64_t hash, uint64_t size) {
+  CADICAL_assert (size > 0);
+  unsigned shift = 32;
+  uint64_t res = hash;
+  while ((((uint64_t) 1) << shift) > size) {
+    res ^= res >> shift;
+    shift >>= 1;
+  }
+  res &= size - 1;
+  CADICAL_assert (res < size);
+  return res;
+}
+
+uint64_t LidrupTracer::compute_hash (const int64_t id) {
+  CADICAL_assert (id > 0);
+  unsigned j = id % num_nonces;
+  uint64_t tmp = nonces[j] * (uint64_t) id;
+  return last_hash = tmp;
+}
+
+bool LidrupTracer::find_and_delete (const int64_t id) {
+  if (!num_clauses)
+    return false;
+  LidrupClause **res = 0, *c;
+  const uint64_t hash = compute_hash (id);
+  const uint64_t h = reduce_hash (hash, size_clauses);
+  for (res = clauses + h; (c = *res); res = &c->next) {
+    if (c->hash == hash && c->id == id) {
+      break;
+    }
+    if (!c->next)
+      return false;
+  }
+  if (!c)
+    return false;
+  CADICAL_assert (c && res);
+  *res = c->next;
+  for (auto &lit : c->literals) {
+    imported_clause.push_back (lit);
+  }
+  for (auto &cid : c->chain) {
+    imported_chain.push_back (cid);
+  }
+  delete_clause (c);
+  return true;
+}
+
+void LidrupTracer::insert () {
+  if (num_clauses == size_clauses)
+    enlarge_clauses ();
+  const uint64_t h = reduce_hash (compute_hash (last_id), size_clauses);
+  LidrupClause *c = new_clause ();
+  c->next = clauses[h];
+  clauses[h] = c;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void LidrupTracer::flush_if_piping () {
+  if (piping)
+    file->flush ();
+}
+
+inline void LidrupTracer::put_binary_zero () {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  file->put ((unsigned char) 0);
+}
+
+inline void LidrupTracer::put_binary_lit (int lit) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  CADICAL_assert (lit != INT_MIN);
+  unsigned x = 2 * abs (lit) + (lit < 0);
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+inline void LidrupTracer::put_binary_id (int64_t id, bool can_be_negative) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  uint64_t x = abs (id);
+  if (can_be_negative) {
+    x = 2 * x + (id < 0);
+  }
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+/*------------------------------------------------------------------------*/
+
+void LidrupTracer::lidrup_add_restored_clause (int64_t id) {
+  if (!batch_weaken.empty () || !batch_delete.empty ())
+    lidrup_batch_weaken_restore_and_delete ();
+  batch_restore.push_back (id);
+}
+
+void LidrupTracer::lidrup_add_derived_clause (
+    int64_t id, const vector<int> &clause, const vector<int64_t> &chain) {
+  lidrup_batch_weaken_restore_and_delete ();
+  if (binary) {
+    file->put ('l');
+    put_binary_id (id);
+  } else {
+    file->put ("l ");
+    file->put (id);
+    file->put (' ');
+  }
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0 ");
+  for (const auto &cid : chain)
+    if (binary)
+      put_binary_id (cid);
+    else
+      file->put (cid), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+}
+
+void LidrupTracer::lidrup_add_original_clause (int64_t id,
+                                               const vector<int> &clause) {
+  lidrup_batch_weaken_restore_and_delete ();
+  if (binary) {
+    file->put ('i');
+    put_binary_id (id);
+  } else {
+    file->put ("i ");
+    file->put (id);
+    file->put (' ');
+  }
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+}
+
+void LidrupTracer::lidrup_batch_weaken_restore_and_delete () {
+  CADICAL_assert (batch_weaken.empty () || batch_delete.empty ());
+  if (!batch_weaken.empty ()) {
+    if (binary) {
+      file->put ('w');
+    } else {
+      file->put ("w ");
+    }
+    for (const auto &id : batch_weaken) {
+      if (binary)
+        put_binary_id (id);
+      else
+        file->put (id), file->put (' ');
+    }
+    batch_weaken.clear ();
+    if (binary)
+      put_binary_zero ();
+    else
+      file->put ("0\n");
+#ifndef CADICAL_QUIET
+    batched++;
+#endif
+  }
+  if (!batch_delete.empty ()) {
+    if (binary) {
+      file->put ('d');
+    } else {
+      file->put ("d ");
+    }
+    for (const auto &id : batch_delete) {
+      if (binary)
+        put_binary_id (id);
+      else
+        file->put (id), file->put (' ');
+    }
+    batch_delete.clear ();
+    if (binary)
+      put_binary_zero ();
+    else
+      file->put ("0\n");
+#ifndef CADICAL_QUIET
+    batched++;
+#endif
+  }
+  if (!batch_restore.empty ()) {
+    if (binary) {
+      file->put ('r');
+    } else {
+      file->put ("r ");
+    }
+    for (const auto &id : batch_restore) {
+      if (binary)
+        put_binary_id (id);
+      else
+        file->put (id), file->put (' ');
+    }
+    batch_restore.clear ();
+    if (binary)
+      put_binary_zero ();
+    else
+      file->put ("0\n");
+#ifndef CADICAL_QUIET
+    batched++;
+#endif
+  }
+}
+
+void LidrupTracer::lidrup_conclude_and_delete (
+    const vector<int64_t> &conclusion) {
+  lidrup_batch_weaken_restore_and_delete ();
+  int64_t size = conclusion.size ();
+  if (size > 1) {
+    if (binary) {
+      file->put ('U');
+      put_binary_id (size);
+    } else {
+      file->put ("U ");
+      file->put (size), file->put ("\n");
+    }
+  }
+  for (auto &id : conclusion) {
+    if (binary)
+      file->put ('u');
+    else
+      file->put ("u ");
+    if (!find_and_delete (id)) {
+      CADICAL_assert (imported_clause.empty ());
+      CADICAL_assert (conclusion.size () == 1);
+      if (binary) {
+        put_binary_zero ();
+        put_binary_id (id);
+        put_binary_zero ();
+      } else {
+        file->put ("0 ");
+        file->put (id);
+        file->put (" 0\n");
+      }
+    } else {
+      for (const auto &external_lit : imported_clause) {
+        // flip sign...
+        const auto not_elit = -external_lit;
+        if (binary)
+          put_binary_lit (not_elit);
+        else
+          file->put (not_elit), file->put (' ');
+      }
+      if (binary)
+        put_binary_zero ();
+      else
+        file->put ("0 ");
+      for (const auto &cid : imported_chain) {
+        if (binary)
+          put_binary_id (cid);
+        else
+          file->put (cid), file->put (' ');
+      }
+      if (binary)
+        put_binary_zero ();
+      else
+        file->put ("0\n");
+      imported_clause.clear ();
+      imported_chain.clear ();
+    }
+  }
+  flush_if_piping ();
+}
+
+void LidrupTracer::lidrup_report_status (int status) {
+  lidrup_batch_weaken_restore_and_delete ();
+  if (binary)
+    file->put ('s');
+  else
+    file->put ("s ");
+  if (status == SATISFIABLE)
+    file->put ("SATISFIABLE");
+  else if (status == UNSATISFIABLE)
+    file->put ("UNSATISFIABLE");
+  else
+    file->put ("UNKNOWN");
+  if (!binary)
+    file->put ("\n");
+  flush_if_piping ();
+}
+
+void LidrupTracer::lidrup_conclude_sat (const vector<int> &model) {
+  lidrup_batch_weaken_restore_and_delete ();
+  if (binary)
+    file->put ('m');
+  else
+    file->put ("m ");
+  for (auto &lit : model) {
+    if (binary)
+      put_binary_lit (lit);
+    else
+      file->put (lit), file->put (' ');
+  }
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  flush_if_piping ();
+}
+
+void LidrupTracer::lidrup_conclude_unknown (const vector<int> &trail) {
+  lidrup_batch_weaken_restore_and_delete ();
+  if (binary)
+    file->put ('e');
+  else
+    file->put ("e ");
+  for (auto &lit : trail) {
+    if (binary)
+      put_binary_lit (lit);
+    else
+      file->put (lit), file->put (' ');
+  }
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  flush_if_piping ();
+}
+
+void LidrupTracer::lidrup_solve_query () {
+  lidrup_batch_weaken_restore_and_delete ();
+  if (binary)
+    file->put ('q');
+  else
+    file->put ("q ");
+  for (auto &lit : assumptions) {
+    if (binary)
+      put_binary_lit (lit);
+    else
+      file->put (lit), file->put (' ');
+  }
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0\n");
+  flush_if_piping ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void LidrupTracer::add_derived_clause (int64_t id, bool,
+                                       const vector<int> &clause,
+                                       const vector<int64_t> &chain) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG (clause, "LIDRUP TRACER tracing addition of derived clause");
+  lidrup_add_derived_clause (id, clause, chain);
+#ifndef CADICAL_QUIET
+  added++;
+#endif
+}
+
+void LidrupTracer::add_assumption_clause (int64_t id,
+                                          const vector<int> &clause,
+                                          const vector<int64_t> &chain) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG (clause,
+       "LIDRUP TRACER tracing addition of assumption clause[%" PRId64 "]",
+       id);
+  for (auto &lit : clause)
+    imported_clause.push_back (lit);
+  for (auto &cid : chain)
+    imported_chain.push_back (cid);
+  last_id = id;
+  insert ();
+  imported_clause.clear ();
+  imported_chain.clear ();
+}
+
+void LidrupTracer::delete_clause (int64_t id, bool, const vector<int> &) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG ("LIDRUP TRACER tracing deletion of clause[%" PRId64 "]", id);
+  if (find_and_delete (id)) {
+    CADICAL_assert (imported_clause.empty ());
+    if (!batch_delete.empty () || !batch_restore.empty ())
+      lidrup_batch_weaken_restore_and_delete ();
+    batch_weaken.push_back (id);
+#ifndef CADICAL_QUIET
+    weakened++;
+#endif
+  } else {
+    if (!batch_weaken.empty () || !batch_restore.empty ())
+      lidrup_batch_weaken_restore_and_delete ();
+    batch_delete.push_back (id);
+#ifndef CADICAL_QUIET
+    deleted++;
+#endif
+  }
+}
+
+void LidrupTracer::weaken_minus (int64_t id, const vector<int> &) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG ("LIDRUP TRACER tracing weaken minus of clause[%" PRId64 "]", id);
+  last_id = id;
+  insert ();
+}
+
+void LidrupTracer::conclude_unsat (ConclusionType,
+                                   const vector<int64_t> &conclusion) {
+  if (file->closed ())
+    return;
+  CADICAL_assert (imported_clause.empty ());
+  LOG (conclusion, "LIDRUP TRACER tracing conclusion of clause(s)");
+  lidrup_conclude_and_delete (conclusion);
+}
+
+void LidrupTracer::add_original_clause (int64_t id, bool,
+                                        const vector<int> &clause,
+                                        bool restored) {
+  if (file->closed ())
+    return;
+  if (!restored) {
+    LOG (clause, "LIDRUP TRACER tracing addition of original clause");
+#ifndef CADICAL_QUIET
+    original++;
+#endif
+    return lidrup_add_original_clause (id, clause);
+  }
+  CADICAL_assert (restored);
+  if (find_and_delete (id)) {
+    LOG (clause,
+         "LIDRUP TRACER the clause was not yet weakened, so no restore");
+    return;
+  }
+  LOG (clause, "LIDRUP TRACER tracing addition of restored clause");
+  lidrup_add_restored_clause (id);
+#ifndef CADICAL_QUIET
+  restore++;
+#endif
+}
+
+void LidrupTracer::report_status (int status, int64_t) {
+  if (file->closed ())
+    return;
+  LOG ("LIDRUP TRACER tracing report of status %d", status);
+  lidrup_report_status (status);
+}
+
+void LidrupTracer::conclude_sat (const vector<int> &model) {
+  if (file->closed ())
+    return;
+  LOG (model, "LIDRUP TRACER tracing conclusion of model");
+  lidrup_conclude_sat (model);
+}
+
+void LidrupTracer::conclude_unknown (const vector<int> &entrailed) {
+  if (file->closed ())
+    return;
+  LOG (entrailed, "LIDRUP TRACER tracing conclusion of UNK");
+  lidrup_conclude_unknown (entrailed);
+}
+
+void LidrupTracer::solve_query () {
+  if (file->closed ())
+    return;
+  LOG (assumptions, "LIDRUP TRACER tracing solve query with assumptions");
+  lidrup_solve_query ();
+#ifndef CADICAL_QUIET
+  solved++;
+#endif
+}
+
+void LidrupTracer::add_assumption (int lit) {
+  LOG ("LIDRUP TRACER tracing addition of assumption %d", lit);
+  assumptions.push_back (lit);
+}
+
+void LidrupTracer::reset_assumptions () {
+  LOG (assumptions, "LIDRUP TRACER tracing reset of assumptions");
+  assumptions.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+bool LidrupTracer::closed () { return file->closed (); }
+
+#ifndef CADICAL_QUIET
+
+void LidrupTracer::print_statistics () {
+  // TODO complete this.
+  uint64_t bytes = file->bytes ();
+  uint64_t total = added + deleted + weakened + restore + original;
+  MSG ("LIDRUP %" PRId64 " original clauses %.2f%%", original,
+       percent (original, total));
+  MSG ("LIDRUP %" PRId64 " learned clauses %.2f%%", added,
+       percent (added, total));
+  MSG ("LIDRUP %" PRId64 " deleted clauses %.2f%%", deleted,
+       percent (deleted, total));
+  MSG ("LIDRUP %" PRId64 " weakened clauses %.2f%%", weakened,
+       percent (weakened, total));
+  MSG ("LIDRUP %" PRId64 " restored clauses %.2f%%", restore,
+       percent (restore, total));
+  MSG ("LIDRUP %" PRId64 " batches of deletions, weaken and restores %.2f",
+       batched, relative (batched, deleted + restore + weakened));
+  MSG ("LIDRUP %" PRId64 " queries %.2f", solved, relative (solved, total));
+  MSG ("LIDRUP %" PRId64 " bytes (%.2f MB)", bytes,
+       bytes / (double) (1 << 20));
+}
+
+#endif
+
+void LidrupTracer::close (bool print) {
+  CADICAL_assert (!closed ());
+  file->close ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("LIDRUP proof file '%s' closed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+void LidrupTracer::flush (bool print) {
+  CADICAL_assert (!closed ());
+  lidrup_batch_weaken_restore_and_delete ();
+  file->flush ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("LIDRUP proof file '%s' flushed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_limit.cpp b/src/sat/cadical/cadical_limit.cpp
new file mode 100644
index 000000000..69417a473
--- /dev/null
+++ b/src/sat/cadical/cadical_limit.cpp
@@ -0,0 +1,135 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+Limit::Limit () { memset (this, 0, sizeof *this); }
+
+/*------------------------------------------------------------------------*/
+
+double Internal::scale (double v) const {
+  const double ratio = clause_variable_ratio ();
+  const double factor = (ratio <= 2) ? 1.0 : log (ratio) / log (2);
+  double res = factor * v;
+  if (res < 1)
+    res = 1;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+Last::Last () { memset (this, 0, sizeof *this); }
+
+/*------------------------------------------------------------------------*/
+
+Inc::Inc () {
+  memset (this, 0, sizeof *this);
+  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");
+  } else if (l < 0) {
+    LOG ("reset conflict limit to be unbounded");
+    inc.conflicts = -1;
+  } else {
+    inc.conflicts = l;
+    LOG ("new conflict limit of %d conflicts", l);
+  }
+}
+
+void Internal::limit_decisions (int l) {
+  if (l < 0 && inc.decisions < 0) {
+    LOG ("keeping unbounded decision limit");
+  } else if (l < 0) {
+    LOG ("reset decision limit to be unbounded");
+    inc.decisions = -1;
+  } else {
+    inc.decisions = l;
+    LOG ("new decision limit of %d decisions", l);
+  }
+}
+
+void Internal::limit_preprocessing (int l) {
+  if (l < 0) {
+    LOG ("ignoring invalid preprocessing limit %d", l);
+  } else if (!l) {
+    LOG ("reset preprocessing limit to no preprocessing");
+    inc.preprocessing = 0;
+  } else {
+    inc.preprocessing = l;
+    LOG ("new preprocessing limit of %d preprocessing rounds", l);
+  }
+}
+
+void Internal::limit_local_search (int l) {
+  if (l < 0) {
+    LOG ("ignoring invalid local search limit %d", l);
+  } else if (!l) {
+    LOG ("reset local search limit to no local search");
+    inc.localsearch = 0;
+  } else {
+    inc.localsearch = l;
+    LOG ("new local search limit of %d local search rounds", 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;
+  if (!strcmp (name, "localsearch"))
+    return true;
+  return false;
+}
+
+bool Internal::limit (const char *name, int l) {
+  bool res = true;
+  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);
+  else
+    res = false;
+  return res;
+}
+
+void Internal::reset_limits () {
+  LOG ("reset limits");
+  limit_terminate (0);
+  limit_conflicts (-1);
+  limit_decisions (-1);
+  limit_preprocessing (0);
+  limit_local_search (0);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_logging.cpp b/src/sat/cadical/cadical_logging.cpp
new file mode 100644
index 000000000..589bf097e
--- /dev/null
+++ b/src/sat/cadical/cadical_logging.cpp
@@ -0,0 +1,221 @@
+#include "global.h"
+
+#ifdef LOGGING
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Logger::print_log_prefix (Internal *internal) {
+  internal->print_prefix ();
+  tout.magenta ();
+  fputs ("LOG ", stdout);
+  tout.magenta (true);
+  printf ("%d ", internal->level);
+  tout.normal ();
+}
+
+void Logger::log_empty_line (Internal *internal) {
+  internal->print_prefix ();
+  tout.magenta ();
+  const int len = internal->prefix.size (), max = 78 - len;
+  for (int i = 0; i < max; i++)
+    fputc ('-', stdout);
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+void Logger::log (Internal *internal, const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// It is hard to factor out the common part between the two clause loggers,
+// since they are also used in slightly different contexts.  Our attempt to
+// do so were not more readable than the current version.  See the header
+// for an explanation of the difference between the following two functions.
+
+void Logger::log (Internal *internal, const Clause *c, const char *fmt,
+                  ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (c) {
+    if (c->redundant)
+      printf (" glue %d redundant", c->glue);
+    else
+      printf (" irredundant");
+    printf (" size %d clause[%" PRId64 "]", c->size, c->id);
+    if (c->moved)
+      printf (" ... (moved)");
+    else {
+      if (internal->opts.logsort) {
+        vector<int> s;
+        for (const auto &lit : *c)
+          s.push_back (lit);
+        sort (s.begin (), s.end (), clause_lit_less_than ());
+        for (const auto &lit : s)
+          printf (" %d", lit);
+      } else {
+        for (const auto &lit : *c) {
+          printf (" %s", loglit (internal, lit).c_str ());
+        }
+      }
+    }
+  } else if (internal->level)
+    printf (" decision");
+  else
+    printf (" unit");
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+void Logger::log (Internal *internal, const Gate *g, const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (g) {
+    printf ("%s%s%s gate[%" PRIu64 "] (arity: %ld) %s := %s",
+	    g->degenerated_and_pos ? " deg+" : "",
+	    g->degenerated_and_neg ? " deg-" : "",
+            g->garbage ? " garbage" : "", g->id, g->arity (),
+            loglit (internal, g->lhs).c_str (),
+            string_of_gate (g->tag).c_str ());
+    for (const auto &lit : g->rhs) {
+      printf (" %s", loglit (internal, lit).c_str ());
+    }
+  } else
+    printf (" null gate");
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// Same as above, but for the global clause 'c' (which is not a reason).
+
+void Logger::log (Internal *internal, const vector<int> &c, const char *fmt,
+                  ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (internal->opts.logsort) {
+    vector<int> s;
+    for (const auto &lit : c)
+      s.push_back (lit);
+    sort (s.begin (), s.end (), clause_lit_less_than ());
+    for (const auto &lit : s)
+      printf (" %d", lit);
+  } else {
+    for (const auto &lit : c)
+      printf (" %d", lit);
+  }
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// Now for 'restore_clause' to avoid copying (without logging).
+
+void Logger::log (Internal *internal,
+                  const vector<int>::const_iterator &begin,
+                  const vector<int>::const_iterator &end, const char *fmt,
+                  ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (internal->opts.logsort) {
+    vector<int> s;
+    for (auto p = begin; p != end; p++)
+      s.push_back (*p);
+    sort (s.begin (), s.end (), clause_lit_less_than ());
+    for (const auto &lit : s)
+      printf (" %d", lit);
+  } else {
+    for (auto p = begin; p != end; p++)
+      printf (" %d", *p);
+  }
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// for LRAT proof chains
+
+void Logger::log (Internal *internal, const vector<int64_t> &c,
+                  const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  for (const auto &id : c)
+    printf (" %" PRId64, id);
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// for LRAT proof clauses
+
+void Logger::log (Internal *internal, const int *literals,
+                  const unsigned size, const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  for (unsigned i = 0; i < size; i++) {
+    const int lit = literals[i];
+    printf (" %d", lit);
+  }
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+string Logger::loglit (Internal *internal, int lit) {
+  std::string v = std::to_string (lit);
+  if (lit && -internal->max_var <= lit && internal->max_var >= lit) {
+    const int va = internal->val (lit);
+    if (va) {
+      v = v + "@" + std::to_string (internal->var (lit).level);
+      if (!internal->var (lit).reason)
+        v = v + "+";
+    }
+    if (va > 0)
+      v += "=1";
+    else if (va < 0)
+      v += "=-1";
+  }
+  return v;
+}
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+#endif
diff --git a/src/sat/cadical/cadical_lookahead.cpp b/src/sat/cadical/cadical_lookahead.cpp
new file mode 100644
index 000000000..de84858cc
--- /dev/null
+++ b/src/sat/cadical/cadical_lookahead.cpp
@@ -0,0 +1,526 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+struct literal_occ {
+  int lit;
+  int count;
+  bool operator< (const literal_occ &locc) const {
+    return (count > locc.count) || (count == locc.count && lit < locc.lit);
+  }
+  literal_occ operator++ () {
+    ++count;
+    return *this;
+  }
+};
+
+std::vector<int> Internal::lookahead_populate_locc () {
+  std::vector<literal_occ> loccs ((std::size_t) max_var + 1);
+  for (std::size_t lit = 0; lit < loccs.size (); ++lit) {
+    loccs[lit].lit = lit;
+  }
+  for (const auto &c : clauses)
+    if (!c->redundant)
+      for (const auto &lit : *c)
+        if (active (lit))
+          ++loccs[std::abs (lit)];
+  std::sort (begin (loccs), end (loccs));
+  std::vector<int> locc_map;
+  locc_map.reserve (max_var);
+  for (const auto &locc : loccs)
+    locc_map.push_back (locc.lit);
+  return locc_map;
+}
+
+int Internal::lookahead_locc (const std::vector<int> &loccs) {
+  for (auto lit : loccs)
+    if (active (abs (lit)) && !assumed (lit) && !assumed (-lit) &&
+        !val (lit))
+      return lit;
+  return 0;
+}
+
+// This calculates the literal that appears the most often reusing the
+// available datastructures and iterating over the clause set. This is too
+// slow to be called iteratively. A faster (but inexact) version is
+// lookahead_populate_loc and lookahead_loc.
+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) {}
+  typedef size_t Type;
+  Type 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 () {
+
+  CADICAL_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;
+    CADICAL_assert (!noccs (lit)), CADICAL_assert (noccs (-lit) > 0);
+    if (propfixed (lit) >= stats.all.fixed)
+      continue;
+    MSG ("keeping probe %d negated occs %" PRId64 "", lit, noccs (-lit));
+    *j++ = lit;
+  }
+  size_t remain = j - probes.begin ();
+#ifndef CADICAL_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 () {
+
+  CADICAL_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;
+
+      MSG ("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;
+
+      MSG ("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 %zd 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 ()) {
+    MSG ("connected terminator forces termination");
+    return true;
+  }
+
+  if (termination_forced) {
+    MSG ("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;
+
+  MSG ("lookahead-probe-round %" PRId64
+       " without propagations limit and %zu assumptions",
+       stats.probingrounds, assumptions.size ());
+
+  termination_forced = false;
+
+#ifndef CADICAL_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 ()) {
+    MSG ("empty clause before probing");
+    learn_empty_clause ();
+    return INT_MIN;
+  }
+
+  if (terminating_asked ())
+    return most_occurring_literal ();
+
+  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;
+
+  CADICAL_assert (unsat || propagated == trail.size ());
+  propagated = propagated2 = trail.size ();
+
+  int probe;
+  int res = most_occurring_literal ();
+  int max_hbrs = -1;
+
+  set_mode (PROBE);
+
+  MSG ("unsat = %d, terminating_asked () = %d ", unsat,
+       terminating_asked ());
+  init_probehbr_lrat ();
+  while (!unsat && !terminating_asked () &&
+         (probe = lookahead_next_probe ())) {
+    stats.probed++;
+    int hbrs;
+
+    probe_assign_decision (probe);
+    if (probe_propagate ())
+      hbrs = trail.size (), backtrack ();
+    else
+      hbrs = 0, failed_literal (probe);
+    clean_probehbr_lrat ();
+    if (max_hbrs < hbrs ||
+        (max_hbrs == hbrs &&
+         internal->bumped (probe) > internal->bumped (res))) {
+      res = probe;
+      max_hbrs = hbrs;
+    }
+  }
+
+  reset_mode (PROBE);
+
+  if (unsat) {
+    MSG ("probing derived empty clause");
+    res = INT_MIN;
+  } else if (propagated < trail.size ()) {
+    MSG ("probing produced %zd units",
+         (size_t) (trail.size () - propagated));
+    if (!propagate ()) {
+      MSG ("propagating units after probing results in empty clause");
+      learn_empty_clause ();
+      res = INT_MIN;
+    } else
+      sort_watches ();
+  }
+
+#ifndef CADICAL_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 %" PRId64 " 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);
+
+  MSG ("lookahead literal %d with %d\n", res, max_hbrs);
+
+  return res;
+}
+
+CubesWithStatus Internal::generate_cubes (int depth, int min_depth) {
+  if (!active () || depth == 0) {
+    CubesWithStatus cubes;
+    cubes.status = 0;
+    cubes.cubes.push_back (std::vector<int> ());
+    return cubes;
+  }
+
+  lookingahead = true;
+  START (lookahead);
+  MSG ("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) {
+    MSG ("Solved during preprocessing");
+    CubesWithStatus cubes;
+    cubes.status = res;
+    lookingahead = false;
+    STOP (lookahead);
+    return cubes;
+  }
+
+  reset_limits ();
+  MSG ("generate cubes with %zu assumptions\n", assumptions.size ());
+
+  CADICAL_assert (ntab.empty ());
+  std::vector<int> current_assumptions{assumptions};
+  std::vector<std::vector<int>> cubes{{assumptions}};
+  auto loccs{lookahead_populate_locc ()};
+  LOG ("loccs populated\n");
+  CADICAL_assert (ntab.empty ());
+
+  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) {
+      CADICAL_assert (ntab.empty ());
+      CADICAL_assert (!unsat);
+      reset_assumptions ();
+      for (auto lit : cubes2[j])
+        assume (lit);
+      restore_clauses ();
+      propagate ();
+      // preprocess_round(0); //uncomment maybe
+
+      if (unsat) {
+        LOG ("current cube is unsat; skipping");
+        unsat = false;
+        continue;
+      }
+
+      int res = terminating_asked () ? lookahead_locc (loccs)
+                                     : lookahead_probing ();
+      if (unsat) {
+        LOG ("current cube is unsat; skipping");
+        unsat = false;
+        continue;
+      }
+
+      if (res == 0) {
+        LOG ("no lit to split %i", res);
+        cubes.push_back (cubes2[j]);
+        continue;
+      }
+
+      CADICAL_assert (res != 0);
+      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 () && i >= min_depth)
+      break;
+  }
+
+  CADICAL_assert (std::for_each (
+      std::begin (cubes), std::end (cubes),
+      [] (std::vector<int> cube) { return non_tautological_cube (cube); }));
+  reset_assumptions ();
+
+  for (auto lit : current_assumptions)
+    assume (lit);
+
+  STOP (lookahead);
+  lookingahead = false;
+
+  if (unsat) {
+    LOG ("Solved during preprocessing");
+    CubesWithStatus cubes;
+    cubes.status = 20;
+    return cubes;
+  }
+
+  CubesWithStatus rcubes;
+  rcubes.status = 0;
+  rcubes.cubes = cubes;
+
+  return rcubes;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_lratchecker.cpp b/src/sat/cadical/cadical_lratchecker.cpp
new file mode 100644
index 000000000..5f342a370
--- /dev/null
+++ b/src/sat/cadical/cadical_lratchecker.cpp
@@ -0,0 +1,835 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+inline unsigned LratChecker::l2u (int lit) {
+  CADICAL_assert (lit);
+  CADICAL_assert (lit != INT_MIN);
+  unsigned res = 2 * (abs (lit) - 1);
+  if (lit < 0)
+    res++;
+  return res;
+}
+
+signed char &LratChecker::mark (int lit) {
+  const unsigned u = l2u (lit);
+  CADICAL_assert (u < marks.size ());
+  return marks[u];
+}
+
+signed char &LratChecker::checked_lit (int lit) {
+  const unsigned u = l2u (lit);
+  CADICAL_assert (u < checked_lits.size ());
+  return checked_lits[u];
+}
+
+/*------------------------------------------------------------------------*/
+
+LratCheckerClause *LratChecker::new_clause () {
+  const size_t size = imported_clause.size ();
+  CADICAL_assert (size <= UINT_MAX);
+  const int off = size ? 1 : 0;
+  const size_t bytes =
+      sizeof (LratCheckerClause) + (size - off) * sizeof (int);
+  LratCheckerClause *res = (LratCheckerClause *) new char[bytes];
+  res->garbage = false;
+  res->next = 0;
+  res->hash = last_hash;
+  res->id = last_id;
+  res->size = size;
+  res->used = false;
+  res->tautological = false;
+  int *literals = res->literals, *p = literals;
+#ifndef CADICAL_NDEBUG
+  for (auto &b : checked_lits)
+    CADICAL_assert (!b); // = false;
+#endif
+  for (const auto &lit : imported_clause) {
+    *p++ = lit;
+    checked_lit (-lit) = true;
+    if (checked_lit (lit)) {
+      LOG (imported_clause, "LRAT CHECKER clause tautological");
+      res->tautological = true;
+    }
+  }
+  for (const auto &lit : imported_clause)
+    checked_lit (-lit) = false;
+  num_clauses++;
+
+  return res;
+}
+
+void LratChecker::delete_clause (LratCheckerClause *c) {
+  CADICAL_assert (c);
+  if (!c->garbage) {
+    CADICAL_assert (num_clauses);
+    num_clauses--;
+  } else {
+    CADICAL_assert (num_garbage);
+    num_garbage--;
+  }
+  delete[] (char *) c;
+}
+
+void LratChecker::enlarge_clauses () {
+  CADICAL_assert (num_clauses == size_clauses);
+  const uint64_t new_size_clauses = size_clauses ? 2 * size_clauses : 1;
+  LOG ("LRAT CHECKER enlarging clauses of checker from %" PRIu64
+       " to %" PRIu64,
+       (uint64_t) size_clauses, (uint64_t) new_size_clauses);
+  LratCheckerClause **new_clauses;
+  new_clauses = new LratCheckerClause *[new_size_clauses];
+  clear_n (new_clauses, new_size_clauses);
+  for (uint64_t i = 0; i < size_clauses; i++) {
+    for (LratCheckerClause *c = clauses[i], *next; c; c = next) {
+      next = c->next;
+      const uint64_t h = reduce_hash (c->hash, new_size_clauses);
+      c->next = new_clauses[h];
+      new_clauses[h] = c;
+    }
+  }
+  delete[] clauses;
+  clauses = new_clauses;
+  size_clauses = new_size_clauses;
+}
+
+// Probably not necessary since we have no watches.
+//
+void LratChecker::collect_garbage_clauses () {
+
+  stats.collections++;
+
+  LOG ("LRAT CHECKER collecting %" PRIu64 " garbage clauses %.0f%%",
+       num_garbage, percent (num_garbage, num_clauses));
+
+  for (LratCheckerClause *c = garbage, *next; c; c = next)
+    next = c->next, delete_clause (c);
+
+  CADICAL_assert (!num_garbage);
+  garbage = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+LratChecker::LratChecker (Internal *i)
+    : internal (i), size_vars (0), concluded (false), num_clauses (0),
+      num_finalized (0), num_garbage (0), size_clauses (0), clauses (0),
+      garbage (0), last_hash (0), last_id (0), current_id (0) {
+
+  // Initialize random number table for hash function.
+  //
+  Random random (42);
+  for (unsigned n = 0; n < num_nonces; n++) {
+    uint64_t nonce = random.next ();
+    if (!(nonce & 1))
+      nonce++;
+    CADICAL_assert (nonce), CADICAL_assert (nonce & 1);
+    nonces[n] = nonce;
+  }
+
+  memset (&stats, 0, sizeof (stats)); // Initialize statistics.
+}
+
+void LratChecker::connect_internal (Internal *i) {
+  internal = i;
+  LOG ("connected to internal");
+}
+
+LratChecker::~LratChecker () {
+  LOG ("LRAT CHECKER delete");
+  for (size_t i = 0; i < size_clauses; i++)
+    for (LratCheckerClause *c = clauses[i], *next; c; c = next)
+      next = c->next, delete_clause (c);
+  for (LratCheckerClause *c = garbage, *next; c; c = next)
+    next = c->next, delete_clause (c);
+  delete[] clauses;
+}
+
+/*------------------------------------------------------------------------*/
+
+void LratChecker::enlarge_vars (int64_t idx) {
+
+  CADICAL_assert (0 < idx), CADICAL_assert (idx <= INT_MAX);
+
+  int64_t new_size_vars = size_vars ? 2 * size_vars : 2;
+  while (idx >= new_size_vars)
+    new_size_vars *= 2;
+  LOG ("LRAT CHECKER enlarging variables of checker from %" PRId64
+       " to %" PRId64 "",
+       size_vars, new_size_vars);
+
+  marks.resize (2 * new_size_vars);
+  checked_lits.resize (2 * new_size_vars);
+
+  CADICAL_assert (idx < new_size_vars);
+  size_vars = new_size_vars;
+}
+
+inline void LratChecker::import_literal (int lit) {
+  CADICAL_assert (lit);
+  CADICAL_assert (lit != INT_MIN);
+  int idx = abs (lit);
+  if (idx >= size_vars)
+    enlarge_vars (idx);
+  imported_clause.push_back (lit);
+}
+
+void LratChecker::import_clause (const vector<int> &c) {
+  for (const auto &lit : c)
+    import_literal (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+uint64_t LratChecker::reduce_hash (uint64_t hash, uint64_t size) {
+  CADICAL_assert (size > 0);
+  unsigned shift = 32;
+  uint64_t res = hash;
+  while ((((uint64_t) 1) << shift) > size) {
+    res ^= res >> shift;
+    shift >>= 1;
+  }
+  res &= size - 1;
+  CADICAL_assert (res < size);
+  return res;
+}
+
+uint64_t LratChecker::compute_hash (const int64_t id) {
+  CADICAL_assert (id > 0);
+  unsigned j = id % num_nonces;
+  uint64_t tmp = nonces[j] * (uint64_t) id;
+  return last_hash = tmp;
+}
+
+LratCheckerClause **LratChecker::find (const int64_t id) {
+  stats.searches++;
+  LratCheckerClause **res, *c;
+  const uint64_t hash = compute_hash (id);
+  const uint64_t h = reduce_hash (hash, size_clauses);
+  for (res = clauses + h; (c = *res); res = &c->next) {
+    if (c->hash == hash && c->id == id) {
+      break;
+    }
+    stats.collisions++;
+  }
+  return res;
+}
+
+void LratChecker::insert () {
+  stats.insertions++;
+  if (num_clauses == size_clauses)
+    enlarge_clauses ();
+  const uint64_t h = reduce_hash (compute_hash (last_id), size_clauses);
+  LratCheckerClause *c = new_clause ();
+  c->next = clauses[h];
+  clauses[h] = c;
+}
+
+/*------------------------------------------------------------------------*/
+
+// "strict" resolution check instead of rup check
+bool LratChecker::check_resolution (vector<int64_t> proof_chain) {
+  if (proof_chain.empty ()) {
+    LOG ("LRAT CHECKER resolution check skipped clause is tautological");
+    return true;
+  }
+  // LOG (imported_clause, "LRAT CHECKER checking clause with resolution");
+#ifndef CADICAL_NDEBUG
+  for (auto &b : checked_lits)
+    CADICAL_assert (!b); // = false;
+#endif
+  if (!proof_chain.size () || proof_chain.back () < 0)
+    return false;
+  LratCheckerClause *c = *find (proof_chain.back ());
+  CADICAL_assert (c);
+  for (int *i = c->literals; i < c->literals + c->size; i++) {
+    int lit = *i;
+    checked_lit (lit) = true;
+    CADICAL_assert (!checked_lit (-lit));
+  }
+  for (auto p = proof_chain.end () - 2; p >= proof_chain.begin (); p--) {
+    auto &id = *p;
+    c = *find (id);
+    CADICAL_assert (c); // since this is checked in check already
+    for (int *i = c->literals; i < c->literals + c->size; i++) {
+      int lit = *i;
+      if (!checked_lit (-lit))
+        checked_lit (lit) = true;
+      else
+        checked_lit (-lit) = false;
+    }
+  }
+  for (const auto &lit : imported_clause) {
+    if (checked_lit (-lit)) {
+      LOG ("LRAT CHECKER resolution failed, resolved literal %d in learned "
+           "clause",
+           lit);
+      for (auto &b : checked_lits)
+        b = false; // clearing checking bits
+      return false;
+    }
+    if (!checked_lit (lit)) {
+      // learned clause is subsumed by resolvents
+      checked_lit (lit) = true;
+    }
+    checked_lit (-lit) = true;
+  }
+  bool failed = false;
+  for (int64_t lit = 1; lit < size_vars; lit++) {
+    bool ok = checked_lit (lit) && checked_lit (-lit);
+    ok = ok || (!checked_lit (lit) && !checked_lit (-lit));
+    checked_lit (lit) = checked_lit (-lit) = false;
+    if (!ok && !failed) {
+      LOG ("LRAT CHECKER resolution failed, learned clause does not match "
+           "on "
+           "variable %" PRId64,
+           lit);
+      failed = true;
+    }
+  }
+
+  return !failed;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool LratChecker::check (vector<int64_t> proof_chain) {
+  LOG (imported_clause, "LRAT CHECKER checking clause");
+  stats.checks++;
+#ifndef CADICAL_NDEBUG
+  for (auto &b : checked_lits)
+    CADICAL_assert (!b); // = false;
+#endif
+  bool taut = false;
+  for (const auto &lit : imported_clause) { // tautological clauses
+    checked_lit (-lit) = true;
+    if (checked_lit (lit)) {
+      LOG (imported_clause, "LRAT CHECKER clause tautological");
+      CADICAL_assert (!proof_chain.size ()); // would be unnecessary hence a bug
+      taut = true;
+    }
+  }
+  // we assume that we can have RUP and ER clauses. One side of the ER
+  // clauses are pure, i.e. without any chain, the long clause is blocked,
+  // so the chain consists only of negative ids. Therefore these checks are
+  // enough to distiguish between RUP and ER
+  if (taut || !proof_chain.size () || proof_chain.back () < 0) {
+    for (const auto &lit : imported_clause) { // tautological clauses
+      checked_lit (-lit) = false;
+    }
+    return taut;
+  }
+
+  vector<LratCheckerClause *> used_clauses;
+  bool checking = false;
+  for (auto &id : proof_chain) {
+    LratCheckerClause *c = *find (id);
+    if (!c) {
+      LOG ("LRAT CHECKER LRAT failed. Did not find clause with id %" PRIu64,
+           id);
+      break;
+    }
+    if (c->tautological) {
+      LOG ("LRAT CHECKER LRAT failed. Clause with id %" PRId64
+           " is tautological",
+           id);
+      break;
+    }
+    used_clauses.push_back (c);
+    if (c->used) {
+      LOG ("LRAT CHECKER LRAT failed. Id %" PRId64
+           " was used multiple times",
+           id);
+      break;
+    } else
+      c->used = true;
+    int unit = 0;
+    for (int *i = c->literals; i < c->literals + c->size; i++) {
+      int lit = *i;
+      if (checked_lit (-lit))
+        continue;
+      if (unit && unit != lit) {
+        unit = INT_MIN; // multiple unfalsified literals
+        break;
+      }
+      unit = lit; // potential unit
+    }
+    if (unit == INT_MIN) {
+      LOG ("LRAT CHECKER check failed, found non unit clause %" PRId64, id);
+      break;
+    }
+    if (!unit) {
+      LOG ("LRAT CHECKER check succeded, clause falsified %" PRId64, id);
+      checking = true;
+      break;
+    }
+    // LOG ("LRAT CHECKER found unit clause %" PRIu64 ", assign %d", id,
+    // unit);
+    checked_lit (unit) = true;
+  }
+  for (auto &lc : used_clauses) {
+    lc->used = false;
+  }
+  for (auto &b : checked_lits)
+    b = false;
+  if (!checking) {
+    LOG ("LRAT CHECKER failed, no conflict found");
+    return false; // check failed because no empty clause was found
+  }
+  return true;
+}
+
+bool LratChecker::check_blocked (vector<int64_t> proof_chain) {
+  for (const auto &lit : imported_clause) {
+    checked_lit (-lit) = true;
+    mark (-lit) = true;
+  }
+  for (size_t i = 0; i < size_clauses; i++) {
+    for (LratCheckerClause *c = clauses[i], *next; c; c = next) {
+      next = c->next;
+      if (c->garbage)
+        continue;
+      // if c is part of the proof chain its id occurs negatively there.
+      if (std::find (proof_chain.begin (), proof_chain.end (), -c->id) !=
+          proof_chain.end ()) {
+        // clause needs to be blocked
+        unsigned count = 0;
+        vector<int> candidates;
+        for (unsigned i = 0; i < c->size; i++) {
+          const int lit = c->literals[i];
+          if (checked_lit (lit)) {
+            count++;
+          }
+          if (mark (lit)) {
+            candidates.push_back (lit);
+          }
+        }
+        if (count < 2) {
+          // check failed
+          for (const auto &lit : imported_clause) {
+            checked_lit (-lit) = false;
+            mark (-lit) = false;
+          }
+          return false;
+        } else {
+          // all literals outside of candidates are not valid RAT candidates
+          for (auto &lit : imported_clause) {
+            if (mark (-lit) &&
+                std::find (candidates.begin (), candidates.end (), -lit) ==
+                    candidates.end ()) {
+              mark (-lit) = false;
+            }
+          }
+        }
+      } else {
+        // any literal contained in the clause is not a valid RAT candidate
+        for (unsigned i = 0; i < c->size; i++) {
+          const int lit = c->literals[i];
+          if (checked_lit (lit)) {
+            mark (lit) = false;
+          }
+        }
+      }
+    }
+  }
+  bool success = false;
+  for (const auto &lit : imported_clause) {
+    if (mark (-lit))
+      success = true;
+    checked_lit (-lit) = mark (-lit) = false;
+  }
+  return success;
+}
+
+/*------------------------------------------------------------------------*/
+
+void LratChecker::add_original_clause (int64_t id, bool,
+                                       const vector<int> &c, bool restore) {
+  START (checking);
+  LOG (c, "LRAT CHECKER addition of original clause[%" PRId64 "]", id);
+  if (restore)
+    restore_clause (id, c);
+  stats.added++;
+  stats.original++;
+  import_clause (c);
+  last_id = id;
+  if (!restore && id == 1 + current_id)
+    current_id = id;
+
+  if (size_clauses && !restore) {
+    LratCheckerClause **p = find (id), *d = *p;
+    if (d) {
+      fatal_message_start ();
+      fputs ("different clause with id ", stderr);
+      fprintf (stderr, "%" PRId64, id);
+      fputs (" already present\n", stderr);
+      fatal_message_end ();
+    }
+  }
+  CADICAL_assert (id);
+  insert ();
+  imported_clause.clear ();
+  STOP (checking);
+}
+
+void LratChecker::add_derived_clause (int64_t id, bool,
+                                      const vector<int> &c,
+                                      const vector<int64_t> &proof_chain) {
+  START (checking);
+  LOG (c, "LRAT CHECKER addition of derived clause[%" PRId64 "]", id);
+  stats.added++;
+  stats.derived++;
+  import_clause (c);
+  last_id = id;
+  CADICAL_assert (id == current_id + 1);
+  current_id = id;
+  if (size_clauses) {
+    LratCheckerClause **p = find (id), *d = *p;
+    if (d) {
+      fatal_message_start ();
+      fputs ("different clause with id ", stderr);
+      fprintf (stderr, "%" PRId64, id);
+      fputs (" already present\n", stderr);
+      fatal_message_end ();
+    }
+  }
+  CADICAL_assert (id);
+  bool failed = true;
+  if (check (proof_chain) && check_resolution (proof_chain)) {
+    failed = false;
+  } else if (check_blocked (proof_chain)) {
+    failed = false;
+  }
+  if (failed) {
+    LOG (proof_chain, "LRAT CHECKER check failed with chain");
+#ifdef LOGGING
+    for (const auto &pid : proof_chain) {
+      const int64_t aid = abs (pid);
+      LratCheckerClause **p = find (aid), *d = *p;
+      LOG (d->literals, d->size, "clause[%" PRId64 "]", pid);
+    }
+#endif
+    fatal_message_start ();
+    fputs ("failed to check derived clause:\n", stderr);
+    for (const auto &lit : imported_clause)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fatal_message_end ();
+  } else
+    insert ();
+  imported_clause.clear ();
+  STOP (checking);
+}
+
+void LratChecker::add_assumption_clause (int64_t id, const vector<int> &c,
+                                         const vector<int64_t> &chain) {
+  for (auto &lit : c) {
+    if (std::find (assumptions.begin (), assumptions.end (), -lit) !=
+        assumptions.end ())
+      continue;
+    if (std::find (constraint.begin (), constraint.end (), -lit) !=
+        constraint.end ())
+      continue;
+    fatal_message_start ();
+    fputs ("clause contains non assumptions or constraint literals\n",
+           stderr);
+    fatal_message_end ();
+  }
+  add_derived_clause (id, true, c, chain);
+  delete_clause (id, true, c);
+  assumption_clauses.push_back (id);
+}
+
+void LratChecker::add_assumption (int a) { assumptions.push_back (a); }
+
+void LratChecker::add_constraint (const vector<int> &c) {
+  constraint.clear ();
+  for (auto &lit : c) {
+    CADICAL_assert (lit);
+    if (std::find (constraint.begin (), constraint.end (), lit) !=
+        constraint.end ())
+      continue;
+    constraint.push_back (lit);
+  }
+}
+
+void LratChecker::reset_assumptions () {
+  assumption_clauses.clear ();
+  assumptions.clear ();
+  concluded = false;
+  // constraint.clear ();
+}
+
+void LratChecker::conclude_unsat (ConclusionType conclusion,
+                                  const vector<int64_t> &ids) {
+  if (concluded) {
+    fatal_message_start ();
+    fputs ("already concluded\n", stderr);
+    fatal_message_end ();
+  }
+  concluded = true;
+  if (conclusion == CONFLICT) {
+    LratCheckerClause **p = find (ids.back ()), *d = *p;
+    if (!d || d->size) {
+      fatal_message_start ();
+      fputs ("empty clause not in proof\n", stderr);
+      fatal_message_end ();
+    }
+    return;
+  } else if (conclusion == ASSUMPTIONS) {
+    if (ids.size () != 1 || assumption_clauses.size () != 1) {
+      fatal_message_start ();
+      fputs ("expected exactly one assumption clause\n", stderr);
+      fatal_message_end ();
+    }
+    if (ids.back () != assumption_clauses.back ()) {
+      fatal_message_start ();
+      fputs ("conclusion is not an assumption clause\n", stderr);
+      fatal_message_end ();
+    }
+    return;
+  } else {
+    CADICAL_assert (conclusion == CONSTRAINT);
+    if (constraint.size () != ids.size ()) {
+      fatal_message_start ();
+      fputs ("not complete conclusion given for constraint\n", stderr);
+      fputs ("The constraint contains the literals: ", stderr);
+      for (auto c : constraint) {
+        fprintf (stderr, "%d ", c);
+      }
+
+      fputs ("\nThe ids are: ", stderr);
+      for (auto c : ids) {
+        fprintf (stderr, "%" PRId64 " ", c);
+      }
+      fatal_message_end ();
+    }
+    for (auto &id : ids) {
+      if (std::find (assumption_clauses.begin (), assumption_clauses.end (),
+                     id) != assumption_clauses.end ())
+        continue;
+      fatal_message_start ();
+      fputs ("assumption clause for constraint missing\n", stderr);
+      fatal_message_end ();
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void LratChecker::delete_clause (int64_t id, bool, const vector<int> &c) {
+  START (checking);
+  LOG (c, "LRAT CHECKER checking deletion of clause[%" PRId64 "]", id);
+  stats.deleted++;
+  import_clause (c);
+  last_id = id;
+  LratCheckerClause **p = find (id), *d = *p;
+  if (d) {
+    for (const auto &lit : imported_clause)
+      mark (lit) = true;
+    const int *dp = d->literals;
+    for (unsigned i = 0; i < d->size; i++) {
+      int lit = *(dp + i);
+      if (!mark (lit)) {        // should never happen since ids
+        fatal_message_start (); // are unique.
+        fputs ("deleted clause not in proof:\n", stderr);
+        for (const auto &lit : imported_clause)
+          fprintf (stderr, "%d ", lit);
+        fputc ('0', stderr);
+        fatal_message_end ();
+      }
+    }
+    for (const auto &lit : imported_clause)
+      mark (lit) = false;
+
+    // Remove from hash table, mark as garbage, connect to garbage list.
+    num_garbage++;
+    CADICAL_assert (num_clauses);
+    num_clauses--;
+    *p = d->next;
+    d->next = garbage;
+    garbage = d;
+    d->garbage = true;
+
+    // If there are enough garbage clauses collect them.
+    // TODO: probably can just delete clause directly without
+    // specific garbage collection phase.
+    if (num_garbage > 0.5 * max ((size_t) size_clauses, (size_t) size_vars))
+      collect_garbage_clauses ();
+  } else {
+    fatal_message_start ();
+    fputs ("deleted clause not in proof:\n", stderr);
+    for (const auto &lit : imported_clause)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fatal_message_end ();
+  }
+  imported_clause.clear ();
+  STOP (checking);
+}
+
+/*------------------------------------------------------------------------*/
+
+void LratChecker::weaken_minus (int64_t id, const vector<int> &c) {
+  LOG (c, "LRAT CHECKER saving clause[%" PRId64 "] to restore later", id);
+  import_clause (c);
+
+  CADICAL_assert (id <= current_id);
+  last_id = id;
+  LratCheckerClause **p = find (id), *d = *p;
+  if (d) {
+    for (const auto &lit : imported_clause)
+      mark (lit) = true;
+    const int *dp = d->literals;
+    for (unsigned i = 0; i < d->size; i++) {
+      int lit = *(dp + i);
+      if (!mark (lit)) {        // should never happen since ids
+        fatal_message_start (); // are unique.
+        fputs ("deleted clause not in proof:\n", stderr);
+        for (const auto &lit : imported_clause)
+          fprintf (stderr, "%d ", lit);
+        fputc ('0', stderr);
+        fatal_message_end ();
+      }
+    }
+    for (const auto &lit : imported_clause)
+      mark (lit) = false;
+  } else {
+    fatal_message_start ();
+    fputs ("weakened clause not in proof:\n", stderr);
+    for (const auto &lit : imported_clause)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fatal_message_end ();
+  }
+  imported_clause.clear ();
+
+  vector<int> e = c;
+  sort (begin (e), end (e));
+  clauses_to_reconstruct[id] = e;
+}
+
+void LratChecker::restore_clause (int64_t id, const vector<int> &c) {
+  LOG (c, "LRAT CHECKER check of restoration of clause[%" PRId64 "]", id);
+  if (clauses_to_reconstruct.find (id) == end (clauses_to_reconstruct)) {
+    fatal_message_start ();
+    fputs ("restoring clauses not deleted previously:\n", stderr);
+    for (const auto &lit : c)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fatal_message_end ();
+  }
+  vector<int> e = c;
+  sort (begin (e), end (e));
+  const vector<int> &d = clauses_to_reconstruct.find (id)->second;
+  bool eq = true;
+  if (c.size () != d.size ()) {
+    eq = false;
+  }
+
+  for (std::vector<int>::size_type i = 0; i < e.size () && eq; ++i) {
+    eq = (e[i] == d[i]);
+  }
+
+  if (!eq) {
+    fatal_message_start ();
+    fputs ("restoring clause that is different than the one imported:\n",
+           stderr);
+    for (const auto &lit : c)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fputs ("vs:\n", stderr);
+    for (const auto &lit : d)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fatal_message_end ();
+  }
+
+  clauses_to_reconstruct.erase (id);
+}
+
+void LratChecker::finalize_clause (int64_t id, const vector<int> &c) {
+  START (checking);
+  LOG (c, "LRAT CHECKER checking finalize of clause[%" PRId64 "]", id);
+  stats.finalized++;
+  num_finalized++;
+  import_clause (c);
+  CADICAL_assert (id <= current_id);
+  last_id = id;
+  LratCheckerClause **p = find (id), *d = *p;
+  if (d) {
+    for (const auto &lit : imported_clause)
+      mark (lit) = true;
+    const int *dp = d->literals;
+    for (unsigned i = 0; i < d->size; i++) {
+      int lit = *(dp + i);
+      if (!mark (lit)) {        // should never happen since ids
+        fatal_message_start (); // are unique.
+        fputs ("deleted clause not in proof:\n", stderr);
+        for (const auto &lit : imported_clause)
+          fprintf (stderr, "%d ", lit);
+        fputc ('0', stderr);
+        fatal_message_end ();
+      }
+    }
+    for (const auto &lit : imported_clause)
+      mark (lit) = false;
+
+  } else {
+    fatal_message_start ();
+    fputs ("deleted clause not in proof:\n", stderr);
+    for (const auto &lit : imported_clause)
+      fprintf (stderr, "%d ", lit);
+    fputc ('0', stderr);
+    fatal_message_end ();
+  }
+  imported_clause.clear ();
+  STOP (checking);
+}
+
+// check if all clauses have been deleted
+void LratChecker::report_status (int, int64_t) {
+  START (checking);
+  if (num_finalized == num_clauses) {
+    num_finalized = 0;
+    LOG ("LRAT CHECKER successful finalize check, all clauses have been "
+         "deleted");
+  } else {
+    fatal_message_start ();
+    fputs ("finalize check failed ", stderr);
+    fprintf (stderr, "%" PRIu64, num_clauses);
+    fputs (" are not finalized", stderr);
+    fatal_message_end ();
+  }
+  STOP (checking);
+}
+
+/*------------------------------------------------------------------------*/
+
+void LratChecker::dump () {
+  int max_var = 0;
+  for (uint64_t i = 0; i < size_clauses; i++)
+    for (LratCheckerClause *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 (LratCheckerClause *c = clauses[i]; c; c = c->next) {
+      for (unsigned i = 0; i < c->size; i++)
+        printf ("%d ", c->literals[i]);
+      printf ("0\n");
+    }
+}
+
+void LratChecker::begin_proof (int64_t id) { current_id = id; }
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_lrattracer.cpp b/src/sat/cadical/cadical_lrattracer.cpp
new file mode 100644
index 000000000..4da728e18
--- /dev/null
+++ b/src/sat/cadical/cadical_lrattracer.cpp
@@ -0,0 +1,206 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+#include <limits.h>
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+LratTracer::LratTracer (Internal *i, File *f, bool b)
+    : internal (i), file (f), binary (b)
+#ifndef CADICAL_QUIET
+      ,
+      added (0), deleted (0)
+#endif
+      ,
+      latest_id (0) {
+  (void) internal;
+}
+
+void LratTracer::connect_internal (Internal *i) {
+  internal = i;
+  file->connect_internal (internal);
+  LOG ("LRAT TRACER connected to internal");
+}
+
+LratTracer::~LratTracer () {
+  LOG ("LRAT TRACER delete");
+  delete file;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void LratTracer::put_binary_zero () {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  file->put ((unsigned char) 0);
+}
+
+inline void LratTracer::put_binary_lit (int lit) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  CADICAL_assert (lit != INT_MIN);
+  unsigned idx = abs (lit);
+  CADICAL_assert (idx < (1u << 31));
+  unsigned x = 2 * idx + (lit < 0);
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+inline void LratTracer::put_binary_id (int64_t id) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  uint64_t x = abs (id);
+  x = 2 * x + (id < 0);
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+/*------------------------------------------------------------------------*/
+
+void LratTracer::lrat_add_clause (int64_t id, const vector<int> &clause,
+                                  const vector<int64_t> &chain) {
+  if (delete_ids.size ()) {
+    if (!binary)
+      file->put (latest_id), file->put (" ");
+    if (binary)
+      file->put ('d');
+    else
+      file->put ("d ");
+    for (auto &did : delete_ids) {
+      if (binary)
+        put_binary_id (did);
+      else
+        file->put (did), file->put (" ");
+    }
+    if (binary)
+      put_binary_zero ();
+    else
+      file->put ("0\n");
+    delete_ids.clear ();
+  }
+  latest_id = id;
+
+  if (binary)
+    file->put ('a'), put_binary_id (id);
+  else
+    file->put (id), file->put (" ");
+  for (const auto &external_lit : clause)
+    if (binary)
+      put_binary_lit (external_lit);
+    else
+      file->put (external_lit), file->put (' ');
+  if (binary)
+    put_binary_zero ();
+  else
+    file->put ("0 ");
+  for (const auto &c : chain)
+    if (binary)
+      put_binary_id (c);
+    else
+      file->put (c), file->put (' '); // in proof chain, so they get
+  if (binary)
+    put_binary_zero (); // since cadical has no rat-steps
+  else
+    file->put ("0\n"); // this is just 2c here
+}
+
+void LratTracer::lrat_delete_clause (int64_t id) {
+  delete_ids.push_back (id); // pushing off deletion for later
+}
+
+/*------------------------------------------------------------------------*/
+
+void LratTracer::add_derived_clause (int64_t id, bool,
+                                     const vector<int> &clause,
+                                     const vector<int64_t> &chain) {
+  if (file->closed ())
+    return;
+  LOG ("LRAT TRACER tracing addition of derived clause");
+  lrat_add_clause (id, clause, chain);
+#ifndef CADICAL_QUIET
+  added++;
+#endif
+}
+
+void LratTracer::delete_clause (int64_t id, bool, const vector<int> &) {
+  if (file->closed ())
+    return;
+  LOG ("LRAT TRACER tracing deletion of clause");
+  lrat_delete_clause (id);
+#ifndef CADICAL_QUIET
+  deleted++;
+#endif
+}
+
+void LratTracer::begin_proof (int64_t id) {
+  if (file->closed ())
+    return;
+  LOG ("LRAT TRACER tracing begin of proof");
+  latest_id = id;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool LratTracer::closed () { return file->closed (); }
+
+#ifndef CADICAL_QUIET
+
+void LratTracer::print_statistics () {
+  uint64_t bytes = file->bytes ();
+  uint64_t total = added + deleted;
+  MSG ("LRAT %" PRId64 " added clauses %.2f%%", added,
+       percent (added, total));
+  MSG ("LRAT %" PRId64 " deleted clauses %.2f%%", deleted,
+       percent (deleted, total));
+  MSG ("LRAT %" PRId64 " bytes (%.2f MB)", bytes,
+       bytes / (double) (1 << 20));
+}
+
+#endif
+
+void LratTracer::close (bool print) {
+  CADICAL_assert (!closed ());
+  file->close ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("LRAT proof file '%s' closed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+void LratTracer::flush (bool print) {
+  CADICAL_assert (!closed ());
+  file->flush ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("LRAT proof file '%s' flushed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_lucky.cpp b/src/sat/cadical/cadical_lucky.cpp
new file mode 100644
index 000000000..d67782db4
--- /dev/null
+++ b/src/sat/cadical/cadical_lucky.cpp
@@ -0,0 +1,440 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// It turns out that even in the competition there are formulas which are
+// easy to satisfy by either setting all variables to the same truth value
+// or by assigning variables to the same value and propagating it.  In the
+// latter situation this can be done either in the order of all variables
+// (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");
+  CADICAL_assert (!level);
+  CADICAL_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;
+    for (const auto &lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) {
+        satisfied = true;
+        break;
+      }
+      if (tmp < 0)
+        continue;
+      if (lit > 0)
+        continue;
+      found_negative_literal = true;
+      break;
+    }
+    if (satisfied || found_negative_literal)
+      continue;
+    LOG (c, "found purely positively");
+    return unlucky (0);
+  }
+  VERBOSE (1, "all clauses contain a negative literal");
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10))
+      return unlucky (-1);
+    if (val (idx))
+      continue;
+    search_assume_decision (-idx);
+    if (propagate ())
+      continue;
+    CADICAL_assert (level > 0);
+    LOG ("propagation failed including redundant clauses");
+    return unlucky (0);
+  }
+  stats.lucky.constant.zero++;
+  return 10;
+}
+
+int Internal::trivially_true_satisfiable () {
+  LOG ("checking that all clauses contain a positive literal");
+  CADICAL_assert (!level);
+  CADICAL_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;
+    for (const auto &lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) {
+        satisfied = true;
+        break;
+      }
+      if (tmp < 0)
+        continue;
+      if (lit < 0)
+        continue;
+      found_positive_literal = true;
+      break;
+    }
+    if (satisfied || found_positive_literal)
+      continue;
+    LOG (c, "found purely negatively");
+    return unlucky (0);
+  }
+  VERBOSE (1, "all clauses contain a positive literal");
+  for (auto idx : vars) {
+    if (terminated_asynchronously (10))
+      return unlucky (-1);
+    if (val (idx))
+      continue;
+    search_assume_decision (idx);
+    if (propagate ())
+      continue;
+    CADICAL_assert (level > 0);
+    LOG ("propagation failed including redundant clauses");
+    return unlucky (0);
+  }
+  stats.lucky.constant.one++;
+  return 10;
+}
+
+/*------------------------------------------------------------------------*/
+inline bool Internal::lucky_propagate_discrepency (int dec) {
+  search_assume_decision (dec);
+  bool no_conflict = propagate ();
+  if (no_conflict)
+    return false;
+  if (level > 1) {
+    backtrack (level - 1);
+    search_assume_decision (-dec);
+    no_conflict = propagate ();
+    if (no_conflict)
+      return false;
+    return true;
+  } else {
+    analyze ();
+    CADICAL_assert (!level);
+    no_conflict = propagate ();
+    if (!no_conflict) {
+      analyze ();
+      LOG ("lucky inconsistency backward assigning to true");
+      return true;
+    }
+  }
+  return false;
+}
+
+int Internal::forward_false_satisfiable () {
+  LOG ("checking increasing variable index false assignment");
+  CADICAL_assert (!unsat);
+  CADICAL_assert (!level);
+  CADICAL_assert (assumptions.empty ());
+  for (auto idx : vars) {
+  START:
+    if (terminated_asynchronously (100))
+      return unlucky (-1);
+    if (val (idx))
+      continue;
+    if (lucky_propagate_discrepency (-idx)) {
+      if (unsat)
+        return 20;
+      else
+        return unlucky (0);
+    } else
+      goto START;
+  }
+  VERBOSE (1, "forward assuming variables false satisfies formula");
+  CADICAL_assert (satisfied ());
+  stats.lucky.forward.zero++;
+  return 10;
+}
+
+int Internal::forward_true_satisfiable () {
+  LOG ("checking increasing variable index true assignment");
+  CADICAL_assert (!unsat);
+  CADICAL_assert (!level);
+  CADICAL_assert (assumptions.empty ());
+  for (auto idx : vars) {
+  START:
+    if (terminated_asynchronously (10))
+      return unlucky (-1);
+    if (val (idx))
+      continue;
+    if (lucky_propagate_discrepency (idx)) {
+      if (unsat)
+        return 20;
+      else
+        return unlucky (0);
+    } else
+      goto START;
+  }
+  VERBOSE (1, "forward assuming variables true satisfies formula");
+  CADICAL_assert (satisfied ());
+  stats.lucky.forward.one++;
+  return 10;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::backward_false_satisfiable () {
+  LOG ("checking decreasing variable index false assignment");
+  CADICAL_assert (!unsat);
+  CADICAL_assert (!level);
+  CADICAL_assert (assumptions.empty ());
+  for (int idx = max_var; idx > 0; idx--) {
+  START:
+    if (terminated_asynchronously (10))
+      return unlucky (-1);
+    if (val (idx))
+      continue;
+    if (lucky_propagate_discrepency (-idx)) {
+      if (unsat)
+        return 20;
+      else
+        return unlucky (0);
+    } else
+      goto START;
+  }
+  VERBOSE (1, "backward assuming variables false satisfies formula");
+  CADICAL_assert (satisfied ());
+  stats.lucky.backward.zero++;
+  return 10;
+}
+
+int Internal::backward_true_satisfiable () {
+  LOG ("checking decreasing variable index true assignment");
+  CADICAL_assert (!unsat);
+  CADICAL_assert (!level);
+  CADICAL_assert (assumptions.empty ());
+  for (int idx = max_var; idx > 0; idx--) {
+  START:
+    if (terminated_asynchronously (10))
+      return unlucky (-1);
+    if (val (idx))
+      continue;
+    if (lucky_propagate_discrepency (idx)) {
+      if (unsat)
+        return 20;
+      else
+        return unlucky (0);
+    } else
+      goto START;
+  }
+  VERBOSE (1, "backward assuming variables true satisfies formula");
+  CADICAL_assert (satisfied ());
+  stats.lucky.backward.one++;
+  return 10;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The following two functions test if the formula is a satisfiable horn
+// formula.  Actually the test is slightly more general.  It goes over all
+// clauses and assigns the first positive literal to true and propagates.
+// Already satisfied clauses are of course skipped.  A reverse function
+// is not implemented yet.
+
+int Internal::positive_horn_satisfiable () {
+  LOG ("checking that all clauses are positive horn satisfiable");
+  CADICAL_assert (!level);
+  CADICAL_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;
+    bool satisfied = false;
+    for (const auto &lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) {
+        satisfied = true;
+        break;
+      }
+      if (tmp < 0)
+        continue;
+      if (lit < 0)
+        continue;
+      positive_literal = lit;
+      break;
+    }
+    if (satisfied)
+      continue;
+    if (!positive_literal) {
+      LOG (c, "no positive unassigned literal in");
+      return unlucky (0);
+    }
+    CADICAL_assert (positive_literal > 0);
+    LOG (c, "found positive literal %d in", positive_literal);
+    search_assume_decision (positive_literal);
+    if (propagate ())
+      continue;
+    LOG ("propagation of positive literal %d leads to conflict",
+         positive_literal);
+    return unlucky (0);
+  }
+  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);
+    return unlucky (0);
+  }
+  VERBOSE (1, "clauses are positive horn satisfied");
+  CADICAL_assert (!conflict);
+  CADICAL_assert (satisfied ());
+  stats.lucky.horn.positive++;
+  return 10;
+}
+
+int Internal::negative_horn_satisfiable () {
+  LOG ("checking that all clauses are negative horn satisfiable");
+  CADICAL_assert (!level);
+  CADICAL_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;
+    bool satisfied = false;
+    for (const auto &lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp > 0) {
+        satisfied = true;
+        break;
+      }
+      if (tmp < 0)
+        continue;
+      if (lit > 0)
+        continue;
+      negative_literal = lit;
+      break;
+    }
+    if (satisfied)
+      continue;
+    if (!negative_literal) {
+      if (level > 0)
+        backtrack ();
+      LOG (c, "no negative unassigned literal in");
+      return unlucky (0);
+    }
+    CADICAL_assert (negative_literal < 0);
+    LOG (c, "found negative literal %d in", negative_literal);
+    search_assume_decision (negative_literal);
+    if (propagate ())
+      continue;
+    LOG ("propagation of negative literal %d leads to conflict",
+         negative_literal);
+    return unlucky (0);
+  }
+  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);
+    return unlucky (0);
+  }
+  VERBOSE (1, "clauses are negative horn satisfied");
+  CADICAL_assert (!conflict);
+  CADICAL_assert (satisfied ());
+  stats.lucky.horn.negative++;
+  return 10;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::lucky_phases () {
+  CADICAL_assert (!level);
+  require_mode (SEARCH);
+  if (!opts.lucky)
+    return 0;
+
+  // TODO: Some of the lucky assignments can also be found if there are
+  // assumptions, but this is not completely implemented nor tested yet.
+  // Nothing done for constraint either.
+  // External propagator assumes a CDCL loop, so lucky is not tried here.
+  if (!assumptions.empty () || !constraint.empty () || external_prop)
+    return 0;
+
+  START (search);
+  START (lucky);
+  CADICAL_assert (!searching_lucky_phases);
+  searching_lucky_phases = true;
+  stats.lucky.tried++;
+  const int64_t active_before = stats.active;
+  int res = trivially_false_satisfiable ();
+  if (!res)
+    res = trivially_true_satisfiable ();
+  if (!res)
+    res = forward_true_satisfiable ();
+  if (!res)
+    res = forward_false_satisfiable ();
+  if (!res)
+    res = backward_false_satisfiable ();
+  if (!res)
+    res = backward_true_satisfiable ();
+  if (!res)
+    res = positive_horn_satisfiable ();
+  if (!res)
+    res = negative_horn_satisfiable ();
+  if (res < 0)
+    CADICAL_assert (termination_forced), res = 0;
+  if (res == 10)
+    stats.lucky.succeeded++;
+  report ('l', !res);
+  CADICAL_assert (searching_lucky_phases);
+
+  const int64_t units = active_before - stats.active;
+
+  if (!res && units)
+    LOG ("lucky %zd units", units);
+  searching_lucky_phases = false;
+  STOP (lucky);
+  STOP (search);
+
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_message.cpp b/src/sat/cadical/cadical_message.cpp
new file mode 100644
index 000000000..42d8c0e48
--- /dev/null
+++ b/src/sat/cadical/cadical_message.cpp
@@ -0,0 +1,218 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+#ifndef CADICAL_QUIET
+/*------------------------------------------------------------------------*/
+
+void Internal::print_prefix () { fputs (prefix.c_str (), stdout); }
+
+void Internal::vmessage (const char *fmt, va_list &ap) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet)
+      return;
+  print_prefix ();
+  vprintf (fmt, ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+void Internal::message (const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  vmessage (fmt, ap);
+  va_end (ap);
+}
+
+void Internal::message () {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet)
+      return;
+  print_prefix ();
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::vverbose (int level, const char *fmt, va_list &ap) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet || level > opts.verbose)
+      return;
+  print_prefix ();
+  vprintf (fmt, ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+void Internal::verbose (int level, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  vverbose (level, fmt, ap);
+  va_end (ap);
+}
+
+void Internal::verbose (int level) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet || level > opts.verbose)
+      return;
+  print_prefix ();
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::section (const char *title) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet)
+      return;
+  if (stats.sections++)
+    MSG ();
+  print_prefix ();
+  tout.blue ();
+  fputs ("--- [ ", stdout);
+  tout.blue (true);
+  fputs (title, stdout);
+  tout.blue ();
+  fputs (" ] ", stdout);
+  for (int i = strlen (title) + strlen (prefix.c_str ()) + 9; i < 78; i++)
+    fputc ('-', stdout);
+  tout.normal ();
+  fputc ('\n', stdout);
+  MSG ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::phase (const char *phase, const char *fmt, ...) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet || (!force_phase_messages && opts.verbose < 2))
+      return;
+  print_prefix ();
+  printf ("[%s] ", phase);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+void Internal::phase (const char *phase, int64_t count, const char *fmt,
+                      ...) {
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet || (!force_phase_messages && opts.verbose < 2))
+      return;
+  print_prefix ();
+  printf ("[%s-%" PRId64 "] ", phase, count);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+#endif // ifndef CADICAL_QUIET
+/*------------------------------------------------------------------------*/
+
+void Internal::warning (const char *fmt, ...) {
+  fflush (stdout);
+  terr.bold ();
+  fputs ("cadical: ", stderr);
+  terr.red (1);
+  fputs ("warning:", stderr);
+  terr.normal ();
+  fputc (' ', stderr);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::error_message_start () {
+  fflush (stdout);
+  terr.bold ();
+  fputs ("cadical: ", stderr);
+  terr.red (1);
+  fputs ("error:", stderr);
+  terr.normal ();
+  fputc (' ', stderr);
+}
+
+void Internal::error_message_end () {
+  fputc ('\n', stderr);
+  fflush (stderr);
+  // TODO add possibility to use call back instead.
+  exit (1);
+}
+
+void Internal::verror (const char *fmt, va_list &ap) {
+  error_message_start ();
+  vfprintf (stderr, fmt, ap);
+  error_message_end ();
+}
+
+void Internal::error (const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  verror (fmt, ap);
+  va_end (ap); // unreachable
+}
+
+/*------------------------------------------------------------------------*/
+
+void fatal_message_start () {
+  fflush (stdout);
+  terr.bold ();
+  fputs ("cadical: ", stderr);
+  terr.red (1);
+  fputs ("fatal error:", stderr);
+  terr.normal ();
+  fputc (' ', stderr);
+}
+
+void fatal_message_end () {
+  fputc ('\n', stderr);
+  fflush (stderr);
+  abort ();
+}
+
+void fatal (const char *fmt, ...) {
+  fatal_message_start ();
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fatal_message_end ();
+  abort ();
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_minimize.cpp b/src/sat/cadical/cadical_minimize.cpp
new file mode 100644
index 000000000..97af5fbe6
--- /dev/null
+++ b/src/sat/cadical/cadical_minimize.cpp
@@ -0,0 +1,230 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// Functions for learned clause minimization. We only have the recursive
+// version, which actually really is implemented recursively.  We also
+// played with a derecursified version, which however was more complex and
+// slower.  The trick to keep potential stack exhausting recursion under
+// guards is to explicitly limit the recursion depth.
+
+// Instead of signatures as in the original implementation in MiniSAT and
+// our corresponding paper, we use the 'poison' idea of Allen Van Gelder to
+// mark unsuccessful removal attempts, then Donald Knuth's idea to abort
+// minimization if only one literal was seen on the level and a new idea of
+// also aborting if the earliest seen literal was assigned afterwards.
+
+bool Internal::minimize_literal (int lit, int depth) {
+  LOG ("attempt to minimize lit %d at depth %d", lit, depth);
+  CADICAL_assert (val (lit) > 0);
+  Flags &f = flags (lit);
+  Var &v = var (lit);
+  if (!v.level || f.removable || f.keep)
+    return true;
+  if (!v.reason || f.poison || v.level == level)
+    return false;
+  const Level &l = control[v.level];
+  if (!depth && l.seen.count < 2)
+    return false; // Don Knuth's idea
+  if (v.trail <= l.seen.trail)
+    return false; // new early abort
+  if (depth > opts.minimizedepth)
+    return false;
+  bool res = true;
+  CADICAL_assert (v.reason);
+  if (opts.minimizeticks)
+    stats.ticks.search[stable]++;
+  if (v.reason == external_reason) {
+    CADICAL_assert (!opts.exteagerreasons);
+    v.reason = learn_external_reason_clause (lit, 0, true);
+    if (!v.reason) {
+      CADICAL_assert (!v.level);
+      return true;
+    }
+  }
+  CADICAL_assert (v.reason != external_reason);
+  const const_literal_iterator end = v.reason->end ();
+  const_literal_iterator i;
+  for (i = v.reason->begin (); res && i != end; i++) {
+    const int other = *i;
+    if (other == lit)
+      continue;
+    res = minimize_literal (-other, depth + 1);
+  }
+  if (res)
+    f.removable = true;
+  else
+    f.poison = true;
+  minimized.push_back (lit);
+  if (!depth) {
+    LOG ("minimizing %d %s", lit, res ? "succeeded" : "failed");
+  }
+  return res;
+}
+
+// Sorting the clause before minimization with respect to the trail order
+// (literals with smaller trail height first) is necessary but natural and
+// might help to minimize the required recursion depth too.
+
+struct minimize_trail_positive_rank {
+  Internal *internal;
+  minimize_trail_positive_rank (Internal *s) : internal (s) {}
+  typedef unsigned Type;
+  Type operator() (const int &a) const {
+    CADICAL_assert (internal->val (a));
+    return (unsigned) internal->var (a).trail;
+  }
+};
+
+struct minimize_trail_smaller {
+  Internal *internal;
+  minimize_trail_smaller (Internal *s) : internal (s) {}
+  bool operator() (const int &a, const int &b) const {
+    return internal->var (a).trail < internal->var (b).trail;
+  }
+};
+
+struct minimize_trail_level_positive_rank {
+  Internal *internal;
+  minimize_trail_level_positive_rank (Internal *s) : internal (s) {}
+  typedef uint64_t Type;
+  Type operator() (const int &a) const {
+    CADICAL_assert (internal->val (a));
+    Var &v = internal->var (a);
+    uint64_t res = v.level;
+    res <<= 32;
+    res |= v.trail;
+    return res;
+  }
+};
+
+struct minimize_trail_level_smaller {
+  Internal *internal;
+  minimize_trail_level_smaller (Internal *s) : internal (s) {}
+  bool operator() (const int &a, const int &b) const {
+    return minimize_trail_level_positive_rank (internal) (a) <
+           minimize_trail_level_positive_rank (internal) (b);
+  }
+};
+
+void Internal::minimize_clause () {
+  START (minimize);
+  LOG (clause, "minimizing first UIP clause");
+
+  external->check_learned_clause (); // check 1st UIP learned clause first
+  minimize_sort_clause ();
+
+  CADICAL_assert (minimized.empty ());
+  CADICAL_assert (minimize_chain.empty ());
+  const auto end = clause.end ();
+  auto j = clause.begin (), i = j;
+  std::vector<int> stack;
+  for (; i != end; i++) {
+    if (minimize_literal (-*i)) {
+      if (lrat) {
+        CADICAL_assert (mini_chain.empty ());
+        calculate_minimize_chain (-*i, stack);
+        for (auto p : mini_chain) {
+          minimize_chain.push_back (p);
+        }
+        mini_chain.clear ();
+      }
+      stats.minimized++;
+    } else
+      flags (*j++ = *i).keep = true;
+  }
+  LOG ("minimized %zd literals", (size_t) (clause.end () - j));
+  if (j != end)
+    clause.resize (j - clause.begin ());
+  clear_minimized_literals ();
+  for (auto p = minimize_chain.rbegin (); p != minimize_chain.rend ();
+       p++) {
+    lrat_chain.push_back (*p);
+  }
+  minimize_chain.clear ();
+  STOP (minimize);
+}
+
+// go backwards in reason graph and add ids
+// mini_chain is in correct order so we have to add it to minimize_chain
+// and then reverse when we put it on lrat_chain
+//
+// We have to use the non-recursive as we cannot limit the depth like the
+// minimize version. Unlike the minimize version, we have to keep literals
+// on the stack in order to push its reason later.
+void Internal::calculate_minimize_chain (int lit, std::vector<int> &stack) {
+  CADICAL_assert (stack.empty ());
+  stack.push_back (vidx (lit));
+
+  while (!stack.empty ()) {
+    const int idx = stack.back ();
+    CADICAL_assert (idx);
+    stack.pop_back ();
+    if (idx < 0) {
+      Var &v = var (idx);
+      mini_chain.push_back (v.reason->id);
+      continue;
+    }
+    CADICAL_assert (idx);
+    Flags &f = flags (idx);
+    Var &v = var (idx);
+    if (f.keep || f.added || f.poison) {
+      continue;
+    }
+    if (!v.level) {
+      if (f.seen)
+        continue;
+      f.seen = true;
+      unit_analyzed.push_back (idx);
+      const int lit = val (idx) > 0 ? idx : -idx;
+      int64_t id = unit_id (lit);
+      unit_chain.push_back (id);
+      continue;
+    }
+    f.added = true;
+    CADICAL_assert (v.reason && f.removable);
+    const const_literal_iterator end = v.reason->end ();
+    const_literal_iterator i;
+    LOG (v.reason, "LRAT chain for lit %d at depth %zd by going over", lit,
+         stack.size ());
+    stack.push_back (-idx);
+    for (i = v.reason->begin (); i != end; i++) {
+      const int other = *i;
+      if (other == idx)
+        continue;
+      stack.push_back (vidx (other));
+    }
+  }
+  CADICAL_assert (stack.empty ());
+}
+
+// Sort the literals in reverse assignment order (thus trail order) to
+// establish the base case of the recursive minimization algorithm in the
+// positive case (where a literal with 'keep' true is hit).
+//
+void Internal::minimize_sort_clause () {
+  MSORT (opts.radixsortlim, clause.begin (), clause.end (),
+         minimize_trail_positive_rank (this),
+         minimize_trail_smaller (this));
+}
+
+void Internal::clear_minimized_literals () {
+  LOG ("clearing %zd minimized literals", minimized.size ());
+  for (const auto &lit : minimized) {
+    Flags &f = flags (lit);
+    f.poison = f.removable = f.shrinkable = f.added = false;
+  }
+  for (const auto &lit : clause)
+    CADICAL_assert (!flags (lit).shrinkable), flags (lit).keep =
+                                          flags (lit).shrinkable =
+                                              flags (lit).added = false;
+  minimized.clear ();
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_occs.cpp b/src/sat/cadical/cadical_occs.cpp
new file mode 100644
index 000000000..f79d7a690
--- /dev/null
+++ b/src/sat/cadical/cadical_occs.cpp
@@ -0,0 +1,58 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Occurrence lists.
+
+void Internal::init_occs () {
+  if (otab.size () < 2 * vsize)
+    otab.resize (2 * vsize, Occs ());
+  LOG ("initialized occurrence lists");
+}
+
+void Internal::reset_occs () {
+  CADICAL_assert (occurring ());
+  erase_vector (otab);
+  LOG ("reset occurrence lists");
+}
+
+void Internal::clear_occs () {
+  CADICAL_assert (occurring ());
+  for (auto &occ : otab)
+    occ.clear ();
+  LOG ("clear occurrence lists");
+}
+
+/*------------------------------------------------------------------------*/
+
+// One-sided occurrence counter (each literal has its own counter).
+
+void Internal::init_noccs () {
+  CADICAL_assert (ntab.empty ());
+  if (ntab.size () < 2 * vsize)
+    ntab.resize (2 * vsize, 0);
+  LOG ("initialized two-sided occurrence counters");
+}
+
+void Internal::clear_noccs () {
+  CADICAL_assert (!ntab.empty ());
+  for (auto &nt : ntab)
+    nt = 0;
+  LOG ("clear two-sided occurrence counters");
+}
+
+void Internal::reset_noccs () {
+  CADICAL_assert (!max_var || !ntab.empty ());
+  erase_vector (ntab);
+  LOG ("reset two-sided occurrence counters");
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_options.cpp b/src/sat/cadical/cadical_options.cpp
new file mode 100644
index 000000000..88eba53ab
--- /dev/null
+++ b/src/sat/cadical/cadical_options.cpp
@@ -0,0 +1,365 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// By default, e.g., for library usage, the 'opts.report' value is zero
+// ('false') but can be set to '1' by the stand alone solver.  Using here
+// a static default value avoids that the stand alone solver reports that
+// '--report=1' is different from the default in 'print ()' below.
+//
+int Options::reportdefault;
+
+/*------------------------------------------------------------------------*/
+
+// The order of initializations of static objects is undefined and thus we
+// can not assume that this table is already initialized if a solver and
+// thus the constructor of 'Options' is called.  Therefore we just have to
+// 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
+// '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, P, R, D) \
+  {#N, (int) V, (int) L, (int) H, (int) O, (bool) P, D},
+    OPTIONS
+#undef OPTION
+};
+
+/*------------------------------------------------------------------------*/
+
+// Binary search in 'table', which requires option names to be sorted, which
+// in turned is checked at start-up in 'Options::Options'.
+
+Option *Options::has (const char *name) {
+  size_t l = 0, r = number_of_options;
+  while (l < r) {
+    size_t m = l + (r - l) / 2;
+    Option *res = &table[m];
+    int tmp = strcmp (name, res->name);
+    if (!tmp)
+      return res;
+    if (tmp < 0)
+      r = m;
+    if (tmp > 0)
+      l = m + 1;
+  }
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Options::parse_long_option (const char *arg, string &name, int &val) {
+  if (arg[0] != '-' || arg[1] != '-')
+    return false;
+  const bool has_no_prefix =
+      (arg[2] == 'n' && arg[3] == 'o' && arg[4] == '-');
+  const size_t offset = has_no_prefix ? 5 : 2;
+  name = arg + offset;
+  const size_t pos = name.find_first_of ('=');
+  if (pos != string::npos)
+    name[pos] = 0;
+  if (!Options::has (name.c_str ()))
+    return false;
+  if (pos == string::npos)
+    val = !has_no_prefix;
+  else {
+    const char *val_str = name.c_str () + pos + 1;
+    if (!parse_int_str (val_str, val))
+      return false;
+  }
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::initialize_from_environment (int &val, const char *name,
+                                           const int L, const int H) {
+  char key[80], *q;
+  const char *p;
+  CADICAL_assert (strlen (name) + strlen ("CADICAL_") + 1 < sizeof (key));
+  for (p = "CADICAL_", q = key; *p; p++)
+    *q++ = *p;
+  for (p = name; *p; p++)
+    *q++ = toupper (*p);
+  CADICAL_assert (q < key + sizeof (key));
+  *q = 0;
+  const char *val_str = getenv (key);
+  if (!val_str)
+    return;
+  if (!parse_int_str (val_str, val))
+    return;
+  if (val < L)
+    val = L;
+  if (val > H)
+    val = H;
+}
+
+// Initialize all the options to their default value 'V'.
+
+Options::Options (Internal *s) : internal (s) {
+  CADICAL_assert (number_of_options == sizeof Options::table / sizeof (Option));
+
+  // First initialize them according to defaults in 'options.hpp'.
+  //
+  const char *prev = "";
+  size_t i = 0;
+#define OPTION(N, V, L, H, O, P, R, D) \
+  do { \
+    if ((L) > (V)) \
+      FATAL ("'" #N "' default '" #V "' " \
+             "lower minimum '" #L "' in 'options.hpp'"); \
+    if ((H) < (V)) \
+      FATAL ("'" #N "' default '" #V "' " \
+             "larger maximum '" #H "' in 'options.hpp'"); \
+    if (strcmp (prev, #N) > 0) \
+      FATAL ("'%s' ordered before '" #N "' in 'options.hpp'", prev); \
+    N = (int) (V); \
+    CADICAL_assert (&val (i) == &N); \
+    /* The order of initializing static data is undefined and thus */ \
+    /* it might be the case that the 'table' is not initialized yet. */ \
+    /* Thus this construction just reinitializes the table too even */ \
+    /* though it might not be necessary. */ \
+    CADICAL_assert (!table[i].name || !strcmp (table[i].name, #N)); \
+    table[i] = {#N,        (int) (V),  (int) (L), (int) (H), \
+                (int) (O), (bool) (P), D}; \
+    prev = #N; \
+    i++; \
+  } while (0);
+  OPTIONS
+#undef OPTION
+
+  // Check consistency in debugging mode.
+  //
+#ifndef CADICAL_NDEBUG
+  CADICAL_assert (i == number_of_options);
+  CADICAL_assert (!has ("aaaaa"));
+  CADICAL_assert (!has ("non-existing-option"));
+  CADICAL_assert (!has ("zzzzz"));
+#endif
+
+  // Now overwrite default options with environment values.
+  //
+#define OPTION(N, V, L, H, O, P, R, D) \
+  initialize_from_environment (N, #N, L, H);
+  OPTIONS
+#undef OPTION
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::set (Option *o, int new_val) {
+  CADICAL_assert (o);
+  int &val = o->val (this), old_val = val;
+  if (old_val == new_val) {
+    LOG ("keeping value '%d' of option '%s'", old_val, o->name);
+    return;
+  }
+  if (new_val < o->lo) {
+    LOG ("bounding '%d' to lower limit '%d' for option '%s'", new_val,
+         o->lo, o->name);
+    new_val = o->lo;
+  }
+  if (new_val > o->hi) {
+    LOG ("bounding '%d' to upper limit '%d' for option '%s'", new_val,
+         o->hi, o->name);
+    new_val = o->hi;
+  }
+  val = new_val;
+  LOG ("set option 'set (\"%s\", %d)' from '%d'", o->name, new_val,
+       old_val);
+}
+
+// Explicit option value setting.
+
+bool Options::set (const char *name, int val) {
+  Option *o = has (name);
+  if (!o)
+    return false;
+  set (o, val);
+  return true;
+}
+
+int Options::get (const char *name) {
+  Option *o = has (name);
+  return o ? o->val (this) : 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::print () {
+  unsigned different = 0;
+#ifdef CADICAL_QUIET
+  const bool verbose = false;
+#endif
+  char buffer[256];
+  // We prefer the macro iteration here since '[VLH]' might be '1e9' etc.
+#define OPTION(N, V, L, H, O, P, R, D) \
+  if (N != (V)) \
+    different++; \
+  if (verbose || N != (V)) { \
+    if ((L) == 0 && (H) == 1) { \
+      snprintf (buffer, sizeof buffer, "--" #N "=%s", \
+                (N ? "true" : "false")); \
+      MSG ("  %s%-30s%s (%s default %s'%s'%s)", \
+           ((N == (V)) ? "" : tout.bright_yellow_code ()), buffer, \
+           ((N == (V)) ? "" : tout.normal_code ()), \
+           ((N == (V)) ? "same as" : "different from"), \
+           ((N == (V)) ? tout.green_code () : tout.yellow_code ()), \
+           (bool) (V) ? "true" : "false", tout.normal_code ()); \
+    } else { \
+      snprintf (buffer, sizeof buffer, "--" #N "=%d", N); \
+      MSG ("  %s%-30s%s (%s default %s'" #V "'%s)", \
+           ((N == (V)) ? "" : tout.bright_yellow_code ()), buffer, \
+           ((N == (V)) ? "" : tout.normal_code ()), \
+           ((N == (V)) ? "same as" : "different from"), \
+           ((N == (V)) ? tout.green_code () : tout.yellow_code ()), \
+           tout.normal_code ()); \
+    } \
+  }
+  OPTIONS
+#undef OPTION
+  if (!different)
+    MSG ("all options are set to their default value");
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::usage () {
+  // We prefer the macro iteration here since '[VLH]' might be '1e9' etc.
+#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"); \
+  else \
+    printf ("  %-26s " D " [" #V "]\n", "--" #N "=" #L ".." #H);
+  OPTIONS
+#undef OPTION
+}
+
+/*------------------------------------------------------------------------*/
+
+void Options::optimize (int val) {
+
+  if (val < 0) {
+    LOG ("ignoring negative optimization mode '%d'", val);
+    return;
+  }
+
+  const int max_val = 31;
+  if (val > max_val) {
+    LOG ("optimization argument '%d' reduced to '%d'", val, max_val);
+    val = max_val;
+  }
+
+  int64_t factor2 = 1;
+  for (int i = 0; i < val && factor2 <= INT_MAX; i++)
+    factor2 *= 2;
+
+  int64_t factor10 = 1;
+  for (int i = 0; i < val && factor10 <= INT_MAX; i++)
+    factor10 *= 10;
+
+  unsigned increased = 0;
+#define OPTION(N, V, L, H, O, P, R, D) \
+  do { \
+    if (!(O)) \
+      break; \
+    const int64_t factor1 = ((O) == 1 ? factor2 : factor10); \
+    int64_t new_val = factor1 * (int64_t) (V); \
+    if (new_val > (H)) \
+      new_val = (H); \
+    if (new_val == (int) (V)) \
+      break; \
+    LOG ("optimization mode '%d' for '%s' " \
+         "gives '%" PRId64 "' instead of '%d", \
+         val, #N, new_val, (int) (V)); \
+    CADICAL_assert (new_val <= INT_MAX); \
+    N = (int) new_val; \
+    increased++; \
+  } while (0);
+  OPTIONS
+#undef OPTION
+  if (increased)
+    MSG ("optimization mode '-O%d' increased %u limits", val, increased);
+}
+
+/*------------------------------------------------------------------------*/
+
+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; \
+    LOG ("plain mode disables '%s'", #N); \
+    CADICAL_assert ((L) == 0); \
+    CADICAL_assert ((H) == 1); \
+    count++; \
+    N = 0; \
+  } while (0);
+  OPTIONS
+#undef OPTION
+  LOG ("forced plain mode disabled %zd preprocessing options", count);
+#ifndef LOGGING
+  (void) count;
+#endif
+}
+
+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);
+#ifndef LOGGING
+  (void) count;
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+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
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_parse.cpp b/src/sat/cadical/cadical_parse.cpp
new file mode 100644
index 000000000..0668aca7d
--- /dev/null
+++ b/src/sat/cadical/cadical_parse.cpp
@@ -0,0 +1,442 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Parse error.
+
+#define PER(...) \
+  do { \
+    internal->error_message.init ( \
+        "%s:%" PRIu64 ": parse error: ", file->name (), \
+        (uint64_t) file->lineno ()); \
+    return internal->error_message.append (__VA_ARGS__); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+
+// Parsing utilities.
+
+inline int Parser::parse_char () { return file->get (); }
+
+// Return an non zero error string if a parse error occurred.
+
+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;
+}
+
+inline const char *Parser::parse_positive_int (int &ch, int &res,
+                                               const char *name) {
+  CADICAL_assert (isdigit (ch));
+  res = ch - '0';
+  while (isdigit (ch = parse_char ())) {
+    int digit = ch - '0';
+    if (INT_MAX / 10 < res || INT_MAX - digit < 10 * res)
+      PER ("too large '%s' in header", name);
+    res = 10 * res + digit;
+  }
+  return 0;
+}
+
+static const char *cube_token = "unexpected 'a' in CNF";
+
+inline const char *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 '-'");
+    sign = -1;
+  } else if (!isdigit (ch))
+    PER ("expected digit or '-'");
+  else
+    sign = 1;
+  lit = ch - '0';
+  while (isdigit (ch = parse_char ())) {
+    int digit = ch - '0';
+    if (INT_MAX / 10 < lit || INT_MAX - digit < 10 * lit)
+      PER ("literal too large");
+    lit = 10 * lit + digit;
+  }
+  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) {
+    if (strict != FORCED)
+      PER ("literal %d exceeds maximum variable %d", sign * lit, vars);
+    else
+      vars = lit;
+  }
+  lit *= sign;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Parsing CNF in DIMACS format.
+
+const char *Parser::parse_dimacs_non_profiled (int &vars, int strict) {
+
+#ifndef CADICAL_QUIET
+  double start = internal->time ();
+#endif
+
+  bool found_inccnf_header = false;
+  int ch, clauses = 0;
+  vars = 0;
+
+  // First read comments before header with possibly embedded options.
+  //
+  for (;;) {
+    ch = parse_char ();
+    if (strict != STRICT)
+      if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+        continue;
+    if (ch != 'c')
+      break;
+    string buf;
+    while ((ch = parse_char ()) != '\n')
+      if (ch == EOF)
+        PER ("unexpected end-of-file in header comment");
+      else if (ch != '\r')
+        buf.push_back (ch);
+    const char *o;
+    for (o = buf.c_str (); *o && *o != '-'; o++)
+      ;
+    if (!*o)
+      continue;
+    PHASE ("parse-dimacs", "found option '%s'", o);
+    if (*o)
+      solver->set_long_option (o);
+  }
+
+  if (ch != 'p')
+    PER ("expected 'c' or 'p'");
+
+  ch = parse_char ();
+  if (strict == STRICT) {
+    if (ch != ' ')
+      PER ("expected space after 'p'");
+    ch = parse_char ();
+  } else if (ch != ' ' && ch != '\t')
+    PER ("expected white space after 'p'");
+  else {
+    do
+      ch = parse_char ();
+    while (ch == ' ' || ch == '\t');
+  }
+
+  // Now read 'p cnf <var> <clauses>' header of DIMACS file
+  // or 'p inccnf' of incremental 'INCCNF' file.
+  //
+  if (ch == 'c') {
+    CADICAL_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);
+    internal->reserve_ids (clauses);
+  } 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 '");
+
+  if (parse_inccnf_too)
+    *parse_inccnf_too = false;
+
+  // Now read body of DIMACS part.
+  //
+  int lit = 0, parsed = 0;
+  while ((ch = parse_char ()) != EOF) {
+    if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+      continue;
+    if (ch == 'c') {
+      while ((ch = parse_char ()) != '\n' && ch != EOF)
+        ;
+      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') {
+      while ((ch = parse_char ()) != '\n')
+        if (ch == EOF)
+          PER ("unexpected end-of-file in comment");
+    }
+    solver->add (lit);
+    if (!found_inccnf_header && !lit && parsed++ >= clauses &&
+        strict != FORCED)
+      PER ("too many clauses");
+  }
+
+  if (lit)
+    PER ("last clause without terminating '0'");
+
+  if (!found_inccnf_header && parsed < clauses && strict != FORCED)
+    PER ("clause missing");
+
+#ifndef CADICAL_QUIET
+  double end = internal->time ();
+  MSG ("parsed %d clauses in %.2f seconds %s time", parsed, end - start,
+       internal->opts.realtime ? "real" : "process");
+#endif
+
+#ifndef CADICAL_QUIET
+  start = end;
+  size_t num_cubes = 0;
+#endif
+  if (ch == 'a') {
+    CADICAL_assert (parse_inccnf_too);
+    CADICAL_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) {
+#ifndef CADICAL_QUIET
+        num_cubes++;
+#endif
+        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 CADICAL_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;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Parsing solution in competition output format.
+
+const char *Parser::parse_solution_non_profiled () {
+  external->solution = new signed char[external->max_var + 1u];
+  external->solution_size = external->max_var;
+  clear_n (external->solution, external->max_var + 1u);
+  int ch;
+  for (;;) {
+    ch = parse_char ();
+    if (ch == EOF)
+      PER ("missing 's' line");
+    else if (ch == 'c') {
+      while ((ch = parse_char ()) != '\n')
+        if (ch == EOF)
+          PER ("unexpected end-of-file in comment");
+    } else if (ch == 's')
+      break;
+    else
+      PER ("expected 'c' or 's'");
+  }
+  const char *err = parse_string (" SATISFIABLE", 's');
+  if (err)
+    return err;
+  if ((ch = parse_char ()) == '\r')
+    ch = parse_char ();
+  if (ch != '\n')
+    PER ("expected new-line after 's SATISFIABLE'");
+#ifndef CADICAL_QUIET
+  int count = 0;
+#endif
+  for (;;) {
+    ch = parse_char ();
+    if (ch != 'v')
+      PER ("expected 'v' at start-of-line");
+    if ((ch = parse_char ()) != ' ')
+      PER ("expected ' ' after 'v'");
+    int lit = 0;
+    ch = parse_char ();
+    do {
+      if (ch == ' ' || ch == '\t') {
+        ch = parse_char ();
+        continue;
+      }
+      err = parse_lit (ch, lit, external->max_var, false);
+      if (err)
+        return err;
+      if (ch == 'c')
+        PER ("unexpected comment");
+      if (!lit)
+        break;
+      if (external->solution[abs (lit)])
+        PER ("variable %d occurs twice", abs (lit));
+      LOG ("solution %d", lit);
+      external->solution[abs (lit)] = sign (lit);
+#ifndef CADICAL_QUIET
+      count++;
+#endif
+      if (ch == '\r')
+        ch = parse_char ();
+    } while (ch != '\n');
+    if (!lit)
+      break;
+  }
+  MSG ("parsed %d values %.2f%%", count,
+       percent (count, external->max_var));
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Wrappers to profile parsing and at the same time use the convenient
+// implicit 'return' in PER in the non-profiled versions.
+
+const char *Parser::parse_dimacs (int &vars, int strict) {
+  CADICAL_assert (strict == FORCED || strict == RELAXED || strict == STRICT);
+  START (parse);
+  const char *err = parse_dimacs_non_profiled (vars, strict);
+  STOP (parse);
+  return err;
+}
+
+const char *Parser::parse_solution () {
+  START (parse);
+  const char *err = parse_solution_non_profiled ();
+  STOP (parse);
+  return err;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_phases.cpp b/src/sat/cadical/cadical_phases.cpp
new file mode 100644
index 000000000..f7e4eaffd
--- /dev/null
+++ b/src/sat/cadical/cadical_phases.cpp
@@ -0,0 +1,50 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::copy_phases (vector<signed char> &dst) {
+  START (copy);
+  for (auto i : vars)
+    dst[i] = phases.saved[i];
+  STOP (copy);
+}
+
+void Internal::clear_phases (vector<signed char> &dst) {
+  START (copy);
+  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) {
+    LOG ("forced phase remains at %d", old_forced_phase * idx);
+    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) {
+    LOG ("forced phase of %d already reset", lit);
+    return;
+  }
+  LOG ("clearing old forced phase %d", old_forced_phase * idx);
+  phases.forced[idx] = 0;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_probe.cpp b/src/sat/cadical/cadical_probe.cpp
new file mode 100644
index 000000000..19ff0961f
--- /dev/null
+++ b/src/sat/cadical/cadical_probe.cpp
@@ -0,0 +1,993 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Failed literal probing uses its own propagation and assignment
+// functions.  It further provides on-the-fly generation of hyper binary
+// resolvents but only probes on roots of the binary implication graph.  The
+// search for failed literals is limited, but untried roots are kept until
+// the next time 'probe' is called.  Left over probes from the last attempt
+// and new probes are tried until the limit is hit or all are tried.
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::inprobing () {
+  if (!opts.inprobing)
+    return false;
+  if (!preprocessing && !opts.inprocessing)
+    return false;
+  if (preprocessing)
+    CADICAL_assert (lim.preprocessing);
+  if (stats.inprobingphases && last.inprobe.reductions == stats.reductions)
+    return false;
+  return lim.inprobe <= stats.conflicts;
+}
+
+/*------------------------------------------------------------------------*/
+
+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;
+}
+
+/*-----------------------------------------------------------------------*/
+
+// for opts.probehbr=false we need to do a lot of extra work to remember the
+// correct lrat_chains... This solution is also memory intensive I think
+// all corresponding functions are guarded to only work with the right
+// options so they can be called without checking for options
+//
+// call locally after failed_literal or backtracking
+//
+void Internal::clean_probehbr_lrat () {
+  if (!lrat || opts.probehbr)
+    return;
+  for (auto &field : probehbr_chains) {
+    for (auto &chain : field) {
+      chain.clear ();
+    }
+  }
+}
+
+// call globally before a probe round (or a lookahead round)
+//
+void Internal::init_probehbr_lrat () {
+  if (!lrat || opts.probehbr)
+    return;
+  const size_t size = 2 * (1 + (size_t) max_var);
+  probehbr_chains.resize (size);
+  for (size_t i = 0; i < size; i++) {
+    probehbr_chains[i].resize (size);
+    // commented because not needed... should be empty already
+    /*
+    for (size_t j = 0; j < size; j++) {
+      vector<int64_t> empty;
+      probehbr_chains[i][j] = empty;
+    }
+    */
+  }
+}
+
+// sets lrat_chain to the stored chain in probehbr_chains.
+// this leads to conflict with unit reason uip
+//
+void Internal::get_probehbr_lrat (int lit, int uip) {
+  if (!lrat || opts.probehbr)
+    return;
+  CADICAL_assert (lit);
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (val (uip) < 0);
+  lrat_chain = probehbr_chains[vlit (lit)][vlit (uip)];
+  int64_t id = unit_id (-uip);
+  lrat_chain.push_back (id);
+}
+
+// sets the corresponding probehbr_chain to what is currently stored in
+// lrat_chain. also clears lrat_chain.
+//
+void Internal::set_probehbr_lrat (int lit, int uip) {
+  if (!lrat || opts.probehbr)
+    return;
+  CADICAL_assert (lit);
+  CADICAL_assert (lrat_chain.size ());
+  CADICAL_assert (probehbr_chains[vlit (lit)][vlit (uip)].empty ());
+  probehbr_chains[vlit (lit)][vlit (uip)] = lrat_chain;
+  lrat_chain.clear ();
+}
+
+// compute lrat_chain for the part of the tree from lit to dom
+// use mini_chain because it needs to be reversed
+//
+void Internal::probe_dominator_lrat (int dom, Clause *reason) {
+  if (!lrat || !dom)
+    return;
+  LOG (reason, "probe dominator LRAT for %d from", dom);
+  for (const auto lit : *reason) {
+    if (val (lit) >= 0)
+      continue;
+    const auto other = -lit;
+    if (other == dom)
+      continue;
+    Flags &f = flags (other);
+    if (f.seen)
+      continue;
+    f.seen = true;
+    analyzed.push_back (other);
+    Var u = var (other);
+    if (u.level) {
+      if (!u.reason) {
+        LOG ("this may be a problem %d", other);
+        continue;
+      }
+      probe_dominator_lrat (dom, u.reason);
+      continue;
+    }
+    int64_t id = unit_id (other);
+    lrat_chain.push_back (id);
+  }
+  lrat_chain.push_back (reason->id);
+}
+
+/*------------------------------------------------------------------------*/
+
+// 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.
+
+// Compute a dominator of two literals in the binary implication tree.
+
+int Internal::probe_dominator (int a, int b) {
+  require_mode (PROBE);
+  int l = a, k = b;
+  Var *u = &var (l), *v = &var (k);
+  CADICAL_assert (val (l) > 0), CADICAL_assert (val (k) > 0);
+  CADICAL_assert (u->level == 1), CADICAL_assert (v->level == 1);
+  while (l != k) {
+    if (u->trail > v->trail)
+      swap (l, k), swap (u, v);
+    if (!get_parent_reason_literal (l))
+      return l;
+    int parent = get_parent_reason_literal (k);
+    CADICAL_assert (parent), CADICAL_assert (val (parent) > 0);
+    v = &var (k = parent);
+    CADICAL_assert (v->level == 1);
+  }
+  LOG ("dominator %d of %d and %d", l, a, b);
+  CADICAL_assert (val (l) > 0);
+  return l;
+}
+
+// The idea of dynamic on-the-fly hyper-binary resolution came up in the
+// PrecoSAT solver, where it originally was used on all decision levels.
+
+// It turned out, that most of the hyper-binary resolvents were generated
+// during probing on decision level one anyhow.  Thus this version is
+// specialized to decision level one, where actually all long (non-binary)
+// forcing clauses can be resolved to become binary.  So if we find a clause
+// which would force a new assignment at decision level one during probing
+// we resolve it (the 'reason' argument) to obtain a hyper binary resolvent.
+// It consists of the still unassigned literal (the new unit) and the
+// negation of the unique closest dominator of the negation of all (false)
+// literals in the clause (which has to exist on decision level one).
+
+// There are two special cases which should be mentioned:
+//
+//   (A) The reason is already a binary clause in a certain sense, since all
+//   its unwatched literals are root level fixed to false.  In this
+//   situation it would be better to shrink the clause immediately instead
+//   of adding a new clause consisting only of the watched literals.
+//   However, this would happen during the next garbage collection anyhow.
+//
+//   (B) The resolvent subsumes the original reason clause. This is
+//   equivalent to the property that the negated dominator is contained in
+//   the original reason.  Again one could in principle shrink the clause.
+//
+// Note that (A) is actually subsumed by (B).  The possible optimization to
+// shrink the clause on-the-fly is difficult (need to update 'blit' and
+// 'binary' of the other watch at least) and also not really that important.
+// For (B) we simply add the new binary resolvent and mark the old subsumed
+// clause as garbage instead.  And since in the situation of (A) the
+// shrinking will be performed at the next  garbage collection anyhow, we
+// do not change clauses in (A).
+
+// The hyper binary resolvent clause is redundant unless it subsumes the
+// original reason and that one is irredundant.
+
+// If the option 'opts.probehbr' is 'false', we actually do not add the new
+// hyper binary resolvent, but simply pretend we would have added it and
+// still return the dominator as new reason / parent for the new unit.
+
+// Finally note that adding clauses changes the watches of the propagated
+// literal and thus we can not use standard iterators during probing but
+// need to fall back to indices.  One watch for the hyper binary resolvent
+// clause is added at the end of the currently propagated watches, but its
+// watch is a binary watch and will be skipped during propagating long
+// clauses anyhow.
+
+inline int Internal::hyper_binary_resolve (Clause *reason) {
+  require_mode (PROBE);
+  CADICAL_assert (level == 1);
+  CADICAL_assert (reason->size > 2);
+  const const_literal_iterator end = reason->end ();
+  const int *lits = reason->literals;
+  const_literal_iterator k;
+#ifndef CADICAL_NDEBUG
+  // First literal unassigned, all others false.
+  CADICAL_assert (!val (lits[0]));
+  for (k = lits + 1; k != end; k++)
+    CADICAL_assert (val (*k) < 0);
+  CADICAL_assert (var (lits[1]).level == 1);
+#endif
+  LOG (reason, "hyper binary resolving");
+  stats.hbrs++;
+  stats.hbrsizes += reason->size;
+  const int lit = lits[1];
+  int dom = -lit, non_root_level_literals = 0;
+  for (k = lits + 2; k != end; k++) {
+    const int other = -*k;
+    CADICAL_assert (val (other) > 0);
+    if (!var (other).level)
+      continue;
+    dom = probe_dominator (dom, other);
+    non_root_level_literals++;
+  }
+  probe_reason = reason;
+  if (non_root_level_literals && opts.probehbr) { // !(A)
+    bool contained = false;
+    for (k = lits + 1; !contained && k != end; k++)
+      contained = (*k == -dom);
+    const bool red = !contained || reason->redundant;
+    if (red)
+      stats.hbreds++;
+    LOG ("new %s hyper binary resolvent %d %d",
+         (red ? "redundant" : "irredundant"), -dom, lits[0]);
+    CADICAL_assert (clause.empty ());
+    clause.push_back (-dom);
+    clause.push_back (lits[0]);
+    probe_dominator_lrat (dom, reason);
+    if (lrat)
+      clear_analyzed_literals ();
+    Clause *c = new_hyper_binary_resolved_clause (red, 2);
+    probe_reason = c;
+    if (red)
+      c->hyper = true;
+    clause.clear ();
+    lrat_chain.clear ();
+    if (contained) {
+      stats.hbrsubs++;
+      LOG (reason, "subsumed original");
+      mark_garbage (reason);
+    }
+  } else if (non_root_level_literals && lrat) {
+    // still calculate LRAT and remember for later
+    CADICAL_assert (!opts.probehbr);
+    probe_dominator_lrat (dom, reason);
+    clear_analyzed_literals ();
+    set_probehbr_lrat (dom, lits[0]);
+  }
+  return dom;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The following functions 'probe_assign' and 'probe_propagate' are used for
+// propagating during failed literal probing in simplification mode, as
+// replacement of the generic propagation routine 'propagate' and
+// 'search_assign'.
+
+// The code is mostly copied from 'propagate.cpp' and specialized.  We only
+// comment on the differences.  More explanations are in 'propagate.cpp'.
+
+inline void Internal::probe_assign (int lit, int parent) {
+  require_mode (PROBE);
+  int idx = vidx (lit);
+  CADICAL_assert (!val (idx));
+  CADICAL_assert (!flags (idx).eliminated () || !parent);
+  CADICAL_assert (!parent || val (parent) > 0);
+  Var &v = var (idx);
+  v.level = level;
+  v.trail = (int) trail.size ();
+  CADICAL_assert ((int) num_assigned < max_var);
+  num_assigned++;
+  v.reason = level ? probe_reason : 0;
+  probe_reason = 0;
+  set_parent_reason_literal (lit, parent);
+  if (!level)
+    learn_unit_clause (lit);
+  else
+    CADICAL_assert (level == 1);
+  const signed char tmp = sign (lit);
+  set_val (idx, tmp);
+  CADICAL_assert (val (lit) > 0);
+  CADICAL_assert (val (-lit) < 0);
+  trail.push_back (lit);
+
+  // Do not save the current phase during inprocessing but remember the
+  // number of units on the trail of the last time this literal was
+  // assigned.  This allows us to avoid some redundant failed literal
+  // probing attempts.  Search for 'propfixed' in 'probe.cpp' for details.
+  //
+  if (level)
+    propfixed (lit) = stats.all.fixed;
+
+  if (parent)
+    LOG ("probe assign %d parent %d", lit, parent);
+  else if (level)
+    LOG ("probe assign %d probe", lit);
+  else
+    LOG ("probe assign %d negated failed literal UIP", lit);
+}
+
+void Internal::probe_assign_decision (int lit) {
+  require_mode (PROBE);
+  CADICAL_assert (!level);
+  CADICAL_assert (propagated == trail.size ());
+  level++;
+  control.push_back (Level (lit, trail.size ()));
+  probe_assign (lit, 0);
+}
+
+void Internal::probe_assign_unit (int lit) {
+  require_mode (PROBE);
+  CADICAL_assert (!level);
+  CADICAL_assert (active (lit));
+  probe_assign (lit, 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+// same as in propagate but inlined here
+//
+inline void Internal::probe_lrat_for_units (int lit) {
+  if (!lrat)
+    return;
+  if (level)
+    return; // not decision level 0
+  LOG ("building chain for units");
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (probe_reason);
+  for (auto &reason_lit : *probe_reason) {
+    if (lit == reason_lit)
+      continue;
+    CADICAL_assert (val (reason_lit));
+    if (!val (reason_lit))
+      continue;
+    const int signed_reason_lit = val (reason_lit) * reason_lit;
+    int64_t id = unit_id (signed_reason_lit);
+    lrat_chain.push_back (id);
+  }
+  lrat_chain.push_back (probe_reason->id);
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is essentially the same as 'propagate' except that we prioritize and
+// always propagate binary clauses first (see our CPAIOR'13 paper on tree
+// based look ahead), then immediately stop at a conflict and of course use
+// 'probe_assign' instead of 'search_assign'.  The binary propagation part
+// is factored out too.  If a new unit on decision level one is found we
+// perform hyper binary resolution and thus actually build an implication
+// tree instead of a DAG.  Statistics counters are also different.
+
+inline void Internal::probe_propagate2 () {
+  require_mode (PROBE);
+  int64_t &ticks = stats.ticks.probe;
+  while (propagated2 != trail.size ()) {
+    const int lit = -trail[propagated2++];
+    LOG ("probe propagating %d over binary clauses", -lit);
+    Watches &ws = watches (lit);
+    ticks += 1 + cache_lines (ws.size (), sizeof (const_watch_iterator *));
+    for (const auto &w : ws) {
+      if (!w.binary ())
+        continue;
+      const signed char b = val (w.blit);
+      if (b > 0)
+        continue;
+      ticks++;
+      if (b < 0)
+        conflict = w.clause; // but continue
+      else {
+        CADICAL_assert (lrat_chain.empty ());
+        CADICAL_assert (!probe_reason);
+        probe_reason = w.clause;
+        probe_lrat_for_units (w.blit);
+        probe_assign (w.blit, -lit);
+        lrat_chain.clear ();
+      }
+    }
+  }
+}
+
+bool Internal::probe_propagate () {
+  require_mode (PROBE);
+  CADICAL_assert (!unsat);
+  START (propagate);
+  int64_t before = propagated2 = propagated;
+  int64_t &ticks = stats.ticks.probe;
+  while (!conflict) {
+    if (propagated2 != trail.size ())
+      probe_propagate2 ();
+    else if (propagated != trail.size ()) {
+      const int lit = -trail[propagated++];
+      LOG ("probe propagating %d over large clauses", -lit);
+      Watches &ws = watches (lit);
+      ticks += 1 + cache_lines (ws.size (),
+                                sizeof (sizeof (const_watch_iterator *)));
+      size_t i = 0, j = 0;
+      while (i != ws.size ()) {
+        const Watch w = ws[j++] = ws[i++];
+        if (w.binary ())
+          continue;
+        const signed char b = val (w.blit);
+        if (b > 0)
+          continue;
+        ticks++;
+        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;
+        const signed char u = val (other);
+        if (u > 0)
+          ws[j - 1].blit = other;
+        else {
+          const int size = w.clause->size;
+          const const_literal_iterator end = lits + size;
+          const literal_iterator middle = lits + w.clause->pos;
+          literal_iterator k = middle;
+          int r = 0;
+          signed char v = -1;
+          while (k != end && (v = val (r = *k)) < 0)
+            k++;
+          if (v < 0) {
+            k = lits + 2;
+            CADICAL_assert (w.clause->pos <= size);
+            while (k != middle && (v = val (r = *k)) < 0)
+              k++;
+          }
+          w.clause->pos = k - lits;
+          CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
+          if (v > 0)
+            ws[j - 1].blit = r;
+          else if (!v) {
+            ticks++;
+            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) {
+            ticks++;
+            if (level == 1) {
+              lits[0] = other, lits[1] = lit;
+              CADICAL_assert (lrat_chain.empty ());
+              CADICAL_assert (!probe_reason);
+              int dom = hyper_binary_resolve (w.clause);
+              probe_assign (other, dom);
+            } else {
+              ticks++;
+              CADICAL_assert (lrat_chain.empty ());
+              CADICAL_assert (!probe_reason);
+              probe_reason = w.clause;
+              probe_lrat_for_units (other);
+              probe_assign_unit (other);
+              lrat_chain.clear ();
+            }
+            probe_propagate2 ();
+          } else
+            conflict = w.clause;
+        }
+      }
+      if (j != i) {
+        while (i != ws.size ())
+          ws[j++] = ws[i++];
+        ws.resize (j);
+      }
+    } else
+      break;
+  }
+  int64_t delta = propagated2 - before;
+  stats.propagations.probe += delta;
+  if (conflict)
+    LOG (conflict, "conflict");
+  STOP (propagate);
+  return !conflict;
+}
+
+/*------------------------------------------------------------------------*/
+
+// This a specialized instance of 'analyze'.
+
+void Internal::failed_literal (int failed) {
+
+  LOG ("analyzing failed literal probe %d", failed);
+  stats.failed++;
+  stats.probefailed++;
+
+  CADICAL_assert (!unsat);
+  CADICAL_assert (conflict);
+  CADICAL_assert (level == 1);
+  CADICAL_assert (analyzed.empty ());
+  CADICAL_assert (lrat_chain.empty ());
+
+  START (analyze);
+
+  LOG (conflict, "analyzing failed literal conflict");
+
+  int uip = 0;
+  for (const auto &lit : *conflict) {
+    const int other = -lit;
+    if (!var (other).level) {
+      CADICAL_assert (val (other) > 0);
+      continue;
+    }
+    uip = uip ? probe_dominator (uip, other) : other;
+  }
+  probe_dominator_lrat (uip, conflict);
+  if (lrat)
+    clear_analyzed_literals ();
+
+  LOG ("found probing UIP %d", uip);
+  CADICAL_assert (uip);
+
+  vector<int> work;
+
+  int parent = uip;
+  while (parent != failed) {
+    const int next = get_parent_reason_literal (parent);
+    parent = next;
+    CADICAL_assert (parent);
+    work.push_back (parent);
+  }
+
+  backtrack ();
+  conflict = 0;
+
+  CADICAL_assert (!val (uip));
+  probe_assign_unit (-uip);
+  lrat_chain.clear ();
+
+  if (!probe_propagate ())
+    learn_empty_clause ();
+
+  size_t j = 0;
+  while (!unsat && j < work.size ()) {
+    // CADICAL_assert (!opts.probehbr);        CADICAL_assertion fails ...
+    const int parent = work[j++];
+    const signed char tmp = val (parent);
+    if (tmp > 0) {
+      CADICAL_assert (!opts.probehbr); // ... CADICAL_assertion should hold here
+      get_probehbr_lrat (parent, uip);
+      LOG ("clashing failed parent %d", parent);
+      learn_empty_clause ();
+    } else if (tmp == 0) {
+      CADICAL_assert (!opts.probehbr); // ... and here
+      LOG ("found unassigned failed parent %d", parent);
+      get_probehbr_lrat (parent, uip); // this is computed during
+      probe_assign_unit (-parent);     // propagation and can include
+      lrat_chain.clear ();             // multiple chains where only one
+      if (!probe_propagate ())
+        learn_empty_clause (); // is needed!
+    }
+    uip = parent;
+  }
+  work.clear ();
+  erase_vector (work);
+
+  STOP (analyze);
+
+  CADICAL_assert (unsat || val (failed) < 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::is_binary_clause (Clause *c, int &a, int &b) {
+  CADICAL_assert (!level);
+  if (c->garbage)
+    return false;
+  int first = 0, second = 0;
+  for (const auto &lit : *c) {
+    const signed char tmp = val (lit);
+    if (tmp > 0)
+      return false;
+    if (tmp < 0)
+      continue;
+    if (second)
+      return false;
+    if (first)
+      second = lit;
+    else
+      first = lit;
+  }
+  if (!second)
+    return false;
+  a = first, b = second;
+  return true;
+}
+
+// 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) {}
+  typedef size_t Type;
+  Type operator() (int a) const { return internal->noccs (-a); }
+};
+
+// Fill the 'probes' schedule.
+
+void Internal::generate_probes () {
+
+  CADICAL_assert (probes.empty ());
+
+  int64_t &ticks = stats.ticks.probe;
+
+  // 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 ();
+  ticks += 1 + cache_lines (clauses.size (), sizeof (Clause *));
+  for (const auto &c : clauses) {
+    int a, b;
+    ticks++;
+    if (!is_binary_clause (c, a, b))
+      continue;
+    noccs (a)++;
+    noccs (b)++;
+  }
+
+  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.
+    // 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.
+
+    ticks += 2;
+
+    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;
+
+    int probe = have_neg_bin_occs ? idx : -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 %zd literals %.0f%%", probes.size (),
+         percent (probes.size (), 2u * max_var));
+}
+
+// Follow the ideas in 'generate_probes' but flush non root probes and
+// reorder remaining probes.
+
+void Internal::flush_probes () {
+
+  CADICAL_assert (!probes.empty ());
+  int64_t &ticks = stats.ticks.probe;
+
+  init_noccs ();
+  ticks += 1 + cache_lines (clauses.size (), sizeof (Clause *));
+  for (const auto &c : clauses) {
+    int a, b;
+    ticks++;
+    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;
+    ticks += 2;
+    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;
+    CADICAL_assert (!noccs (lit)), CADICAL_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 CADICAL_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);
+}
+
+int Internal::next_probe () {
+
+  int generated = 0;
+
+  for (;;) {
+
+    if (probes.empty ()) {
+      if (generated++)
+        return 0;
+      generate_probes ();
+    }
+
+    while (!probes.empty ()) {
+
+      int probe = probes.back ();
+      probes.pop_back ();
+
+      // Eliminated or assigned.
+      //
+      if (!active (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 Internal::probe () {
+
+  if (!opts.probe)
+    return false;
+  if (unsat)
+    return false;
+  if (terminated_asynchronously ())
+    return false;
+
+  SET_EFFORT_LIMIT (limit, probe, true);
+
+  START_SIMPLIFIER (probe, PROBE);
+  stats.probingrounds++;
+
+  // Probing is limited in terms of non-probing propagations
+  // 'stats.propagations'. We allow a certain percentage 'opts.probeeffort'
+  // (say %5) of probing propagations in each probing with a lower bound of
+  // 'opts.probmineff'.
+  //
+
+  PHASE ("probe-round", stats.probingrounds,
+         "probing limit of %" PRId64 " propagations ", limit);
+
+  int old_failed = stats.failed;
+#ifndef CADICAL_QUIET
+  int64_t old_probed = stats.probed;
+#endif
+  int64_t old_hbrs = stats.hbrs;
+
+  if (!probes.empty ())
+    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 (auto idx : vars)
+    propfixed (idx) = propfixed (-idx) = -1;
+
+  CADICAL_assert (unsat || propagated == trail.size ());
+  propagated = propagated2 = trail.size ();
+
+  int probe;
+  init_probehbr_lrat ();
+  while (!unsat && !terminated_asynchronously () &&
+         stats.ticks.probe < limit && (probe = next_probe ())) {
+    stats.probed++;
+    LOG ("probing %d", probe);
+    probe_assign_decision (probe);
+    if (probe_propagate ())
+      backtrack ();
+    else
+      failed_literal (probe);
+    clean_probehbr_lrat ();
+  }
+
+  if (unsat)
+    LOG ("probing derived empty clause");
+  else if (propagated < trail.size ()) {
+    LOG ("probing produced %zd units",
+         (size_t) (trail.size () - propagated));
+    if (!propagate ()) {
+      LOG ("propagating units after probing results in empty clause");
+      learn_empty_clause ();
+    } else
+      sort_watches ();
+  }
+
+  int failed = stats.failed - old_failed;
+#ifndef CADICAL_QUIET
+  int64_t probed = stats.probed - old_probed;
+#endif
+  int64_t hbrs = stats.hbrs - old_hbrs;
+
+  PHASE ("probe-round", stats.probingrounds,
+         "probed %" PRId64 " and found %d failed literals", probed, failed);
+
+  if (hbrs)
+    PHASE ("probe-round", stats.probingrounds,
+           "found %" PRId64 " hyper binary resolvents", hbrs);
+
+  STOP_SIMPLIFIER (probe, PROBE);
+
+  report ('p', !opts.reportall && !(unsat + failed + hbrs));
+
+  return !unsat && failed;
+}
+
+/*------------------------------------------------------------------------*/
+
+// This schedules a number of inprocessing techniques.
+// These range from very cheap and beneficial (decompose) to
+// more expensive and sometimes less beneficial. We want to limit
+// expensive techniques to some fraction of total time or search time.
+// this is done using 'ticks'.
+// Generally, there are options for each of the techniques to set the
+// efficiency, i.e., the fraction of ticks they are allowed as budget.
+// Whenever e.g. vivify is called, the budget is calculated from the
+// search ticks that have passed since the last vivify round and this
+// efficiency.
+// We want to be able to run inprocessing frequently, without it dominating
+// runtimes. This entire inprocessing scheme is scheduled after a certain
+// amount of conflicts were found, the gap between two inprocessing rounds
+// increasing by a constant number each time. In effect, the number of
+// inprocessing rounds is allways the square root of the number of conflicts
+// with some constant factor.
+// This factor can also be with the option 'inprobeint'
+// Some of the techniques are not run always, for different reasons.
+// 'factor' or BVA depends on certain structures of the irredundant clauses
+// and as such will only be run when new irredundant clauses are derived or
+// it was not able to finish with the entire search space.
+// 'sweeping' is especially usefull on certain classes of formulas, and uses
+// a increasing or decreasing delay that depends on how usefull it was.
+// In cases where it is less usefull, we obviously want to reset the budged,
+// even if the routine was delayed.
+// Additionally 'vivify', 'sweep' and 'factor' can also have a big initial
+// overhead in setting up the datastructures. This has to be accounted for
+// with the 'ticks', however, since inprocessing is done frequently, this
+// overhead is too expensive to pay. So instead, we accumulate the budget
+// of 'ticks' and delay the technique until it passes a certain threshhold,
+// which depends on the the cost of initialization. Note that in the case of
+// sweeping, we have two different delays, one which resets the budged, and
+// one which passes it to the next round. In this case the former takes
+// precendent, until we would run sweeping once, at which point the focus
+// switches to the latter delay until the budget is big enough, such that
+// sweeping can be run. Then we switch back to the other delay.
+
+void CaDiCaL::Internal::inprobe (bool update_limits) {
+
+  if (unsat)
+    return;
+  if (level)
+    backtrack ();
+  if (!propagate ()) {
+    learn_empty_clause ();
+    return;
+  }
+
+  stats.inprobingphases++;
+  if (external_prop) {
+    CADICAL_assert (!level);
+    private_steps = true;
+  }
+  const int before = active ();
+  const int before_extended = stats.variables_extension;
+
+  // schedule of inprobing techniques.
+  //
+  {
+    mark_duplicated_binary_clauses_as_garbage ();
+    decompose ();
+    if (ternary ())
+      decompose (); // If we derived a binary clause
+    if (probe ())
+      decompose ();
+
+    if (extract_gates ())
+      decompose ();
+    if (sweep ())     // full occurrence list
+      decompose ();   // ... and (ELS) afterwards.
+    (void) vivify (); // resets watches
+    transred ();      // builds big.
+    factor ();   // resets watches, partial occurrence list
+  }
+
+  if (external_prop) {
+    CADICAL_assert (!level);
+    private_steps = false;
+  }
+
+  if (!update_limits)
+    return;
+
+  const int after = active ();
+  const int after_extended = stats.variables_extension;
+  const int diff_extended = after_extended - before_extended;
+  CADICAL_assert (diff_extended >= 0);
+  const int removed = before - after + diff_extended;
+  CADICAL_assert (removed >= 0);
+
+  if (removed) {
+    stats.inprobesuccess++;
+    PHASE ("probe-phase", stats.inprobingphases,
+           "successfully removed %d active variables %.0f%%", removed,
+           percent (removed, before));
+  } else
+    PHASE ("probe-phase", stats.inprobingphases,
+           "could not remove any active variable");
+
+  const int64_t delta =
+      25 * opts.inprobeint * log10 (stats.inprobingphases + 9);
+  lim.inprobe = stats.conflicts + delta;
+
+  PHASE ("probe-phase", stats.inprobingphases,
+         "new limit at %" PRId64 " conflicts after %" PRId64 " conflicts",
+         lim.inprobe, delta);
+
+  last.inprobe.reductions = stats.reductions;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_profile.cpp b/src/sat/cadical/cadical_profile.cpp
new file mode 100644
index 000000000..a95c97661
--- /dev/null
+++ b/src/sat/cadical/cadical_profile.cpp
@@ -0,0 +1,113 @@
+#include "global.h"
+
+#ifndef CADICAL_QUIET
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// Initialize all profile counters with constant name and profiling level.
+
+Profiles::Profiles (Internal *s)
+    : internal (s)
+#define PROFILE(NAME, LEVEL) , NAME (#NAME, LEVEL)
+          PROFILES
+#undef PROFILE
+{
+}
+
+void Internal::start_profiling (Profile &profile, double s) {
+  CADICAL_assert (profile.level <= opts.profile);
+  CADICAL_assert (!profile.active);
+  profile.started = s;
+  profile.active = true;
+}
+
+void Internal::stop_profiling (Profile &profile, double s) {
+  CADICAL_assert (profile.level <= opts.profile);
+  CADICAL_assert (profile.active);
+  profile.value += s - profile.started;
+  profile.active = false;
+}
+
+double Internal::update_profiles () {
+  double now = time ();
+#define PROFILE(NAME, LEVEL) \
+  do { \
+    Profile &profile = profiles.NAME; \
+    if (profile.active) { \
+      CADICAL_assert (profile.level <= opts.profile); \
+      profile.value += now - profile.started; \
+      profile.started = now; \
+    } \
+  } while (0);
+  PROFILES
+#undef PROFILE
+  return now;
+}
+
+double Internal::solve_time () {
+  (void) update_profiles ();
+  return profiles.solve.value;
+}
+
+#define PRT(S, T) \
+  MSG ("%s" S "%s", tout.magenta_code (), T, tout.normal_code ())
+
+void Internal::print_profile () {
+  double now = update_profiles ();
+  const char *time_type = opts.realtime ? "real" : "process";
+  SECTION ("run-time profiling");
+  PRT ("%s time taken by individual solving procedures", time_type);
+  PRT ("(percentage relative to %s time for solving)", time_type);
+  LINE ();
+  const size_t size = sizeof profiles / sizeof (Profile);
+  struct Profile *profs[size];
+  size_t n = 0;
+#define PROFILE(NAME, LEVEL) \
+  do { \
+    if (LEVEL > opts.profile) \
+      break; \
+    Profile *p = &profiles.NAME; \
+    if (p == &profiles.solve) \
+      break; \
+    if (!profiles.NAME.value && p != &profiles.parse && \
+        p != &profiles.search && p != &profiles.simplify) \
+      break; \
+    profs[n++] = p; \
+  } while (0);
+  PROFILES
+#undef PROFILE
+
+  CADICAL_assert (n <= size);
+
+  // Explicit bubble sort to avoid heap allocation since 'print_profile'
+  // is also called during catching a signal after out of heap memory.
+  // This only makes sense if 'profs' is allocated on the stack, and
+  // not the heap, which should be the case.
+
+  double solve = profiles.solve.value;
+
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = i + 1; j < n; j++)
+      if (profs[j]->value > profs[i]->value)
+        swap (profs[i], profs[j]);
+    MSG ("%12.2f %7.2f%% %s", profs[i]->value,
+         percent (profs[i]->value, solve), profs[i]->name);
+  }
+
+  MSG ("  =================================");
+  MSG ("%12.2f %7.2f%% solve", solve, percent (solve, now));
+
+  LINE ();
+  PRT ("last line shows %s time for solving", time_type);
+  PRT ("(percentage relative to total %s time)", time_type);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+#endif // ifndef CADICAL_QUIET
diff --git a/src/sat/cadical/cadical_proof.cpp b/src/sat/cadical/cadical_proof.cpp
new file mode 100644
index 000000000..13c9a1a5d
--- /dev/null
+++ b/src/sat/cadical/cadical_proof.cpp
@@ -0,0 +1,663 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+using namespace std;
+
+/*------------------------------------------------------------------------*/
+
+// Enable proof logging and checking by allocating a 'Proof' object.
+
+void Internal::new_proof_on_demand () {
+  if (!proof) {
+    LOG ("connecting proof to internal solver");
+    proof = new Proof (this);
+  }
+}
+
+void Internal::resize_unit_clauses_idx () {
+  size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) max_var;
+  unit_clauses_idx.resize (2 * new_vsize, 0);
+}
+
+void Internal::force_lrat () {
+  if (lrat)
+    return;
+  CADICAL_assert (proof);
+  lrat = true;
+}
+
+void Internal::connect_proof_tracer (Tracer *tracer, bool antecedents,
+                                     bool finalize_clauses) {
+  new_proof_on_demand ();
+  if (antecedents)
+    force_lrat ();
+  if (finalize_clauses)
+    frat = true;
+  resize_unit_clauses_idx ();
+  proof->connect (tracer);
+  tracers.push_back (tracer);
+}
+
+void Internal::connect_proof_tracer (InternalTracer *tracer,
+                                     bool antecedents,
+                                     bool finalize_clauses) {
+  new_proof_on_demand ();
+  if (antecedents)
+    force_lrat ();
+  if (finalize_clauses)
+    frat = true;
+  resize_unit_clauses_idx ();
+  tracer->connect_internal (this);
+  proof->connect (tracer);
+  tracers.push_back (tracer);
+}
+
+void Internal::connect_proof_tracer (StatTracer *tracer, bool antecedents,
+                                     bool finalize_clauses) {
+  new_proof_on_demand ();
+  if (antecedents)
+    force_lrat ();
+  if (finalize_clauses)
+    frat = true;
+  resize_unit_clauses_idx ();
+  tracer->connect_internal (this);
+  proof->connect (tracer);
+  stat_tracers.push_back (tracer);
+}
+
+void Internal::connect_proof_tracer (FileTracer *tracer, bool antecedents,
+                                     bool finalize_clauses) {
+  new_proof_on_demand ();
+  if (antecedents)
+    force_lrat ();
+  if (finalize_clauses)
+    frat = true;
+  resize_unit_clauses_idx ();
+  tracer->connect_internal (this);
+  proof->connect (tracer);
+  file_tracers.push_back (tracer);
+}
+
+bool Internal::disconnect_proof_tracer (Tracer *tracer) {
+  auto it = std::find (tracers.begin (), tracers.end (), tracer);
+  if (it != tracers.end ()) {
+    tracers.erase (it);
+    CADICAL_assert (proof);
+    proof->disconnect (tracer);
+    return true;
+  }
+  return false;
+}
+
+bool Internal::disconnect_proof_tracer (StatTracer *tracer) {
+  auto it = std::find (stat_tracers.begin (), stat_tracers.end (), tracer);
+  if (it != stat_tracers.end ()) {
+    stat_tracers.erase (it);
+    CADICAL_assert (proof);
+    proof->disconnect (tracer);
+    return true;
+  }
+  return false;
+}
+
+bool Internal::disconnect_proof_tracer (FileTracer *tracer) {
+  auto it = std::find (file_tracers.begin (), file_tracers.end (), tracer);
+  if (it != file_tracers.end ()) {
+    file_tracers.erase (it);
+    CADICAL_assert (proof);
+    proof->disconnect (tracer);
+    return true;
+  }
+  return false;
+}
+
+void Proof::disconnect (Tracer *t) {
+  tracers.erase (std::remove (tracers.begin (), tracers.end (), t),
+                 tracers.end ());
+}
+
+// Enable proof tracing.
+
+void Internal::trace (File *file) {
+  if (opts.veripb) {
+    LOG ("PROOF connecting VeriPB tracer");
+    bool antecedents = opts.veripb == 1 || opts.veripb == 2;
+    bool deletions = opts.veripb == 2 || opts.veripb == 4;
+    FileTracer *ft =
+        new VeripbTracer (this, file, opts.binary, antecedents, deletions);
+    connect_proof_tracer (ft, antecedents);
+  } else if (opts.frat) {
+    LOG ("PROOF connecting FRAT tracer");
+    bool antecedents = opts.frat == 1;
+    resize_unit_clauses_idx ();
+    FileTracer *ft =
+        new FratTracer (this, file, opts.binary, opts.frat == 1);
+    connect_proof_tracer (ft, antecedents, true);
+  } else if (opts.lrat) {
+    LOG ("PROOF connecting LRAT tracer");
+    FileTracer *ft = new LratTracer (this, file, opts.binary);
+    connect_proof_tracer (ft, true);
+  } else if (opts.idrup) {
+    LOG ("PROOF connecting IDRUP tracer");
+    FileTracer *ft = new IdrupTracer (this, file, opts.binary);
+    connect_proof_tracer (ft, true);
+  } else if (opts.lidrup) {
+    LOG ("PROOF connecting LIDRUP tracer");
+    FileTracer *ft = new LidrupTracer (this, file, opts.binary);
+    connect_proof_tracer (ft, true);
+  } else {
+    LOG ("PROOF connecting DRAT tracer");
+    FileTracer *ft = new DratTracer (this, file, opts.binary);
+    connect_proof_tracer (ft, false);
+  }
+}
+
+// Enable proof checking.
+
+void Internal::check () {
+  new_proof_on_demand ();
+  if (opts.checkproof > 1) {
+    StatTracer *lratchecker = new LratChecker (this);
+    DeferDeletePtr<LratChecker> delete_lratchecker (
+        (LratChecker *) lratchecker);
+    LOG ("PROOF connecting LRAT proof checker");
+    force_lrat ();
+    frat = true;
+    resize_unit_clauses_idx ();
+    proof->connect (lratchecker);
+    stat_tracers.push_back (lratchecker);
+    delete_lratchecker.release ();
+  }
+  if (opts.checkproof == 1 || opts.checkproof == 3) {
+    StatTracer *checker = new Checker (this);
+    DeferDeletePtr<Checker> delete_checker ((Checker *) checker);
+    LOG ("PROOF connecting proof checker");
+    proof->connect (checker);
+    stat_tracers.push_back (checker);
+    delete_checker.release ();
+  }
+}
+
+// We want to close a proof trace and stop checking as soon we are done.
+
+void Internal::close_trace (bool print) {
+  for (auto &tracer : file_tracers)
+    tracer->close (print);
+}
+
+// We can flush a proof trace file before actually closing it.
+
+void Internal::flush_trace (bool print) {
+  for (auto &tracer : file_tracers)
+    tracer->flush (print);
+}
+
+/*------------------------------------------------------------------------*/
+
+Proof::Proof (Internal *s) : internal (s) { LOG ("PROOF new"); }
+
+Proof::~Proof () { LOG ("PROOF delete"); }
+
+/*------------------------------------------------------------------------*/
+
+inline void Proof::add_literal (int internal_lit) {
+  const int external_lit = internal->externalize (internal_lit);
+  clause.push_back (external_lit);
+}
+
+inline void Proof::add_literals (Clause *c) {
+  for (auto const &lit : *c)
+    add_literal (lit);
+}
+
+inline void Proof::add_literals (const vector<int> &c) {
+  for (auto const &lit : c)
+    add_literal (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Proof::add_original_clause (int64_t id, bool r, const vector<int> &c) {
+  LOG (c, "PROOF adding original internal clause");
+  add_literals (c);
+  clause_id = id;
+  redundant = r;
+  add_original_clause ();
+}
+
+void Proof::add_external_original_clause (int64_t id, bool r,
+                                          const vector<int> &c,
+                                          bool restore) {
+  // literals of c are already external
+  CADICAL_assert (clause.empty ());
+  for (auto const &lit : c)
+    clause.push_back (lit);
+  clause_id = id;
+  redundant = r;
+  add_original_clause (restore);
+}
+
+void Proof::delete_external_original_clause (int64_t id, bool r,
+                                             const vector<int> &c) {
+  // literals of c are already external
+  CADICAL_assert (clause.empty ());
+  for (auto const &lit : c)
+    clause.push_back (lit);
+  clause_id = id;
+  redundant = r;
+  delete_clause ();
+}
+
+void Proof::add_derived_empty_clause (int64_t id,
+                                      const vector<int64_t> &chain) {
+  LOG ("PROOF adding empty clause");
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (proof_chain.empty ());
+  for (const auto &cid : chain)
+    proof_chain.push_back (cid);
+  clause_id = id;
+  redundant = false;
+  add_derived_clause ();
+}
+
+void Proof::add_derived_unit_clause (int64_t id, int internal_unit,
+                                     const vector<int64_t> &chain) {
+  LOG ("PROOF adding unit clause %d", internal_unit);
+  CADICAL_assert (proof_chain.empty ());
+  CADICAL_assert (clause.empty ());
+  add_literal (internal_unit);
+  for (const auto &cid : chain)
+    proof_chain.push_back (cid);
+  clause_id = id;
+  redundant = false;
+  add_derived_clause ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void Proof::add_derived_clause (Clause *c, const vector<int64_t> &chain) {
+  LOG (c, "PROOF adding to proof derived");
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (proof_chain.empty ());
+  add_literals (c);
+  for (const auto &cid : chain)
+    proof_chain.push_back (cid);
+  clause_id = c->id;
+  redundant = c->redundant;
+  add_derived_clause ();
+}
+
+void Proof::add_derived_clause (int64_t id, bool r, const vector<int> &c,
+                                const vector<int64_t> &chain) {
+  LOG (c, "PROOF adding derived clause");
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (proof_chain.empty ());
+  for (const auto &lit : c)
+    add_literal (lit);
+  for (const auto &cid : chain)
+    proof_chain.push_back (cid);
+  clause_id = id;
+  redundant = r;
+  add_derived_clause ();
+}
+
+void Proof::add_assumption_clause (int64_t id, const vector<int> &c,
+                                   const vector<int64_t> &chain) {
+  // literals of c are already external
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (proof_chain.empty ());
+  for (const auto &lit : c)
+    clause.push_back (lit);
+  for (const auto &cid : chain)
+    proof_chain.push_back (cid);
+  clause_id = id;
+  add_assumption_clause ();
+}
+
+void Proof::add_assumption (int a) {
+  // a is already external
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (proof_chain.empty ());
+  clause.push_back (a);
+  add_assumption ();
+}
+
+void Proof::add_constraint (const vector<int> &c) {
+  // literals of c are already external
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (proof_chain.empty ());
+  for (const auto &lit : c)
+    clause.push_back (lit);
+  add_constraint ();
+}
+
+void Proof::add_assumption_clause (int64_t id, int lit,
+                                   const vector<int64_t> &chain) {
+  CADICAL_assert (clause.empty ());
+  CADICAL_assert (proof_chain.empty ());
+  clause.push_back (lit);
+  for (const auto &cid : chain)
+    proof_chain.push_back (cid);
+  clause_id = id;
+  add_assumption_clause ();
+}
+
+void Proof::delete_clause (Clause *c) {
+  LOG (c, "PROOF deleting from proof");
+  clause.clear (); // Can be non-empty if an allocation fails during adding.
+  add_literals (c);
+  clause_id = c->id;
+  redundant = c->redundant;
+  delete_clause (); // Increments 'statistics.deleted'.
+}
+
+void Proof::delete_clause (int64_t id, bool r, const vector<int> &c) {
+  LOG (c, "PROOF deleting from proof");
+  CADICAL_assert (clause.empty ());
+  add_literals (c);
+  clause_id = id;
+  redundant = r;
+  delete_clause (); // Increments 'statistics.deleted'.
+}
+
+void Proof::weaken_minus (Clause *c) {
+  LOG (c, "PROOF weaken minus of");
+  CADICAL_assert (clause.empty ());
+  add_literals (c);
+  clause_id = c->id;
+  weaken_minus ();
+}
+
+void Proof::weaken_minus (int64_t id, const vector<int> &c) {
+  LOG (c, "PROOF deleting from proof");
+  CADICAL_assert (clause.empty ());
+  add_literals (c);
+  clause_id = id;
+  weaken_minus ();
+}
+
+void Proof::weaken_plus (Clause *c) {
+  weaken_minus (c);
+  delete_clause (c); // Increments 'statistics.deleted'.
+}
+
+void Proof::weaken_plus (int64_t id, const vector<int> &c) {
+  weaken_minus (id, c);
+  delete_clause (id, false, c); // Increments 'statistics.deleted'.
+}
+
+void Proof::delete_unit_clause (int64_t id, const int lit) {
+  LOG ("PROOF deleting unit from proof %d", lit);
+  CADICAL_assert (clause.empty ());
+  add_literal (lit);
+  clause_id = id;
+  redundant = false;
+  delete_clause ();
+}
+
+void Proof::finalize_clause (Clause *c) {
+  LOG (c, "PROOF finalizing clause");
+  CADICAL_assert (clause.empty ());
+  add_literals (c);
+  clause_id = c->id;
+  finalize_clause ();
+}
+
+void Proof::finalize_clause (int64_t id, const vector<int> &c) {
+  LOG (c, "PROOF finalizing clause");
+  CADICAL_assert (clause.empty ());
+  for (const auto &lit : c)
+    add_literal (lit);
+  clause_id = id;
+  finalize_clause ();
+}
+
+void Proof::finalize_unit (int64_t id, int lit) {
+  LOG ("PROOF finalizing clause %d", lit);
+  CADICAL_assert (clause.empty ());
+  add_literal (lit);
+  clause_id = id;
+  finalize_clause ();
+}
+
+void Proof::finalize_external_unit (int64_t id, int lit) {
+  LOG ("PROOF finalizing clause %d", lit);
+  CADICAL_assert (clause.empty ());
+  clause.push_back (lit);
+  clause_id = id;
+  finalize_clause ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// During garbage collection clauses are shrunken by removing falsified
+// literals. To avoid copying the clause, we provide a specialized tracing
+// function here, which traces the required 'add' and 'remove' operations.
+
+void Proof::flush_clause (Clause *c) {
+  LOG (c, "PROOF flushing falsified literals in");
+  CADICAL_assert (clause.empty ());
+  const bool antecedents = (internal->lrat || internal->frat);
+  for (int i = 0; i < c->size; i++) {
+    int internal_lit = c->literals[i];
+    if (internal->fixed (internal_lit) < 0) {
+      if (antecedents) {
+        int64_t id = internal->unit_id (-internal_lit);
+        proof_chain.push_back (id);
+      }
+      continue;
+    }
+    add_literal (internal_lit);
+  }
+  proof_chain.push_back (c->id);
+  redundant = c->redundant;
+  int64_t id = ++internal->clause_id;
+  clause_id = id;
+  add_derived_clause ();
+  delete_clause (c);
+  c->id = id;
+}
+
+// While strengthening clauses, e.g., through self-subsuming resolutions,
+// during subsumption checking, we have a similar situation, except that we
+// have to remove exactly one literal.  Again the following function allows
+// to avoid copying the clause and instead provides tracing of the required
+// 'add' and 'remove' operations.
+
+void Proof::strengthen_clause (Clause *c, int remove,
+                               const vector<int64_t> &chain) {
+  LOG (c, "PROOF strengthen by removing %d in", remove);
+  CADICAL_assert (clause.empty ());
+  for (int i = 0; i < c->size; i++) {
+    int internal_lit = c->literals[i];
+    if (internal_lit == remove)
+      continue;
+    add_literal (internal_lit);
+  }
+  int64_t id = ++internal->clause_id;
+  clause_id = id;
+  redundant = c->redundant;
+  for (const auto &cid : chain)
+    proof_chain.push_back (cid);
+  add_derived_clause ();
+  delete_clause (c);
+  c->id = id;
+}
+
+void Proof::otfs_strengthen_clause (Clause *c, const std::vector<int> &old,
+                                    const vector<int64_t> &chain) {
+  LOG (c, "PROOF otfs strengthen");
+  CADICAL_assert (clause.empty ());
+  for (int i = 0; i < c->size; i++) {
+    int internal_lit = c->literals[i];
+    add_literal (internal_lit);
+  }
+  int64_t id = ++internal->clause_id;
+  clause_id = id;
+  redundant = c->redundant;
+  for (const auto &cid : chain)
+    proof_chain.push_back (cid);
+  add_derived_clause ();
+  delete_clause (c->id, c->redundant, old);
+  c->id = id;
+}
+
+void Proof::strengthen (int64_t id) {
+  clause_id = id;
+  strengthen ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void Proof::add_original_clause (bool restore) {
+  LOG (clause, "PROOF adding original external clause");
+  CADICAL_assert (clause_id);
+
+  for (auto &tracer : tracers) {
+    tracer->add_original_clause (clause_id, false, clause, restore);
+  }
+  clause.clear ();
+  clause_id = 0;
+}
+
+void Proof::add_derived_clause () {
+  LOG (clause, "PROOF adding derived external clause (redundant: %d)",
+       redundant);
+  CADICAL_assert (clause_id);
+  for (auto &tracer : tracers) {
+    tracer->add_derived_clause (clause_id, redundant, clause, proof_chain);
+  }
+  proof_chain.clear ();
+  clause.clear ();
+  clause_id = 0;
+}
+
+void Proof::delete_clause () {
+  LOG (clause, "PROOF deleting external clause");
+  for (auto &tracer : tracers) {
+    tracer->delete_clause (clause_id, redundant, clause);
+  }
+  clause.clear ();
+  clause_id = 0;
+}
+
+void Proof::demote_clause () {
+  LOG (clause, "PROOF demoting external clause");
+  CADICAL_assert (!redundant);
+  for (auto &tracer : tracers) {
+    tracer->demote_clause (clause_id, clause);
+  }
+  clause.clear ();
+  clause_id = 0;
+}
+
+void Proof::weaken_minus () {
+  LOG (clause, "PROOF marking as clause to restore");
+  for (auto &tracer : tracers) {
+    tracer->weaken_minus (clause_id, clause);
+  }
+  clause.clear ();
+  clause_id = 0;
+}
+
+void Proof::strengthen () {
+  LOG ("PROOF strengthen clause with id %" PRId64, clause_id);
+  for (auto &tracer : tracers) {
+    tracer->strengthen (clause_id);
+  }
+  clause_id = 0;
+}
+
+void Proof::finalize_clause () {
+  for (auto &tracer : tracers) {
+    tracer->finalize_clause (clause_id, clause);
+  }
+  clause.clear ();
+  clause_id = 0;
+}
+
+void Proof::add_assumption_clause () {
+  LOG (clause, "PROOF adding assumption clause");
+  for (auto &tracer : tracers) {
+    tracer->add_assumption_clause (clause_id, clause, proof_chain);
+  }
+  proof_chain.clear ();
+  clause.clear ();
+  clause_id = 0;
+}
+
+void Proof::add_assumption () {
+  LOG (clause, "PROOF adding assumption");
+  CADICAL_assert (clause.size () == 1);
+  for (auto &tracer : tracers) {
+    tracer->add_assumption (clause.back ());
+  }
+  clause.clear ();
+}
+
+void Proof::add_constraint () {
+  LOG (clause, "PROOF adding constraint");
+  for (auto &tracer : tracers) {
+    tracer->add_constraint (clause);
+  }
+  clause.clear ();
+}
+
+void Proof::reset_assumptions () {
+  LOG ("PROOF reset assumptions");
+  for (auto &tracer : tracers) {
+    tracer->reset_assumptions ();
+  }
+}
+
+void Proof::report_status (int status, int64_t id) {
+  LOG ("PROOF reporting status %d", status);
+  for (auto &tracer : tracers) {
+    tracer->report_status (status, id);
+  }
+}
+
+void Proof::begin_proof (int64_t id) {
+  LOG (clause, "PROOF begin proof");
+  for (auto &tracer : tracers) {
+    tracer->begin_proof (id);
+  }
+}
+
+void Proof::solve_query () {
+  LOG (clause, "PROOF solve query");
+  for (auto &tracer : tracers) {
+    tracer->solve_query ();
+  }
+}
+
+void Proof::conclude_unsat (ConclusionType con,
+                            const vector<int64_t> &conclusion) {
+  LOG (clause, "PROOF conclude unsat");
+  for (auto &tracer : tracers) {
+    tracer->conclude_unsat (con, conclusion);
+  }
+}
+
+void Proof::conclude_sat (const vector<int> &model) {
+  LOG (clause, "PROOF conclude sat");
+  for (auto &tracer : tracers) {
+    tracer->conclude_sat (model);
+  }
+}
+
+void Proof::conclude_unknown (const vector<int> &trail) {
+  LOG (clause, "PROOF conclude unknown");
+  for (auto &tracer : tracers) {
+    tracer->conclude_unknown (trail);
+  }
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_propagate.cpp b/src/sat/cadical/cadical_propagate.cpp
new file mode 100644
index 000000000..a4f21ee6a
--- /dev/null
+++ b/src/sat/cadical/cadical_propagate.cpp
@@ -0,0 +1,586 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// We are using the address of 'decision_reason' as pseudo reason for
+// decisions to distinguish assignment decisions from other assignments.
+// Before we added chronological backtracking all learned units were
+// assigned at decision level zero ('Solver.level == 0') and we just used a
+// zero pointer as reason.  After allowing chronological backtracking units
+// were also assigned at higher decision level (but with assignment level
+// zero), and it was not possible anymore to just distinguish the case
+// 'unit' versus 'decision' by just looking at the current level.  Both had
+// a zero pointer as reason.  Now only units have a zero reason and
+// decisions need to use the pseudo reason 'decision_reason'.
+
+// External propagation steps use the pseudo reason 'external_reason'.
+// The corresponding actual reason clauses are learned only when they are
+// relevant in conflict analysis or in root-level fixing steps.
+
+static Clause decision_reason_clause;
+static Clause *decision_reason = &decision_reason_clause;
+
+// If chronological backtracking is used the actual assignment level might
+// be lower than the current decision level. In this case the assignment
+// level is defined as the maximum level of the literals in the reason
+// clause except the literal for which the clause is a reason.  This
+// function determines this assignment level. For non-chronological
+// backtracking as in classical CDCL this function always returns the
+// current decision level, the concept of assignment level does not make
+// sense, and accordingly this function can be skipped.
+
+// In case of external propagation, it is implicitly assumed that the
+// assignment level is the level of the literal (since the reason clause,
+// i.e., the set of other literals, is unknown).
+
+inline int Internal::assignment_level (int lit, Clause *reason) {
+
+  CADICAL_assert (opts.chrono || external_prop);
+  if (!reason || reason == external_reason)
+    return level;
+
+  int res = 0;
+
+  for (const auto &other : *reason) {
+    if (other == lit)
+      continue;
+    CADICAL_assert (val (other));
+    int tmp = var (other).level;
+    if (tmp > res)
+      res = tmp;
+  }
+
+  return res;
+}
+
+// calculate lrat_chain
+//
+void Internal::build_chain_for_units (int lit, Clause *reason,
+                                      bool forced) {
+  if (!lrat)
+    return;
+  if (opts.chrono && assignment_level (lit, reason) && !forced)
+    return;
+  else if (!opts.chrono && level && !forced)
+    return; // not decision level 0
+  CADICAL_assert (lrat_chain.empty ());
+  for (auto &reason_lit : *reason) {
+    if (lit == reason_lit)
+      continue;
+    CADICAL_assert (val (reason_lit));
+    if (!val (reason_lit))
+      continue;
+    const int signed_reason_lit = val (reason_lit) * reason_lit;
+    int64_t id = unit_id (signed_reason_lit);
+    lrat_chain.push_back (id);
+  }
+  lrat_chain.push_back (reason->id);
+}
+
+// same code as above but reason is assumed to be conflict and lit is not
+// needed
+//
+void Internal::build_chain_for_empty () {
+  if (!lrat || !lrat_chain.empty ())
+    return;
+  CADICAL_assert (!level);
+  CADICAL_assert (lrat_chain.empty ());
+  CADICAL_assert (conflict);
+  LOG (conflict, "lrat for global empty clause with conflict");
+  for (auto &lit : *conflict) {
+    CADICAL_assert (val (lit) < 0);
+    int64_t id = unit_id (-lit);
+    lrat_chain.push_back (id);
+  }
+  lrat_chain.push_back (conflict->id);
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void Internal::search_assign (int lit, Clause *reason) {
+
+  if (level)
+    require_mode (SEARCH);
+
+  const int idx = vidx (lit);
+  const bool from_external = reason == external_reason;
+  CADICAL_assert (!val (idx));
+  CADICAL_assert (!flags (idx).eliminated () || reason == decision_reason ||
+          reason == external_reason);
+  Var &v = var (idx);
+  int lit_level;
+  CADICAL_assert (!lrat || level || reason == external_reason ||
+          reason == decision_reason || !lrat_chain.empty ());
+  // The following cases are explained in the two comments above before
+  // 'decision_reason' and 'assignment_level'.
+  //
+  // External decision reason means that the propagation was done by
+  // an external propagation and the reason clause not known (yet).
+  // In that case it is assumed that the propagation is NOT out of
+  // order (i.e. lit_level = level), because due to lazy explanation,
+  // we can not calculate the real assignment level.
+  // The function assignment_level () will also assign the current level
+  // to literals with external reason.
+  if (!reason)
+    lit_level = 0; // unit
+  else if (reason == decision_reason)
+    lit_level = level, reason = 0;
+  else if (opts.chrono)
+    lit_level = assignment_level (lit, reason);
+  else
+    lit_level = level;
+  if (!lit_level)
+    reason = 0;
+
+  v.level = lit_level;
+  v.trail = trail.size ();
+  v.reason = reason;
+  CADICAL_assert ((int) num_assigned < max_var);
+  CADICAL_assert (num_assigned == trail.size ());
+  num_assigned++;
+  if (!lit_level && !from_external)
+    learn_unit_clause (lit); // increases 'stats.fixed'
+  CADICAL_assert (lit_level || !from_external);
+  const signed char tmp = sign (lit);
+  set_val (idx, tmp);
+  CADICAL_assert (val (lit) > 0);  // Just a bit paranoid but useful.
+  CADICAL_assert (val (-lit) < 0); // Ditto.
+  if (!searching_lucky_phases)
+    phases.saved[idx] = tmp; // phase saving during search
+  trail.push_back (lit);
+#ifdef LOGGING
+  if (!lit_level)
+    LOG ("root-level unit assign %d @ 0", lit);
+  else
+    LOG (reason, "search assign %d @ %d", lit, lit_level);
+#endif
+
+  if (watching ()) {
+    const Watches &ws = watches (-lit);
+    if (!ws.empty ()) {
+      const Watch &w = ws[0];
+#ifndef WIN32
+      __builtin_prefetch (&w, 0, 1);
+#endif
+    }
+  }
+  lrat_chain.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// External versions of 'search_assign' which are not inlined.  They either
+// are used to assign unit clauses on the root-level, in 'decide' to assign
+// a decision or in 'analyze' to assign the literal 'driven' by a learned
+// clause.  This happens far less frequently than the 'search_assign' above,
+// which is called directly in 'propagate' below and thus is inlined.
+
+void Internal::assign_unit (int lit) {
+  CADICAL_assert (!level);
+  search_assign (lit, 0);
+}
+
+// Just assume the given literal as decision (increase decision level and
+// assign it).  This is used below in 'decide'.
+
+void Internal::search_assume_decision (int lit) {
+  require_mode (SEARCH);
+  CADICAL_assert (propagated == trail.size ());
+  new_trail_level (lit);
+  notify_decision ();
+  LOG ("search decide %d", lit);
+  search_assign (lit, decision_reason);
+}
+
+void Internal::search_assign_driving (int lit, Clause *c) {
+  require_mode (SEARCH);
+  search_assign (lit, c);
+  notify_assignments ();
+}
+
+void Internal::search_assign_external (int lit) {
+  require_mode (SEARCH);
+  search_assign (lit, external_reason);
+  notify_assignments ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// The 'propagate' function is usually the hot-spot of a CDCL SAT solver.
+// The 'trail' stack saves assigned variables and is used here as BFS queue
+// for checking clauses with the negation of assigned variables for being in
+// conflict or whether they produce additional assignments.
+
+// This version of 'propagate' uses lazy watches and keeps two watched
+// literals at the beginning of the clause.  We also use 'blocking literals'
+// to reduce the number of times clauses have to be visited (2008 JSAT paper
+// by Chu, Harwood and Stuckey).  The watches know if a watched clause is
+// binary, in which case it never has to be visited.  If a binary clause is
+// falsified we continue propagating.
+
+// Finally, for long clauses we save the position of the last watch
+// replacement in 'pos', which in turn reduces certain quadratic accumulated
+// propagation costs (2013 JAIR article by Ian Gent) at the expense of four
+// more bytes for each clause.
+
+bool Internal::propagate () {
+
+  if (level)
+    require_mode (SEARCH);
+  CADICAL_assert (!unsat);
+  LOG ("starting propagate");
+  START (propagate);
+
+  // Updating statistics counter in the propagation loops is costly so we
+  // delay until propagation ran to completion.
+  //
+  int64_t before = propagated;
+  int64_t ticks = 0;
+
+  while (!conflict && propagated != trail.size ()) {
+
+    const int lit = -trail[propagated++];
+    LOG ("propagating %d", -lit);
+    Watches &ws = watches (lit);
+
+    const const_watch_iterator eow = ws.end ();
+    watch_iterator j = ws.begin ();
+    const_watch_iterator i = j;
+    ticks += 1 + cache_lines (ws.size (), sizeof *i);
+
+    while (i != eow) {
+
+      const Watch w = *j++ = *i++;
+      const signed char b = val (w.blit);
+      LOG (w.clause, "checking");
+
+      if (b > 0)
+        continue; // blocking literal satisfied
+
+      if (w.binary ()) {
+
+        // CADICAL_assert (w.clause->redundant || !w.clause->garbage);
+
+        // In principle we can ignore garbage binary clauses too, but that
+        // would require to dereference the clause pointer all the time with
+        //
+        // if (w.clause->garbage) { j--; continue; } // (*)
+        //
+        // This is too costly.  It is however necessary to produce correct
+        // proof traces if binary clauses are traced to be deleted ('d ...'
+        // line) immediately as soon they are marked as garbage.  Actually
+        // finding instances where this happens is pretty difficult (six
+        // parallel fuzzing jobs in parallel took an hour), but it does
+        // occur.  Our strategy to avoid generating incorrect proofs now is
+        // to delay tracing the deletion of binary clauses marked as garbage
+        // until they are really deleted from memory.  For large clauses
+        // this is not necessary since we have to access the clause anyhow.
+        //
+        // Thanks go to Mathias Fleury, who wanted me to explain why the
+        // line '(*)' above was in the code. Removing it actually really
+        // improved running times and thus I tried to find concrete
+        // instances where this happens (which I found), and then
+        // implemented the described fix.
+
+        // Binary clauses are treated separately since they do not require
+        // to access the clause at all (only during conflict analysis, and
+        // there also only to simplify the code).
+
+        if (b < 0)
+          conflict = w.clause; // but continue ...
+        else {
+          build_chain_for_units (w.blit, w.clause, 0);
+          search_assign (w.blit, w.clause);
+          // lrat_chain.clear (); done in search_assign
+          ticks++;
+        }
+
+      } else {
+        CADICAL_assert (w.clause->size > 2);
+
+        if (conflict)
+          break; // Stop if there was a binary conflict already.
+
+        // The cache line with the clause data is forced to be loaded here
+        // and thus this first memory access below is the real hot-spot of
+        // the solver.  Note, that this check is positive very rarely and
+        // thus branch prediction should be almost perfect here.
+
+        ticks++;
+
+        if (w.clause->garbage) {
+          j--;
+          continue;
+        }
+
+        literal_iterator lits = w.clause->begin ();
+
+        // Simplify code by forcing 'lit' to be the second literal in the
+        // clause.  This goes back to MiniSAT.  We use a branch-less version
+        // for conditionally swapping the first two literals, since it
+        // turned out to be substantially faster than this one
+        //
+        //  if (lits[0] == lit) swap (lits[0], lits[1]);
+        //
+        // which achieves the same effect, but needs a branch.
+        //
+        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
+        else {
+
+          // This follows Ian Gent's (JAIR'13) idea of saving the position
+          // of the last watch replacement.  In essence it needs two copies
+          // of the default search for a watch replacement (in essence the
+          // code in the 'if (v < 0) { ... }' block below), one starting at
+          // the saved position until the end of the clause and then if that
+          // one failed to find a replacement another one starting at the
+          // first non-watched literal until the saved position.
+
+          const int size = w.clause->size;
+          const literal_iterator middle = lits + w.clause->pos;
+          const const_literal_iterator end = lits + size;
+          literal_iterator k = middle;
+
+          // Find replacement watch 'r' at position 'k' with value 'v'.
+
+          int r = 0;
+          signed char v = -1;
+
+          while (k != end && (v = val (r = *k)) < 0)
+            k++;
+
+          if (v < 0) { // need second search starting at the head?
+
+            k = lits + 2;
+            CADICAL_assert (w.clause->pos <= size);
+            while (k != middle && (v = val (r = *k)) < 0)
+              k++;
+          }
+
+          w.clause->pos = k - lits; // always save position
+
+          CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
+
+          if (v > 0) {
+
+            // Replacement satisfied, so just replace 'blit'.
+
+            j[-1].blit = r;
+
+          } else if (!v) {
+
+            // Found new unassigned replacement literal to be watched.
+
+            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'.
+
+            ticks++;
+
+          } else if (!u) {
+
+            CADICAL_assert (v < 0);
+
+            // The other watch is unassigned ('!u') and all other literals
+            // assigned to false (still 'v < 0'), thus we found a unit.
+            //
+            build_chain_for_units (other, w.clause, 0);
+            search_assign (other, w.clause);
+            // lrat_chain.clear (); done in search_assign
+            ticks++;
+
+            // Similar code is in the implementation of the SAT'18 paper on
+            // chronological backtracking but in our experience, this code
+            // first does not really seem to be necessary for correctness,
+            // and further does not improve running time either.
+            //
+            if (opts.chrono > 1) {
+
+              const int other_level = var (other).level;
+
+              if (other_level > var (lit).level) {
+
+                // The assignment level of the new unit 'other' is larger
+                // than the assignment level of 'lit'.  Thus we should find
+                // another literal in the clause at that higher assignment
+                // level and watch that instead of 'lit'.
+
+                CADICAL_assert (size > 2);
+
+                int pos, s = 0;
+
+                for (pos = 2; pos < size; pos++)
+                  if (var (s = lits[pos]).level == other_level)
+                    break;
+
+                CADICAL_assert (s);
+                CADICAL_assert (pos < size);
+
+                LOG (w.clause, "unwatch %d in", lit);
+                lits[pos] = lit;
+                lits[0] = other;
+                lits[1] = s;
+                watch_literal (s, lit, w.clause);
+
+                j--; // Drop this watch from the watch list of 'lit'.
+              }
+            }
+          } else {
+
+            CADICAL_assert (u < 0);
+            CADICAL_assert (v < 0);
+
+            // The other watch is assigned false ('u < 0') and all other
+            // literals as well (still 'v < 0'), thus we found a conflict.
+
+            conflict = w.clause;
+            break;
+          }
+        }
+      }
+    }
+
+    if (j != i) {
+
+      while (i != eow)
+        *j++ = *i++;
+
+      ws.resize (j - ws.begin ());
+    }
+  }
+
+  if (searching_lucky_phases) {
+
+    if (conflict)
+      LOG (conflict, "ignoring lucky conflict");
+
+  } else {
+
+    // Avoid updating stats eagerly in the hot-spot of the solver.
+    //
+    stats.propagations.search += propagated - before;
+    stats.ticks.search[stable] += ticks;
+
+    if (!conflict)
+      no_conflict_until = propagated;
+    else {
+
+      if (stable)
+        stats.stabconflicts++;
+      stats.conflicts++;
+
+      LOG (conflict, "conflict");
+
+      // The trail before the current decision level was conflict free.
+      //
+      no_conflict_until = control[level].trail;
+    }
+  }
+
+  STOP (propagate);
+
+  return !conflict;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::propergate () {
+
+  CADICAL_assert (!conflict);
+  CADICAL_assert (propagated == trail.size ());
+
+  while (propergated != trail.size ()) {
+
+    const int lit = -trail[propergated++];
+    LOG ("propergating %d", -lit);
+    Watches &ws = watches (lit);
+
+    const const_watch_iterator eow = ws.end ();
+    watch_iterator j = ws.begin ();
+    const_watch_iterator i = j;
+
+    while (i != eow) {
+
+      const Watch w = *j++ = *i++;
+
+      if (w.binary ()) {
+        CADICAL_assert (val (w.blit) > 0);
+        continue;
+      }
+      if (w.clause->garbage) {
+        j--;
+        continue;
+      }
+
+      literal_iterator lits = w.clause->begin ();
+
+      const int other = lits[0] ^ lits[1] ^ lit;
+      const signed char u = val (other);
+
+      // TODO: check if u == 0 can happen.
+      if (u > 0)
+        continue;
+      CADICAL_assert (u < 0);
+
+      const int size = w.clause->size;
+      const literal_iterator middle = lits + w.clause->pos;
+      const const_literal_iterator end = lits + size;
+      literal_iterator k = middle;
+
+      int r = 0;
+      signed char v = -1;
+
+      while (k != end && (v = val (r = *k)) < 0)
+        k++;
+
+      if (v < 0) {
+        k = lits + 2;
+        CADICAL_assert (w.clause->pos <= size);
+        while (k != middle && (v = val (r = *k)) < 0)
+          k++;
+      }
+
+      CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
+      w.clause->pos = k - lits;
+
+      CADICAL_assert (v > 0);
+
+      LOG (w.clause, "unwatch %d in", lit);
+
+      lits[0] = other;
+      lits[1] = r;
+      *k = lit;
+
+      watch_literal (r, lit, w.clause);
+
+      j--;
+    }
+
+    if (j != i) {
+
+      while (i != eow)
+        *j++ = *i++;
+
+      ws.resize (j - ws.begin ());
+    }
+  }
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_queue.cpp b/src/sat/cadical/cadical_queue.cpp
new file mode 100644
index 000000000..c8b5b8030
--- /dev/null
+++ b/src/sat/cadical/cadical_queue.cpp
@@ -0,0 +1,96 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// Slightly different than 'bump_variable' since the variable is not
+// enqueued at all.
+
+inline void Internal::init_enqueue (int idx) {
+  Link &l = links[idx];
+  if (opts.reverse) {
+    l.prev = 0;
+    if (queue.first) {
+      CADICAL_assert (!links[queue.first].prev);
+      links[queue.first].prev = idx;
+      btab[idx] = btab[queue.first] - 1;
+    } else {
+      CADICAL_assert (!queue.last);
+      queue.last = idx;
+      btab[idx] = 0;
+    }
+    CADICAL_assert (btab[idx] <= stats.bumped);
+    l.next = queue.first;
+    queue.first = idx;
+    if (!queue.unassigned)
+      update_queue_unassigned (queue.last);
+  } else {
+    l.next = 0;
+    if (queue.last) {
+      CADICAL_assert (!links[queue.last].next);
+      links[queue.last].next = idx;
+    } else {
+      CADICAL_assert (!queue.first);
+      queue.first = idx;
+    }
+    btab[idx] = ++stats.bumped;
+    l.prev = queue.last;
+    queue.last = idx;
+    update_queue_unassigned (queue.last);
+  }
+}
+
+// Initialize VMTF queue from current 'old_max_var + 1' to 'new_max_var'.
+// This incorporates an initial variable order.  We currently simply assume
+// that variables with smaller index are more important.  This is the same
+// as in MiniSAT (implicitly) and also matches the 'scores' initialization.
+//
+void Internal::init_queue (int old_max_var, int new_max_var) {
+  LOG ("initializing VMTF queue from %d to %d", old_max_var + 1,
+       new_max_var);
+  CADICAL_assert (old_max_var < new_max_var);
+  // New variables can be created that can invoke enlarge anytime (eg via
+  // calls during ipasir-up call-backs), thus assuming (!level) is not
+  // correct
+  for (int idx = old_max_var; idx < new_max_var; idx++)
+    init_enqueue (idx + 1);
+}
+
+// Shuffle the VMTF queue.
+
+void Internal::shuffle_queue () {
+  if (!opts.shuffle)
+    return;
+  if (!opts.shufflequeue)
+    return;
+  stats.shuffled++;
+  LOG ("shuffling queue");
+  vector<int> shuffle;
+  if (opts.shufflerandom) {
+    for (int idx = max_var; idx; idx--)
+      shuffle.push_back (idx);
+    Random random (opts.seed); // global seed
+    random += stats.shuffled;  // different every time
+    for (int i = 0; i <= max_var - 2; i++) {
+      const int j = random.pick_int (i, max_var - 1);
+      swap (shuffle[i], shuffle[j]);
+    }
+  } else {
+    for (int idx = queue.last; idx; idx = links[idx].prev)
+      shuffle.push_back (idx);
+  }
+  queue.first = queue.last = 0;
+  for (const int idx : shuffle)
+    queue.enqueue (links, idx);
+  int64_t bumped = queue.bumped;
+  for (int idx = queue.last; idx; idx = links[idx].prev)
+    btab[idx] = bumped--;
+  queue.unassigned = queue.last;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_random.cpp b/src/sat/cadical/cadical_random.cpp
new file mode 100644
index 000000000..85d022e8f
--- /dev/null
+++ b/src/sat/cadical/cadical_random.cpp
@@ -0,0 +1,233 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// Our random number generator is seeded by default (i.e., in the default
+// constructor) with random seeds, which should be unique across machines,
+// processes and time.  This makes this code below rather operating system
+// dependent.  We also use in essence defensive programming, overlaying
+// several methods to get randomness since in the past we were bitten a
+// couple of times (and got the same seeds).  Having several methods makes
+// it also simpler to port randomly initializing seeds to different
+// operating systems (even though currently it is only tested on Linux).
+// This functionality is only used in the 'Mobical' model based tester at
+// this point, since the main solver explicitly sets a random seed ('0' by
+// default in 'options.hpp') and also currently only uses this seed in the
+// local search procedure explicitly without using the default constructor.
+// It is crucial for 'Mobical' to make sure that concurrent runs are really
+// independent.
+
+/*------------------------------------------------------------------------*/
+
+// Uncomment the following definition to force printing the computed hash
+// values for individual machine and process properties. This is only needed
+// for testing, porting and debugging different ports of this seeding and
+// hashing functions (uncomment and run 'mobical' for instance).
+
+/*
+#define DO_PRINT_HASH
+*/
+
+#ifdef DO_PRINT_HASH
+#define PRINT_HASH(H) \
+  do { \
+    printf ("c PRINT_HASH %32s () = %020" PRIu64 "\n", __func__, H); \
+    fflush (stdout); \
+  } while (0)
+#else
+#define PRINT_HASH(...) \
+  do { \
+  } while (0)
+#endif
+
+/*------------------------------------------------------------------------*/
+
+// This is Linux specific but if '/var/lib/dbus/machine-id' does not exist
+// does not have any effect.  TODO: add a similar machine identity hashing
+// function for other operating systems (Windows and macOS).
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+static uint64_t hash_machine_identifier () {
+  FILE *file = fopen ("/var/lib/dbus/machine-id", "r");
+  uint64_t res = 0;
+  if (file) {
+    char buffer[128];
+    memset (buffer, 0, sizeof buffer);
+    size_t bytes = fread (buffer, 1, sizeof buffer - 1, file);
+    CADICAL_assert (bytes);
+    fclose (file);
+    if (bytes && bytes < sizeof buffer) {
+      buffer[bytes] = 0;
+      res = hash_string (buffer);
+    }
+  }
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+/*------------------------------------------------------------------------*/
+
+// On our Linux cluster where we used an NFS mounted root disk the
+// 'machine-id' above (even on a locally mounted '/var' disk on each node)
+// was copied from '/etc/machine-id' which was shared among all nodes
+// (before figuring this out and fixing it). Thus the main idea of getting
+// different hash values through this machine identifier machines did not
+// work.  As an additional measure to increase the possibility to get
+// different seeds we are now also using network addresses (explicitly).
+
+#ifndef WIN32
+
+extern "C" {
+#include <ifaddrs.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+}
+
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+static uint64_t hash_network_addresses () {
+  uint64_t res = 0;
+
+  // We still need to properly port this to Windows, but since accessing the
+  // IP address is only required for better randomization during testing
+  // (running 'mobical' on a cluster for instance) it is not crucial unless
+  // you really need to run 'mobical' on a Windows cluster where each node
+  // has identical IP addresses.
+
+#ifndef WIN32
+  struct ifaddrs *addrs;
+  if (!getifaddrs (&addrs)) {
+    for (struct ifaddrs *addr = addrs; addr; addr = addr->ifa_next) {
+      if (!addr->ifa_addr)
+        continue;
+      const int family = addr->ifa_addr->sa_family;
+      if (family == AF_INET || family == AF_INET6) {
+        const int size = (family == AF_INET) ? sizeof (struct sockaddr_in)
+                                             : sizeof (struct sockaddr_in6);
+        char buffer[128];
+        if (!getnameinfo (addr->ifa_addr, size, buffer, sizeof buffer, 0, 0,
+                          NI_NUMERICHOST)) {
+          uint64_t tmp = hash_string (buffer);
+#ifdef DO_PRINT_HASH
+          printf ("c PRINT_HASH %35s = %020" PRIu64 "\n", buffer, tmp);
+          fflush (stdout);
+#endif
+          res ^= tmp;
+          res *= 10000000000000000051ul;
+        }
+      }
+    }
+    freeifaddrs (addrs);
+  }
+#endif
+
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+/*------------------------------------------------------------------------*/
+
+// Hash the current wall-clock time in seconds.
+
+extern "C" {
+#include <time.h>
+}
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+static uint64_t hash_time () {
+  uint64_t res = ::time (0);
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+/*------------------------------------------------------------------------*/
+
+// Hash the process identified.
+
+extern "C" {
+#include <sys/types.h>
+#ifdef WIN32
+#include <process.h>
+#else
+#include <unistd.h>
+#endif
+}
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+static uint64_t hash_process () {
+  uint64_t res = getpid ();
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+/*------------------------------------------------------------------------*/
+
+// Hash the current number of clock cycles.
+
+#include <ctime>
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+static uint64_t hash_clock_cycles () {
+  uint64_t res = std::clock ();
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+Random::Random () : state (1) {
+  add (hash_machine_identifier ());
+  add (hash_network_addresses ());
+  add (hash_clock_cycles ());
+  add (hash_process ());
+  add (hash_time ());
+#ifdef DO_PRINT_HASH
+  printf ("c PRINT_HASH %32s    = %020" PRIu64 "\n", "combined", state);
+  fflush (stdout);
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_reap.cpp b/src/sat/cadical/cadical_reap.cpp
new file mode 100644
index 000000000..4625c44db
--- /dev/null
+++ b/src/sat/cadical/cadical_reap.cpp
@@ -0,0 +1,142 @@
+#include "global.h"
+
+#include "reap.hpp"
+#include <cassert>
+#include <climits>
+#include <cstring>
+
+#ifdef _MSC_VER
+#include <intrin.h>
+static inline int __builtin_clz(unsigned x) {
+  unsigned long r;
+  _BitScanReverse(&r, x);
+  return (int)(r ^ 31);
+}
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+void Reap::init () {
+  for (auto &bucket : buckets)
+    bucket = {0};
+  CADICAL_assert (!num_elements);
+  CADICAL_assert (!last_deleted);
+  min_bucket = 32;
+  CADICAL_assert (!max_bucket);
+}
+
+void Reap::release () {
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}
+
+Reap::Reap () {
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}
+
+static inline unsigned leading_zeroes_of_unsigned (unsigned x) {
+  return x ? __builtin_clz (x) : sizeof (unsigned) * 8;
+}
+
+void Reap::push (unsigned e) {
+  CADICAL_assert (last_deleted <= e);
+  const unsigned diff = e ^ last_deleted;
+  const unsigned bucket = 32 - leading_zeroes_of_unsigned (diff);
+  buckets[bucket].push_back (e);
+  if (min_bucket > bucket)
+    min_bucket = bucket;
+  if (max_bucket < bucket)
+    max_bucket = bucket;
+  CADICAL_assert (num_elements != UINT_MAX);
+  num_elements++;
+}
+
+unsigned Reap::pop () {
+  CADICAL_assert (num_elements > 0);
+  unsigned i = min_bucket;
+  for (;;) {
+    CADICAL_assert (i < 33);
+    CADICAL_assert (i <= max_bucket);
+    std::vector<unsigned> &s = buckets[i];
+    if (s.empty ()) {
+      min_bucket = ++i;
+      continue;
+    }
+    unsigned res;
+    if (i) {
+      res = UINT_MAX;
+      const auto begin = std::begin (s);
+      const auto end = std::end (s);
+      auto q = std::begin (s);
+      CADICAL_assert (begin < end);
+      for (auto p = begin; p != end; ++p) {
+        const unsigned tmp = *p;
+        if (tmp >= res)
+          continue;
+        res = tmp;
+        q = p;
+      }
+
+      for (auto p = begin; p != end; ++p) {
+        if (p == q)
+          continue;
+        const unsigned other = *p;
+        const unsigned diff = other ^ res;
+        CADICAL_assert (sizeof (unsigned) == 4);
+        const unsigned j = 32 - leading_zeroes_of_unsigned (diff);
+        CADICAL_assert (j < i);
+        buckets[j].push_back (other);
+        if (min_bucket > j)
+          min_bucket = j;
+      }
+
+      s.clear ();
+
+      if (i && max_bucket == i) {
+#ifndef CADICAL_NDEBUG
+        for (unsigned j = i + 1; j < 33; j++)
+          CADICAL_assert (buckets[j].empty ());
+#endif
+        if (s.empty ())
+          max_bucket = i - 1;
+      }
+    } else {
+      res = last_deleted;
+      CADICAL_assert (!buckets[0].empty ());
+      CADICAL_assert (buckets[0].at (0) == res);
+      buckets[0].pop_back ();
+    }
+
+    if (min_bucket == i) {
+#ifndef CADICAL_NDEBUG
+      for (unsigned j = 0; j < i; j++)
+        CADICAL_assert (buckets[j].empty ());
+#endif
+      if (s.empty ())
+        min_bucket = std::min ((int) (i + 1), 32);
+    }
+
+    --num_elements;
+    CADICAL_assert (last_deleted <= res);
+    last_deleted = res;
+
+    return res;
+  }
+}
+
+void Reap::clear () {
+  CADICAL_assert (max_bucket <= 32);
+  for (unsigned i = 0; i < 33; i++)
+    buckets[i].clear ();
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_reduce.cpp b/src/sat/cadical/cadical_reduce.cpp
new file mode 100644
index 000000000..cc6f35228
--- /dev/null
+++ b/src/sat/cadical/cadical_reduce.cpp
@@ -0,0 +1,284 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Once in a while we reduce, e.g., we remove learned clauses which are
+// supposed to be less useful in the future.  This is done in increasing
+// intervals, which has the effect of allowing more and more learned clause
+// to be kept for a longer period.  The number of learned clauses kept
+// in memory corresponds to an upper bound on the 'space' of a resolution
+// proof needed to refute a formula in proof complexity sense.
+
+bool Internal::reducing () {
+  if (!opts.reduce)
+    return false;
+  if (!stats.current.redundant)
+    return false;
+  return stats.conflicts >= lim.reduce;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Even less regularly we are flushing all redundant clauses.
+
+bool Internal::flushing () {
+  if (!opts.flush)
+    return false;
+  return stats.conflicts >= lim.flush;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::mark_clauses_to_be_flushed () {
+  const int tier1limit = tier1[false];
+  const int tier2limit = max (tier1limit, tier2[false]);
+  for (const auto &c : clauses) {
+    if (!c->redundant)
+      continue; // keep irredundant
+    if (c->garbage)
+      continue; // already marked as garbage
+    if (c->reason)
+      continue; // need to keep reasons
+    const unsigned used = c->used;
+    if (used)
+      c->used--;
+    if (c->glue < tier1limit && used)
+      continue;
+    if (c->glue < tier2limit && used >= max_used - 1)
+      continue;
+    mark_garbage (c); // flush unused clauses
+    if (c->hyper)
+      stats.flush.hyper++;
+    else
+      stats.flush.learned++;
+  }
+  // No change to 'lim.kept{size,glue}'.
+}
+
+/*------------------------------------------------------------------------*/
+
+// Clauses of larger glue or larger size are considered less useful.
+//
+// We also follow the observations made by the Glucose team in their
+// IJCAI'09 paper and keep all low glue clauses limited by
+// 'options.keepglue' (typically '2').
+//
+// In earlier versions we pre-computed a 64-bit sort key per clause and
+// wrapped a pointer to the clause and the 64-bit sort key into a separate
+// data structure for sorting.  This was probably faster but awkward and
+// so we moved back to a simpler scheme which also uses 'stable_sort'
+// instead of 'rsort' below.  Sorting here is not a hot-spot anyhow.
+
+struct reduce_less_useful {
+  bool operator() (const Clause *c, const Clause *d) const {
+    if (c->glue > d->glue)
+      return true;
+    if (c->glue < d->glue)
+      return false;
+    return c->size > d->size;
+  }
+};
+
+// This function implements the important reduction policy. It determines
+// which redundant clauses are considered not useful and thus will be
+// collected in a subsequent garbage collection phase.
+
+void Internal::mark_useless_redundant_clauses_as_garbage () {
+
+  // We use a separate stack for sorting candidates for removal.  This uses
+  // (slightly) more memory but has the advantage to keep the relative order
+  // in 'clauses' intact, which actually due to using stable sorting goes
+  // into the candidate selection (more recently learned clauses are kept if
+  // they otherwise have the same glue and size).
+
+  vector<Clause *> stack;
+  const int tier1limit = tier1[false];
+  const int tier2limit = max (tier1limit, tier2[false]);
+
+  stack.reserve (stats.current.redundant);
+
+  for (const auto &c : clauses) {
+    if (!c->redundant)
+      continue; // Keep irredundant.
+    if (c->garbage)
+      continue; // Skip already marked.
+    if (c->reason)
+      continue; // Need to keep reasons.
+    const unsigned used = c->used;
+    if (used)
+      c->used--;
+    if (c->glue <= tier1limit && used)
+      continue;
+    if (c->glue <= tier2limit && used >= max_used - 1)
+      continue;
+    if (c->hyper) {          // Hyper binary and ternary resolvents
+      CADICAL_assert (c->size <= 3); // are only kept for one reduce round
+      if (!used)
+        mark_garbage (c); // unless
+      continue;           //  used recently.
+    }
+    stack.push_back (c);
+  }
+
+  stable_sort (stack.begin (), stack.end (), reduce_less_useful ());
+  size_t target = 1e-2 * opts.reducetarget * stack.size ();
+
+  // This is defensive code, which I usually consider a bug, but here I am
+  // just not sure that using floating points in the line above is precise
+  // in all situations and instead of figuring that out, I just use this.
+  //
+  if (target > stack.size ())
+    target = stack.size ();
+
+  PHASE ("reduce", stats.reductions, "reducing %zd clauses %.0f%%", target,
+         percent (target, stats.current.redundant));
+
+  auto i = stack.begin ();
+  const auto t = i + target;
+  while (i != t) {
+    Clause *c = *i++;
+    LOG (c, "marking useless to be collected");
+    mark_garbage (c);
+    stats.reduced++;
+  }
+
+  lim.keptsize = lim.keptglue = 0;
+
+  const auto end = stack.end ();
+  for (i = t; i != end; i++) {
+    Clause *c = *i;
+    LOG (c, "keeping");
+    if (c->size > lim.keptsize)
+      lim.keptsize = c->size;
+    if (c->glue > lim.keptglue)
+      lim.keptglue = c->glue;
+  }
+
+  erase_vector (stack);
+
+  PHASE ("reduce", stats.reductions, "maximum kept size %d glue %d",
+         lim.keptsize, lim.keptglue);
+}
+
+/*------------------------------------------------------------------------*/
+
+// If chronological backtracking produces out-of-order assigned units, then
+// it is necessary to completely propagate them at the root level in order
+// to derive all implied units.  Otherwise the blocking literals in
+// 'flush_watches' are messed up and CADICAL_assertion 'FW1' fails.
+
+bool Internal::propagate_out_of_order_units () {
+  if (!level)
+    return true;
+  int oou = 0;
+  for (size_t i = control[1].trail; !oou && i < trail.size (); i++) {
+    const int lit = trail[i];
+    CADICAL_assert (val (lit) > 0);
+    if (var (lit).level)
+      continue;
+    LOG ("found out-of-order assigned unit %d", oou);
+    oou = lit;
+  }
+  if (!oou)
+    return true;
+  CADICAL_assert (opts.chrono || external_prop);
+  backtrack (0);
+  if (propagate ())
+    return true;
+  learn_empty_clause ();
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// reduction is scheduled with reduceint, reducetarget and reduceopt.
+// with reduceopt=1 the number of learnt clauses scale with
+// sqrt of conflicts times reduceint
+// the scaling is the same as with reduceopt=0 (the classical default)
+// however, the constants are different. To avoid this (and get roughly the
+// same behaviour with reduceopt=0 and reduceopt=1) we need to scale the
+// interval, namely (reduceint^2/2)
+// Lastly, reduceopt=2 just replaces sqrt conflicts with log conflicts.
+// The learnt clauses should not be bigger than
+// 1/reducetarget * reduceint * function (conflicts)
+// for function being log if reduceint=2 an sqrt otherwise.
+// This is however only the theoretical target and second chance for
+// tier2 clauses and very long lifespan of tier1 clauses (through used flag)
+// make this behave differently.
+// reduceinit shifts the curve to the right, increasing the number of
+// clauses in the solver. This impact will decrease over time.
+
+void Internal::reduce () {
+  START (reduce);
+
+  stats.reductions++;
+  report ('.', 1);
+
+  bool flush = flushing ();
+  if (flush)
+    stats.flush.count++;
+
+  if (!propagate_out_of_order_units ())
+    goto DONE;
+
+  mark_satisfied_clauses_as_garbage ();
+  protect_reasons ();
+  if (flush)
+    mark_clauses_to_be_flushed ();
+  else
+    mark_useless_redundant_clauses_as_garbage ();
+  garbage_collection ();
+
+  {
+    int64_t delta = opts.reduceint;
+    double factor = stats.reductions + 1;
+    if (opts.reduceopt ==
+        0) // adjust delta such this is the same as reduceopt=1
+      delta = delta * delta / 2;
+    else if (opts.reduceopt == 1) {
+      // this is the same as reduceopt=0 if reduceint = sqrt (reduceint) =
+      // 17
+      factor = sqrt ((double) stats.conflicts);
+    } else if (opts.reduceopt == 2)
+      // log scaling instead
+      factor = log ((double) stats.conflicts);
+    if (factor < 1)
+      factor = 1;
+    delta = delta * factor;
+    if (irredundant () > 1e5) {
+      delta *= log (irredundant () / 1e4) / log (10);
+    }
+    if (delta < 1)
+      delta = 1;
+    lim.reduce = stats.conflicts + delta;
+    PHASE ("reduce", stats.reductions,
+           "new reduce limit %" PRId64 " after %" PRId64 " conflicts",
+           lim.reduce, delta);
+  }
+
+  if (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);
+  }
+
+  last.reduce.conflicts = stats.conflicts;
+
+DONE:
+
+  report (flush ? 'f' : '-');
+  STOP (reduce);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_rephase.cpp b/src/sat/cadical/cadical_rephase.cpp
new file mode 100644
index 000000000..3b2e62526
--- /dev/null
+++ b/src/sat/cadical/cadical_rephase.cpp
@@ -0,0 +1,342 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// We experimented with resetting and reinitializing the saved phase with
+// many solvers. Actually RSAT had already such a scheme.  Our newest
+// version seems to be quite beneficial for satisfiable instances.  In an
+// arithmetic increasing interval in the number of conflicts we either use
+// the original phase (set by the option 'phase'), its inverted value, flip
+// the current phase, pick random phases, then pick the best since the last
+// time a best phase was picked and finally also use local search to find
+// phases which minimize the number of falsified clauses.  During
+// stabilization (see 'stabilizing' in 'restart.cpp' when 'stable' is true)
+// we execute a different rephasing schedule.  The same applies if local
+// search is disabled.
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::rephasing () {
+  if (!opts.rephase)
+    return false;
+  if (opts.forcephase)
+    return false;
+  return stats.conflicts > lim.rephase;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Pick the original default phase.
+
+char Internal::rephase_original () {
+  stats.rephased.original++;
+  signed char val = opts.phase ? 1 : -1; // original = initial
+  PHASE ("rephase", stats.rephased.total, "switching to original phase %d",
+         val);
+  for (auto idx : vars)
+    phases.saved[idx] = val;
+  return 'O';
+}
+
+// Pick the inverted original default phase.
+
+char Internal::rephase_inverted () {
+  stats.rephased.inverted++;
+  signed char val = opts.phase ? -1 : 1; // original = -initial
+  PHASE ("rephase", stats.rephased.total,
+         "switching to inverted original phase %d", val);
+  for (auto idx : vars)
+    phases.saved[idx] = val;
+  return 'I';
+}
+
+// Flip the current phase.
+
+char Internal::rephase_flipping () {
+  stats.rephased.flipped++;
+  PHASE ("rephase", stats.rephased.total,
+         "flipping all phases individually");
+  for (auto idx : vars)
+    phases.saved[idx] *= -1;
+  return 'F';
+}
+
+// Complete random picking of phases.
+
+char Internal::rephase_random () {
+  stats.rephased.random++;
+  PHASE ("rephase", stats.rephased.total, "resetting all phases randomly");
+  Random random (opts.seed);       // global seed
+  random += stats.rephased.random; // different every time
+  for (auto idx : vars)
+    phases.saved[idx] = random.generate_bool () ? -1 : 1;
+  return '#';
+}
+
+// Best phases are those saved at the largest trail height without conflict.
+// See code and comments in 'update_target_and_best' in 'backtrack.cpp'
+
+char Internal::rephase_best () {
+  stats.rephased.best++;
+  PHASE ("rephase", stats.rephased.total,
+         "overwriting saved phases by best phases");
+  signed char val;
+  for (auto idx : vars)
+    if ((val = phases.best[idx]))
+      phases.saved[idx] = val;
+  return 'B';
+}
+
+// Trigger local search 'walk' in 'walk.cpp'.
+
+char Internal::rephase_walk () {
+  stats.rephased.walk++;
+  PHASE ("rephase", stats.rephased.total,
+         "starting local search to improve current phase");
+  walk ();
+  return 'W';
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::rephase () {
+
+  stats.rephased.total++;
+  PHASE ("rephase", stats.rephased.total,
+         "reached rephase limit %" PRId64 " after %" PRId64 " conflicts",
+         lim.rephase, stats.conflicts);
+
+  // Report current 'target' and 'best' and then set 'rephased' below, which
+  // will trigger reporting the new 'target' and 'best' after updating it in
+  // the next 'update_target_and_best' called from the next 'backtrack'.
+  //
+  report ('~', 1);
+
+  backtrack ();
+  clear_phases (phases.target);
+  target_assigned = 0;
+
+  size_t count = lim.rephased[stable]++;
+  bool single;
+  char type;
+
+  if (opts.stabilize && opts.stabilizeonly)
+    single = true;
+  else
+    single = !opts.stabilize;
+
+  if (single && !opts.walk) {
+    // (inverted,best,flipping,best,random,best,original,best)^\omega
+    switch (count % 8) {
+    case 0:
+      type = rephase_inverted ();
+      break;
+    case 1:
+      type = rephase_best ();
+      break;
+    case 2:
+      type = rephase_flipping ();
+      break;
+    case 3:
+      type = rephase_best ();
+      break;
+    case 4:
+      type = rephase_random ();
+      break;
+    case 5:
+      type = rephase_best ();
+      break;
+    case 6:
+      type = rephase_original ();
+      break;
+    case 7:
+      type = rephase_best ();
+      break;
+    default:
+      type = 0;
+      break;
+    }
+  } else if (single && opts.walk) {
+    // (inverted,best,walk,
+    //  flipping,best,walk,
+    //    random,best,walk,
+    //  original,best,walk)^\omega
+    switch (count % 12) {
+    case 0:
+      type = rephase_inverted ();
+      break;
+    case 1:
+      type = rephase_best ();
+      break;
+    case 2:
+      type = rephase_walk ();
+      break;
+    case 3:
+      type = rephase_flipping ();
+      break;
+    case 4:
+      type = rephase_best ();
+      break;
+    case 5:
+      type = rephase_walk ();
+      break;
+    case 6:
+      type = rephase_random ();
+      break;
+    case 7:
+      type = rephase_best ();
+      break;
+    case 8:
+      type = rephase_walk ();
+      break;
+    case 9:
+      type = rephase_original ();
+      break;
+    case 10:
+      type = rephase_best ();
+      break;
+    case 11:
+      type = rephase_walk ();
+      break;
+    default:
+      type = 0;
+      break;
+    }
+  } else if (stable && !opts.walk) {
+    // original,inverted,(best,original,best,inverted)^\omega
+    if (!count)
+      type = rephase_original ();
+    else if (count == 1)
+      type = rephase_inverted ();
+    else
+      switch ((count - 2) % 4) {
+      case 0:
+        type = rephase_best ();
+        break;
+      case 1:
+        type = rephase_original ();
+        break;
+      case 2:
+        type = rephase_best ();
+        break;
+      case 3:
+        type = rephase_inverted ();
+        break;
+      default:
+        type = 0;
+        break;
+      }
+  } else if (stable && opts.walk) {
+    // original,inverted,(best,walk,original,best,walk,inverted)^\omega
+    if (!count)
+      type = rephase_original ();
+    else if (count == 1)
+      type = rephase_inverted ();
+    else
+      switch ((count - 2) % 6) {
+      case 0:
+        type = rephase_best ();
+        break;
+      case 1:
+        type = rephase_walk ();
+        break;
+      case 2:
+        type = rephase_original ();
+        break;
+      case 3:
+        type = rephase_best ();
+        break;
+      case 4:
+        type = rephase_walk ();
+        break;
+      case 5:
+        type = rephase_inverted ();
+        break;
+      default:
+        type = 0;
+        break;
+      }
+  } else if (!stable && (!opts.walk || !opts.walknonstable)) {
+    // flipping,(random,best,flipping,best)^\omega
+    if (!count)
+      type = rephase_flipping ();
+    else
+      switch ((count - 1) % 4) {
+      case 0:
+        type = rephase_random ();
+        break;
+      case 1:
+        type = rephase_best ();
+        break;
+      case 2:
+        type = rephase_flipping ();
+        break;
+      case 3:
+        type = rephase_best ();
+        break;
+      default:
+        type = 0;
+        break;
+      }
+  } else {
+    CADICAL_assert (!stable && opts.walk && opts.walknonstable);
+    // flipping,(random,best,walk,flipping,best,walk)^\omega
+    if (!count)
+      type = rephase_flipping ();
+    else
+      switch ((count - 1) % 6) {
+      case 0:
+        type = rephase_random ();
+        break;
+      case 1:
+        type = rephase_best ();
+        break;
+      case 2:
+        type = rephase_walk ();
+        break;
+      case 3:
+        type = rephase_flipping ();
+        break;
+      case 4:
+        type = rephase_best ();
+        break;
+      case 5:
+        type = rephase_walk ();
+        break;
+      default:
+        type = 0;
+        break;
+      }
+  }
+  CADICAL_assert (type);
+
+  int64_t delta = opts.rephaseint * (stats.rephased.total + 1);
+  lim.rephase = stats.conflicts + delta;
+
+  PHASE ("rephase", stats.rephased.total,
+         "new rephase limit %" PRId64 " after %" PRId64 " conflicts",
+         lim.rephase, delta);
+
+  // This will trigger to report the effect of this new set of phases at the
+  // 'backtrack' (actually 'update_target_and_best') after the next
+  // conflict, as well as resetting 'best_assigned' then to allow to compute
+  // a new "best" assignment at that point.
+  //
+  last.rephase.conflicts = stats.conflicts;
+  rephased = type;
+
+  if (stable)
+    shuffle_scores ();
+  else
+    shuffle_queue ();
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_report.cpp b/src/sat/cadical/cadical_report.cpp
new file mode 100644
index 000000000..18271d17e
--- /dev/null
+++ b/src/sat/cadical/cadical_report.cpp
@@ -0,0 +1,302 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+#ifndef CADICAL_QUIET
+
+/*------------------------------------------------------------------------*/
+
+// Provide nicely formatted progress report messages while running through
+// the 'report' function below.  The code is so complex, because it should
+// be easy to add and remove reporting of certain statistics, while still
+// providing a nicely looking format with automatically aligned headers.
+
+/*------------------------------------------------------------------------*\
+
+The 'reports' are shown as 'c <char> ...' with '<char>' as follows:
+
+i  propagated learned unit clause
+O  backtracked after phases reset to original phase
+F  backtracked after flipping phases
+#  backtracked after randomly setting phases
+B  backtracked after resetting to best phases
+W  backtracked after local search improved phases
+b  blocked clause elimination
+G  before garbage collection
+C  after garbage collection
+/  compacted internal literals and remapped external to internal
+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
+}  end of unstable search phase
+P  preprocessing round (capital 'P')
+L  local search round
+*  start of solving without the need to restore clauses
++  start of solving before restoring clauses
+r  start of solving after restoring clauses
+1  end of solving returns satisfiable
+0  end of solving returns unsatisfiable
+?  end of solving due to interrupt
+l  lucky phase solving
+p  failed literal probing round (lower case 'p')
+.  before reducing redundant clauses
+f  flushed redundant clauses
+-  reduced redundant clauses
+~  start of resetting phases
+R  restart
+s  subsumed clause removal round
+3  ternary resolution round
+t  transition reduction of binary implication graph
+u  vivified tier1 clauses
+v  vivified tier2 clauses
+x  vivified tier3 clauses
+w  vivified irredundant clauses
+
+The order of the list follows the occurrences of 'report' in the source
+files, i.e., obtained from "grep 'report (' *.cpp".   Note that some of the
+reports are only printed for higher verbosity level (for instance 'R').
+
+\*------------------------------------------------------------------------*/
+
+struct Report {
+
+  const char *header;
+  char buffer[32];
+  int pos;
+
+  Report (const char *h, int precision, int min, double value);
+  Report () {}
+
+  void print_header (char *line);
+};
+
+/*------------------------------------------------------------------------*/
+
+void Report::print_header (char *line) {
+  int len = strlen (header);
+  for (int i = -1, j = pos - (len + 1) / 2 - 3; i < len; i++, j++)
+    line[j] = i < 0 ? ' ' : header[i];
+}
+
+Report::Report (const char *h, int precision, int min, double value)
+    : header (h) {
+  char fmt[32];
+  if (precision < 0)
+    snprintf (fmt, sizeof fmt, "%%.%df", -precision - 1);
+  else
+    snprintf (fmt, sizeof fmt, "%%.%df", precision);
+  snprintf (buffer, sizeof buffer, fmt, value);
+  const int width = strlen (buffer);
+  if (precision < 0)
+    strcat (buffer, "%");
+  if (width >= min)
+    return;
+  if (precision < 0)
+    snprintf (fmt, sizeof fmt, "%%%d.%df%%%%", min, -precision - 1);
+  else
+    snprintf (fmt, sizeof fmt, "%%%d.%df", min, precision);
+  snprintf (buffer, sizeof buffer, fmt, value);
+}
+
+/*------------------------------------------------------------------------*/
+
+// The following statistics are printed in columns, whenever 'report' is
+// called.  For instance 'reduce' with prefix '-' will call it.  The other
+// more interesting report is due to learning a unit, called iteration, with
+// prefix 'i'.  To add another statistics column, add a corresponding line
+// here.  If you want to report something else add 'report (..)' functions.
+
+#define TIME opts.reportsolve ? solve_time () : time ()
+
+#define MB (current_resident_set_size () / (double) (1l << 20))
+
+#define REMAINING (percent (active (), stats.variables_original))
+
+#define TRAIL (percent (averages.current.trail.slow, max_var))
+
+#define TARGET (percent (target_assigned, max_var))
+
+#define BEST (percent (best_assigned, max_var))
+
+#define REPORTS \
+  /*     HEADER, PRECISION, MIN, VALUE */ \
+  REPORT ("seconds", 2, 5, TIME) \
+  REPORT ("MB", 0, 2, MB) \
+  REPORT ("level", 0, 2, averages.current.level) \
+  REPORT ("reductions", 0, 1, stats.reductions) \
+  REPORT ("restarts", 0, 3, stats.restarts) \
+  REPORT ("rate", 0, 2, averages.current.decisions) \
+  REPORT ("conflicts", 0, 4, stats.conflicts) \
+  REPORT ("redundant", 0, 4, stats.current.redundant) \
+  REPORT ("trail", -1, 2, TRAIL) \
+  REPORT ("glue", 0, 1, averages.current.glue.slow) \
+  REPORT ("irredundant", 0, 4, stats.current.irredundant) \
+  REPORT ("variables", 0, 3, active ()) \
+  REPORT ("remaining", -1, 2, REMAINING)
+
+// Note, keep an empty line before this line (because of '\')!
+
+#if 0 // ADDITIONAL STATISTICS TO REPORT
+
+REPORT("best",        -1, 2, BEST) \
+REPORT("target",      -1, 2, TARGET) \
+REPORT("maxvar",       0, 2, external->max_var)
+
+#endif
+
+static const int num_reports = // as compile time constant
+#define REPORT(HEAD, PREC, MIN, EXPR) 1 +
+    REPORTS
+#undef REPORT
+    0;
+
+/*------------------------------------------------------------------------*/
+
+void Internal::report (char type, int verbose) {
+  if (!opts.report)
+    return;
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet || (verbose > opts.verbose))
+      return;
+  if (!reported) {
+    CADICAL_assert (!lim.report);
+    reported = true;
+    MSG ("%stime measured in %s time %s%s", tout.magenta_code (),
+         internal->opts.realtime ? "real" : "process",
+         internal->opts.reportsolve ? "in solving" : "since initialization",
+         tout.normal_code ());
+  }
+  Report reports[num_reports];
+  int n = 0;
+#define REPORT(HEAD, PREC, MIN, EXPR) \
+  CADICAL_assert (n < num_reports); \
+  reports[n++] = Report (HEAD, PREC, MIN, (double) (EXPR));
+  REPORTS
+#undef REPORT
+  if (!lim.report) {
+    print_prefix ();
+    fputc ('\n', stdout);
+    int pos = 4;
+    for (int i = 0; i < n; i++) {
+      int len = strlen (reports[i].buffer);
+      reports[i].pos = pos + (len + 1) / 2;
+      pos += len + 1;
+    }
+    const int max_line = pos + 20, nrows = 3;
+    char *line = new char[max_line];
+    for (int start = 0; start < nrows; start++) {
+      int i;
+      for (i = 0; i < max_line; i++)
+        line[i] = ' ';
+      for (i = start; i < n; i += nrows)
+        reports[i].print_header (line);
+      for (i = max_line - 1; line[i - 1] == ' '; i--)
+        ;
+      line[i] = 0;
+      print_prefix ();
+      tout.yellow ();
+      fputs (line, stdout);
+      tout.normal ();
+      fputc ('\n', stdout);
+    }
+    print_prefix ();
+    fputc ('\n', stdout);
+    delete[] line;
+    lim.report = 19;
+  } else
+    lim.report--;
+  print_prefix ();
+  switch (type) {
+  case '[':
+  case ']':
+    tout.magenta (true);
+    break;
+  case 's':
+  case 'b':
+  case 'c':
+    tout.green (false);
+    break;
+  case 'e':
+    tout.green (true);
+    break;
+  case 'p':
+  case '2':
+  case '3':
+  case 'u':
+  case 'v':
+  case 'w':
+  case 'x':
+  case 'f':
+  case '=':
+    tout.blue (false);
+    break;
+  case 't':
+    tout.cyan (false);
+    break;
+  case 'd':
+    tout.blue (true);
+    break;
+  case 'z':
+  case '!':
+    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;
+  default:
+    break;
+  }
+  fputc (type, stdout);
+  if (stable || type == ']')
+    tout.magenta ();
+  else if (type != 'L' && type != 'P')
+    tout.normal ();
+  for (int i = 0; i < n; i++) {
+    fputc (' ', stdout);
+    fputs (reports[i].buffer, stdout);
+  }
+  if (stable || type == 'L' || type == 'P' || type == ']')
+    tout.normal ();
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#else // ifndef CADICAL_QUIET
+
+void Internal::report (char, int) {}
+
+#endif
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_resources.cpp b/src/sat/cadical/cadical_resources.cpp
new file mode 100644
index 000000000..9a2b421e5
--- /dev/null
+++ b/src/sat/cadical/cadical_resources.cpp
@@ -0,0 +1,166 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// This is operating system specific code.  We mostly develop on Linux and
+// there it should be fine and mostly works out-of-the-box on MacOS too but
+// Windows needs special treatment (as probably other operating systems
+// too).
+
+extern "C" {
+
+#ifdef WIN32
+
+#ifndef __WIN32_WINNT
+#define __WIN32_WINNT 0x0600
+#endif
+
+// Clang-format would reorder the includes which breaks the Windows code
+// as it expects 'windows.h' to be included first.  So disable it here.
+
+// clang-format off
+
+#include <windows.h>
+#include <psapi.h>
+
+// clang-format on
+
+#else
+
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#endif
+
+#include <string.h>
+}
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+#ifdef WIN32
+
+double absolute_real_time () {
+  FILETIME f;
+  GetSystemTimeAsFileTime (&f);
+  ULARGE_INTEGER t;
+  t.LowPart = f.dwLowDateTime;
+  t.HighPart = f.dwHighDateTime;
+  double res = (__int64) t.QuadPart;
+  res *= 1e-7;
+  return res;
+}
+
+double absolute_process_time () {
+  double res = 0;
+  FILETIME fc, fe, fu, fs;
+  if (GetProcessTimes (GetCurrentProcess (), &fc, &fe, &fu, &fs)) {
+    ULARGE_INTEGER u, s;
+    u.LowPart = fu.dwLowDateTime;
+    u.HighPart = fu.dwHighDateTime;
+    s.LowPart = fs.dwLowDateTime;
+    s.HighPart = fs.dwHighDateTime;
+    res = (__int64) u.QuadPart + (__int64) s.QuadPart;
+    res *= 1e-7;
+  }
+  return res;
+}
+
+#else
+
+double absolute_real_time () {
+  struct timeval tv;
+  if (gettimeofday (&tv, 0))
+    return 0;
+  return 1e-6 * tv.tv_usec + tv.tv_sec;
+}
+
+// We use 'getrusage' for 'process_time' and 'maximum_resident_set_size'
+// which is pretty standard on Unix but probably not available on Windows
+// etc.  For different variants of Unix not all fields are meaningful.
+
+double absolute_process_time () {
+  double res;
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  res = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;  // user time
+  res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec; // + system time
+  return res;
+}
+
+#endif
+
+double Internal::real_time () const {
+  return absolute_real_time () - stats.time.real;
+}
+
+double Internal::process_time () const {
+  return absolute_process_time () - stats.time.process;
+}
+
+/*------------------------------------------------------------------------*/
+
+#ifdef WIN32
+
+uint64_t current_resident_set_size () {
+  PROCESS_MEMORY_COUNTERS pmc;
+  if (GetProcessMemoryInfo (GetCurrentProcess (), &pmc, sizeof (pmc))) {
+    return pmc.WorkingSetSize;
+  } else
+    return 0;
+}
+
+uint64_t maximum_resident_set_size () {
+  PROCESS_MEMORY_COUNTERS pmc;
+  if (GetProcessMemoryInfo (GetCurrentProcess (), &pmc, sizeof (pmc))) {
+    return pmc.PeakWorkingSetSize;
+  } else
+    return 0;
+}
+
+#else
+
+// This seems to work on Linux (man page says since Linux 2.6.32).
+
+uint64_t maximum_resident_set_size () {
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  return ((uint64_t) u.ru_maxrss) << 10;
+}
+
+// Unfortunately 'getrusage' on Linux does not support current resident set
+// size (the field 'ru_ixrss' is there but according to the man page
+// 'unused'). Thus we fall back to use the '/proc' file system instead.  So
+// this is not portable at all and needs to be replaced on other systems
+// The code would still compile though (assuming 'sysconf' and
+// '_SC_PAGESIZE' are available).
+
+uint64_t current_resident_set_size () {
+  char path[64];
+  snprintf (path, sizeof path, "/proc/%" PRId64 "/statm",
+            (int64_t) getpid ());
+  FILE *file = fopen (path, "r");
+  if (!file)
+    return 0;
+  uint64_t dummy, rss;
+  int scanned = fscanf (file, "%" PRIu64 " %" PRIu64 "", &dummy, &rss);
+  fclose (file);
+  return scanned == 2 ? rss * sysconf (_SC_PAGESIZE) : 0;
+}
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_restart.cpp b/src/sat/cadical/cadical_restart.cpp
new file mode 100644
index 000000000..1c6dc44c8
--- /dev/null
+++ b/src/sat/cadical/cadical_restart.cpp
@@ -0,0 +1,165 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// As observed by Chanseok Oh and implemented in MapleSAT solvers too,
+// various mostly satisfiable instances benefit from long quiet phases
+// with less or almost no restarts.  We implement this idea by prohibiting
+// the Glucose style restart scheme in a geometric fashion, which is very
+// similar to how originally restarts were scheduled in MiniSAT and earlier
+// solvers.  We start with say 1e3 = 1000 (opts.stabilizeinit) conflicts of
+// Glucose restarts.  Then in a "stabilizing" phase we disable these
+// until 1e4 = 2000 conflicts (if 'opts.stabilizefactor' is '200' percent)
+// have passed. After that we switch back to regular Glucose style restarts
+// until again 2 times more conflicts than the previous limit are reached.
+// Actually, in the latest version we still restarts during stabilization
+// but only in a reluctant doubling scheme with a rather high interval.
+
+bool Internal::stabilizing () {
+  if (!opts.stabilize)
+    return false;
+  if (stable && opts.stabilizeonly)
+    return true;
+  if (!inc.stabilize) {
+    CADICAL_assert (!stable);
+    if (stats.conflicts <= lim.stabilize)
+      return false;
+  } else if (stats.ticks.search[stable] <= lim.stabilize)
+    return stable;
+  report (stable ? ']' : '}');
+  if (stable)
+    STOP (stable);
+  else
+    STOP (unstable);
+  const int64_t delta_conflicts =
+      stats.conflicts - last.stabilize.conflicts;
+  const int64_t delta_ticks =
+      stats.ticks.search[stable] - last.stabilize.ticks;
+  const char *current_mode = stable ? "stable" : "unstable";
+  const char *next_mode = stable ? "unstable" : "stable";
+  PHASE ("stabilizing", stats.stabphases,
+         "reached %s stabilization limit %" PRId64 " after %" PRId64
+         " conflicts and %" PRId64 " ticks at %" PRId64
+         " conflicts and %" PRId64 " ticks",
+         current_mode, lim.stabilize, delta_conflicts, delta_ticks,
+         stats.conflicts, stats.ticks.search[stable]);
+  if (!inc.stabilize)
+    inc.stabilize = delta_ticks;
+  if (!inc.stabilize) // rare occurence in incremental calls requiring no
+                      // ticks
+    inc.stabilize = 1;
+
+  stable = !stable; // Switch!!!!!
+
+  int64_t next_delta_ticks = inc.stabilize;
+  int64_t stabphases = stats.stabphases + 1;
+  next_delta_ticks *= stabphases * stabphases;
+
+  lim.stabilize = stats.ticks.search[stable] + next_delta_ticks;
+  if (lim.stabilize <= stats.ticks.search[stable])
+    lim.stabilize = stats.ticks.search[stable] + 1;
+
+  if (stable)
+    stats.stabphases++;
+
+  swap_averages ();
+  PHASE ("stabilizing", stats.stabphases,
+         "next %s stabilization limit %" PRId64
+         " at ticks interval %" PRId64,
+         next_mode, lim.stabilize, next_delta_ticks);
+  report (stable ? '[' : '{');
+  if (stable)
+    START (stable);
+  else
+    START (unstable);
+  return stable;
+}
+
+// Restarts are scheduled by a variant of the Glucose scheme as presented
+// in our POS'15 paper using exponential moving averages.  There is a slow
+// moving average of the average recent glucose level of learned clauses
+// as well as a fast moving average of those glues.  If the end of a base
+// restart conflict interval has passed and the fast moving average is
+// above a certain margin over the slow moving average then we restart.
+
+bool Internal::restarting () {
+  if (!opts.restart)
+    return false;
+  if ((size_t) level < assumptions.size () + 2)
+    return false;
+  if (stabilizing ())
+    return reluctant;
+  if (stats.conflicts <= lim.restart)
+    return false;
+  double f = averages.current.glue.fast;
+  double margin = (100.0 + opts.restartmargin) / 100.0;
+  double s = averages.current.glue.slow, l = margin * s;
+  LOG ("EMA glue slow %.2f fast %.2f limit %.2f", s, f, l);
+  return l <= f;
+}
+
+// This is Marijn's reuse trail idea.  Instead of always backtracking to
+// the top we figure out which decisions will be made again anyhow and
+// only backtrack to the level of the last such decision or to the top if
+// no such decision exists top (in which case we do not reuse any level).
+
+int Internal::reuse_trail () {
+  const int trivial_decisions =
+      assumptions.size ()
+      // Plus 1 if the constraint is satisfied via implications of
+      // assumptions and a pseudo-decision level was introduced.
+      + !control[assumptions.size () + 1].decision;
+  if (!opts.restartreusetrail)
+    return trivial_decisions;
+  int next_decision = next_decision_variable ();
+  CADICAL_assert (1 <= next_decision);
+  int res = trivial_decisions;
+  if (use_scores ()) {
+    while (res < level) {
+      int decision = control[res + 1].decision;
+      if (decision && score_smaller (this) (abs (decision), next_decision))
+        break;
+      res++;
+    }
+  } else {
+    int64_t limit = bumped (next_decision);
+    while (res < level) {
+      int decision = control[res + 1].decision;
+      if (decision && bumped (decision) < limit)
+        break;
+      res++;
+    }
+  }
+  int reused = res - trivial_decisions;
+  if (reused > 0) {
+    stats.reused++;
+    stats.reusedlevels += reused;
+    if (stable)
+      stats.reusedstable++;
+  }
+  return res;
+}
+
+void Internal::restart () {
+  START (restart);
+  stats.restarts++;
+  stats.restartlevels += level;
+  if (stable)
+    stats.restartstable++;
+  LOG ("restart %" PRId64 "", stats.restarts);
+  backtrack (reuse_trail ());
+
+  lim.restart = stats.conflicts + opts.restartint;
+  LOG ("new restart limit at %" PRId64 " conflicts", lim.restart);
+
+  report ('R', 2);
+  STOP (restart);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_restore.cpp b/src/sat/cadical/cadical_restore.cpp
new file mode 100644
index 000000000..f9551fb5e
--- /dev/null
+++ b/src/sat/cadical/cadical_restore.cpp
@@ -0,0 +1,273 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// In incremental solving after a first call to 'solve' has finished and
+// before calling the internal 'solve' again incrementally we have to
+// restore clauses which have the negation of a literal as a witness literal
+// on the extension stack, which was added as original literal in a new
+// clause or in an assumption.  This procedure has to be applied
+// recursively, i.e., the literals of restored clauses are treated in the
+// same way as literals of a new original clause.
+//
+// To figure out whether literals are such witnesses we have a 'witness'
+// bit for each external literal, which is set in 'block', 'elim', and
+// 'decompose' if a clause is pushed on the extension stack.  The witness
+// bits are recomputed after restoring clauses.
+//
+// We further mark in the external solver newly internalized external
+// literals in 'add' and 'assume' since the last call to 'solve' as tainted
+// if they occur negated as a witness literal on the extension stack.  Then
+// we go through the extension stack and restore all clauses which have a
+// tainted literal (and its negation a marked as witness).
+//
+// Since the API contract disallows to call 'val' and 'failed' in an
+// 'UNKNOWN' state. We do not have to internalize literals there.
+//
+// In order to have tainted literals accepted by the internal solver they
+// have to be active and thus we might need to 'reactivate' them before
+// restoring clauses if they are inactive. In case they have completely
+// been eliminated and removed from the internal solver in 'compact', then
+// we just use a new internal variable.  This is performed in 'internalize'
+// during marking external literals as tainted.
+//
+// To check that this approach is correct the external solver can maintain a
+// stack of original clauses and current assumptions both in terms of
+// external literals.  Whenever 'solve' determines that the current
+// incremental call is satisfiable we check that the (extended) witness does
+// satisfy the saved original clauses, as well as all the assumptions. To
+// enable these checks set 'opts.check' as well as 'opts.checkwitness' and
+// 'opts.checkassumptions' all to 'true'.  The model based tester actually
+// prefers to enable the 'opts.check' option and the other two are 'true' by
+// default anyhow.
+//
+// See our SAT'19 paper [FazekasBiereScholl-SAT'19] for more details.
+
+/*------------------------------------------------------------------------*/
+
+void External::restore_clause (const vector<int>::const_iterator &begin,
+                               const vector<int>::const_iterator &end,
+                               const int64_t id) {
+  LOG (begin, end, "restoring external clause[%" PRId64 "]", id);
+  CADICAL_assert (eclause.empty ());
+  CADICAL_assert (id);
+  for (auto p = begin; p != end; p++) {
+    eclause.push_back (*p);
+    if (internal->proof && internal->lrat) {
+      const auto &elit = *p;
+      unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
+      CADICAL_assert ((size_t) eidx < ext_units.size ());
+      const int64_t id = ext_units[eidx];
+      bool added = ext_flags[abs (elit)];
+      if (id && !added) {
+        ext_flags[abs (elit)] = true;
+        internal->lrat_chain.push_back (id);
+      }
+    }
+    int ilit = internalize (*p);
+    internal->add_original_lit (ilit), internal->stats.restoredlits++;
+  }
+  if (internal->proof && internal->lrat) {
+    for (const auto &elit : eclause) {
+      ext_flags[abs (elit)] = false;
+    }
+  }
+  internal->finish_added_clause_with_id (id, true);
+  eclause.clear ();
+  internal->stats.restored++;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::restore_clauses () {
+
+  CADICAL_assert (internal->opts.restoreall == 2 || !tainted.empty ());
+
+  START (restore);
+  internal->stats.restorations++;
+
+  struct {
+    int64_t weakened, satisfied, restored, removed;
+  } clauses;
+  memset (&clauses, 0, sizeof clauses);
+
+  if (internal->opts.restoreall && tainted.empty ())
+    PHASE ("restore", internal->stats.restorations,
+           "forced to restore all clauses");
+
+#ifndef CADICAL_QUIET
+  {
+    unsigned numtainted = 0;
+    for (const auto b : tainted)
+      if (b)
+        numtainted++;
+
+    PHASE ("restore", internal->stats.restorations,
+           "starting with %u tainted literals %.0f%%", numtainted,
+           percent (numtainted, 2u * max_var));
+  }
+#endif
+
+  auto end_of_extension = extension.end ();
+  auto p = extension.begin (), q = p;
+
+  // Go over all witness labelled clauses on the extension stack, restore
+  // those necessary, remove restored and flush satisfied clauses.
+  //
+  while (p != end_of_extension) {
+
+    clauses.weakened++;
+
+    CADICAL_assert (!*p);
+    const auto saved = q; // Save old start.
+    *q++ = *p++;          // Copy zero '0'.
+
+    // Copy witness part and try to find a tainted witness literal in it.
+    //
+    int tlit = 0; // Negation tainted.
+    int elit;
+    //
+    CADICAL_assert (p != end_of_extension);
+    //
+    while ((elit = *q++ = *p++)) {
+
+      if (marked (tainted, -elit)) {
+        tlit = elit;
+        LOG ("negation of witness literal %d tainted", tlit);
+      }
+
+      CADICAL_assert (p != end_of_extension);
+    }
+
+    // now copy the id of the clause
+    const int64_t id = ((int64_t) (*p) << 32) + (int64_t) * (p + 1);
+    LOG ("id is %" PRId64, id);
+    *q++ = *p++;
+    *q++ = *p++;
+    CADICAL_assert (id);
+    CADICAL_assert (!*p);
+    *q++ = *p++;
+
+    // Now find 'end_of_clause' (clause starts at 'p') and at the same time
+    // figure out whether the clause is actually root level satisfied.
+    //
+    int satisfied = 0;
+    auto end_of_clause = p;
+    while (end_of_clause != end_of_extension && (elit = *end_of_clause)) {
+      if (!satisfied && fixed (elit) > 0)
+        satisfied = elit;
+      end_of_clause++;
+    }
+    CADICAL_assert (id);
+
+    // Do not apply our 'FLUSH' rule to remove satisfied (implied) clauses
+    // if the corresponding option is set simply by resetting 'satisfied'.
+    //
+    if (satisfied && !internal->opts.restoreflush) {
+      LOG (p, end_of_clause, "forced to not remove %d satisfied",
+           satisfied);
+      satisfied = 0;
+    }
+
+    if (satisfied || tlit || internal->opts.restoreall) {
+
+      if (satisfied) {
+        LOG (p, end_of_clause,
+             "flushing implied clause satisfied by %d from extension stack",
+             satisfied);
+        clauses.satisfied++;
+      } else {
+        restore_clause (p, end_of_clause, id); // Might taint literals.
+        clauses.restored++;
+      }
+
+      clauses.removed++;
+      p = end_of_clause;
+      q = saved;
+
+    } else {
+
+      LOG (p, end_of_clause, "keeping clause on extension stack");
+
+      while (p != end_of_clause) // Copy clause too.
+        *q++ = *p++;
+    }
+  }
+
+  extension.resize (q - extension.begin ());
+  shrink_vector (extension);
+
+#ifndef CADICAL_QUIET
+  if (clauses.satisfied)
+    PHASE ("restore", internal->stats.restorations,
+           "removed %" PRId64 " satisfied %.0f%% of %" PRId64
+           " weakened clauses",
+           clauses.satisfied, percent (clauses.satisfied, clauses.weakened),
+           clauses.weakened);
+  else
+    PHASE ("restore", internal->stats.restorations,
+           "no satisfied clause removed out of %" PRId64
+           " weakened clauses",
+           clauses.weakened);
+
+  if (clauses.restored)
+    PHASE ("restore", internal->stats.restorations,
+           "restored %" PRId64 " clauses %.0f%% out of %" PRId64
+           " weakened clauses",
+           clauses.restored, percent (clauses.restored, clauses.weakened),
+           clauses.weakened);
+  else
+    PHASE ("restore", internal->stats.restorations,
+           "no clause restored out of %" PRId64 " weakened clauses",
+           clauses.weakened);
+  {
+    unsigned numtainted = 0;
+    for (const auto &b : tainted)
+      if (b)
+        numtainted++;
+
+    PHASE ("restore", internal->stats.restorations,
+           "finishing with %u tainted literals %.0f%%", numtainted,
+           percent (numtainted, 2u * max_var));
+  }
+
+#endif
+  LOG ("extension stack clean");
+  tainted.clear ();
+
+  // Finally recompute the witness bits.
+  //
+  witness.clear ();
+  const auto begin_of_extension = extension.begin ();
+  p = extension.end ();
+  while (p != begin_of_extension) {
+    while (*--p)
+      CADICAL_assert (p != begin_of_extension);
+    int elit;
+    CADICAL_assert (p != begin_of_extension);
+    --p;
+    CADICAL_assert (p != begin_of_extension);
+    CADICAL_assert (*p || *(p - 1));
+    --p;
+    CADICAL_assert (p != begin_of_extension);
+    CADICAL_assert (!*p);
+    --p;
+    CADICAL_assert (p != begin_of_extension);
+    while ((elit = *--p)) {
+      mark (witness, elit);
+      CADICAL_assert (p != begin_of_extension);
+    }
+  }
+
+  STOP (restore);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_score.cpp b/src/sat/cadical/cadical_score.cpp
new file mode 100644
index 000000000..420357929
--- /dev/null
+++ b/src/sat/cadical/cadical_score.cpp
@@ -0,0 +1,57 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// This initializes variables on the binary 'scores' heap also with
+// smallest variable index first (thus picked first) and larger indices at
+// the end.
+//
+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; i < new_max_var; i++)
+    scores.push_back (i + 1);
+}
+
+// Shuffle the EVSIDS heap.
+
+void Internal::shuffle_scores () {
+  if (!opts.shuffle)
+    return;
+  if (!opts.shufflescores)
+    return;
+  CADICAL_assert (!level);
+  stats.shuffled++;
+  LOG ("shuffling scores");
+  vector<int> shuffle;
+  if (opts.shufflerandom) {
+    scores.erase ();
+    for (int idx = max_var; idx; idx--)
+      shuffle.push_back (idx);
+    Random random (opts.seed); // global seed
+    random += stats.shuffled;  // different every time
+    for (int i = 0; i <= max_var - 2; i++) {
+      const int j = random.pick_int (i, max_var - 1);
+      swap (shuffle[i], shuffle[j]);
+    }
+  } else {
+    while (!scores.empty ()) {
+      int idx = scores.front ();
+      (void) scores.pop_front ();
+      shuffle.push_back (idx);
+    }
+  }
+  score_inc = 0;
+  for (const auto &idx : shuffle) {
+    stab[idx] = score_inc++;
+    scores.push_back (idx);
+  }
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_shrink.cpp b/src/sat/cadical/cadical_shrink.cpp
new file mode 100644
index 000000000..201c220e7
--- /dev/null
+++ b/src/sat/cadical/cadical_shrink.cpp
@@ -0,0 +1,513 @@
+#include "global.h"
+
+#include "internal.hpp"
+#include "reap.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::reset_shrinkable () {
+#ifdef LOGGING
+  size_t reset = 0;
+#endif
+  for (const auto &lit : shrinkable) {
+    LOG ("resetting lit %i", lit);
+    Flags &f = flags (lit);
+    CADICAL_assert (f.shrinkable);
+    f.shrinkable = false;
+#ifdef LOGGING
+    ++reset;
+#endif
+  }
+  LOG ("resetting %zu shrinkable variables", reset);
+}
+
+void Internal::mark_shrinkable_as_removable (
+    int blevel, std::vector<int>::size_type minimized_start) {
+#ifdef LOGGING
+  size_t marked = 0, reset = 0;
+#endif
+#ifndef CADICAL_NDEBUG
+  unsigned kept = 0, minireset = 0;
+  for (; minimized_start < minimized.size (); ++minimized_start) {
+    const int lit = minimized[minimized_start];
+    Flags &f = flags (lit);
+    const Var &v = var (lit);
+    if (v.level == blevel) {
+      CADICAL_assert (!f.poison);
+      ++minireset;
+    } else
+      ++kept;
+  }
+  (void) kept;
+  (void) minireset;
+#else
+  (void) blevel;
+  (void) minimized_start;
+#endif
+
+  for (const int lit : shrinkable) {
+    Flags &f = flags (lit);
+    CADICAL_assert (f.shrinkable);
+    CADICAL_assert (!f.poison);
+    f.shrinkable = false;
+#ifdef LOGGING
+    ++reset;
+#endif
+    if (f.removable)
+      continue;
+    f.removable = true;
+    minimized.push_back (lit);
+#ifdef LOGGING
+    ++marked;
+#endif
+  }
+  LOG ("resetting %zu shrinkable variables", reset);
+  LOG ("marked %zu removable variables", marked);
+}
+
+int inline Internal::shrink_literal (int lit, int blevel,
+                                     unsigned max_trail) {
+  CADICAL_assert (val (lit) < 0);
+
+  Flags &f = flags (lit);
+  Var &v = var (lit);
+  CADICAL_assert (v.level <= blevel);
+
+  if (!v.level) {
+    LOG ("skipping root level assigned %d", (lit));
+    return 0;
+  }
+
+  if (v.reason == external_reason) {
+    CADICAL_assert (!opts.exteagerreasons);
+    v.reason = learn_external_reason_clause (-lit, 0, true);
+    if (!v.reason) {
+      CADICAL_assert (!v.level);
+      return 0;
+    }
+  }
+  CADICAL_assert (v.reason != external_reason);
+  if (f.shrinkable) {
+    LOG ("skipping already shrinkable literal %d", (lit));
+    return 0;
+  }
+
+  if (v.level < blevel) {
+    if (f.removable) {
+      LOG ("skipping removable thus shrinkable %d", (lit));
+      return 0;
+    }
+    const bool always_minimize_on_lower_blevel = (opts.shrink > 2);
+    if (always_minimize_on_lower_blevel && minimize_literal (-lit, 1)) {
+      LOG ("minimized thus shrinkable %d", (lit));
+      return 0;
+    }
+    LOG ("literal %d on lower blevel %u < %u not removable/shrinkable",
+         (lit), v.level, blevel);
+    return -1;
+  }
+
+  LOG ("marking %d as shrinkable", lit);
+  f.shrinkable = true;
+  f.poison = false;
+  shrinkable.push_back (lit);
+  if (opts.shrinkreap) {
+    CADICAL_assert (max_trail < trail.size ());
+    const unsigned dist = max_trail - v.trail;
+    reap.push (dist);
+  }
+  return 1;
+}
+
+unsigned Internal::shrunken_block_uip (
+    int uip, int blevel, std::vector<int>::reverse_iterator &rbegin_block,
+    std::vector<int>::reverse_iterator &rend_block,
+    std::vector<int>::size_type minimized_start, const int uip0) {
+  CADICAL_assert (clause[0] == uip0);
+
+  LOG ("UIP on level %u, uip: %i (replacing by %i)", blevel, uip, uip0);
+  CADICAL_assert (rend_block > rbegin_block);
+  CADICAL_assert (rend_block < clause.rend ());
+  unsigned block_shrunken = 0;
+  *rbegin_block = -uip;
+  Var &v = var (-uip);
+  Level &l = control[v.level];
+  l.seen.trail = v.trail;
+  l.seen.count = 1;
+
+  Flags &f = flags (-uip);
+  if (!f.seen) {
+    analyzed.push_back (-uip);
+    f.seen = true;
+  }
+
+  flags (-uip).keep = true;
+  for (auto p = rbegin_block + 1; p != rend_block; ++p) {
+    const int lit = *p;
+    if (lit == -uip0)
+      continue;
+    *p = uip0;
+    // if (lit == -uip) continue;
+    ++block_shrunken;
+    CADICAL_assert (clause[0] == uip0);
+  }
+  mark_shrinkable_as_removable (blevel, minimized_start);
+  CADICAL_assert (clause[0] == uip0);
+  return block_shrunken;
+}
+
+void inline Internal::shrunken_block_no_uip (
+    const std::vector<int>::reverse_iterator &rbegin_block,
+    const std::vector<int>::reverse_iterator &rend_block,
+    unsigned &block_minimized, const int uip0) {
+  STOP (shrink);
+  START (minimize);
+  CADICAL_assert (rend_block > rbegin_block);
+  LOG ("no UIP found, now minimizing");
+  for (auto p = rbegin_block; p != rend_block; ++p) {
+    CADICAL_assert (p != clause.rend () - 1);
+    const int lit = *p;
+    if (opts.minimize && minimize_literal (-lit)) {
+      CADICAL_assert (!flags (lit).keep);
+      ++block_minimized;
+      *p = uip0;
+    } else {
+      flags (lit).keep = true;
+      CADICAL_assert (flags (lit).keep);
+    }
+  }
+  STOP (minimize);
+  START (shrink);
+}
+
+void Internal::push_literals_of_block (
+    const std::vector<int>::reverse_iterator &rbegin_block,
+    const std::vector<int>::reverse_iterator &rend_block, int blevel,
+    unsigned max_trail) {
+  CADICAL_assert (rbegin_block < rend_block);
+  for (auto p = rbegin_block; p != rend_block; ++p) {
+    CADICAL_assert (p != clause.rend () - 1);
+    CADICAL_assert (!flags (*p).keep);
+    const int lit = *p;
+    LOG ("pushing lit %i of blevel %i", lit, var (lit).level);
+#ifndef CADICAL_NDEBUG
+    int tmp =
+#endif
+        shrink_literal (lit, blevel, max_trail);
+    CADICAL_assert (tmp > 0);
+  }
+}
+
+unsigned inline Internal::shrink_next (int blevel, unsigned &open,
+                                       unsigned &max_trail) {
+  const auto &t = &trail;
+  if (opts.shrinkreap) {
+    CADICAL_assert (!reap.empty ());
+    const unsigned dist = reap.pop ();
+    --open;
+    CADICAL_assert (dist <= max_trail);
+    const unsigned pos = max_trail - dist;
+    CADICAL_assert (pos < t->size ());
+    const int uip = (*t)[pos];
+    CADICAL_assert (val (uip) > 0);
+    LOG ("trying to shrink literal %d at trail[%u] and level %d", uip, pos,
+         blevel);
+    return uip;
+  } else {
+    int uip;
+#ifndef CADICAL_NDEBUG
+    unsigned init_max_trail = max_trail;
+#endif
+    do {
+      CADICAL_assert (max_trail <= init_max_trail);
+      uip = (*t)[max_trail--];
+    } while (!flags (uip).shrinkable);
+    --open;
+    LOG ("open is now %d, uip = %d, level %d", open, uip, blevel);
+    return uip;
+  }
+  (void) blevel;
+}
+
+unsigned inline Internal::shrink_along_reason (int uip, int blevel,
+                                               bool resolve_large_clauses,
+                                               bool &failed_ptr,
+                                               unsigned max_trail) {
+  LOG ("shrinking along the reason of lit %i", uip);
+  unsigned open = 0;
+#ifndef CADICAL_NDEBUG
+  const Flags &f = flags (uip);
+#endif
+  const Var &v = var (uip);
+
+  CADICAL_assert (f.shrinkable);
+  CADICAL_assert (v.level == blevel);
+  CADICAL_assert (v.reason);
+
+  if (opts.minimizeticks)
+    stats.ticks.search[stable]++;
+
+  if (resolve_large_clauses || v.reason->size == 2) {
+    const Clause &c = *v.reason;
+    LOG (v.reason, "resolving with reason");
+    for (int lit : c) {
+      if (lit == uip)
+        continue;
+      CADICAL_assert (val (lit) < 0);
+      int tmp = shrink_literal (lit, blevel, max_trail);
+      if (tmp < 0) {
+        failed_ptr = true;
+        break;
+      }
+      if (tmp > 0) {
+        ++open;
+      }
+    }
+  } else {
+    failed_ptr = true;
+  }
+  return open;
+}
+
+unsigned
+Internal::shrink_block (std::vector<int>::reverse_iterator &rbegin_lits,
+                        std::vector<int>::reverse_iterator &rend_block,
+                        int blevel, unsigned &open,
+                        unsigned &block_minimized, const int uip0,
+                        unsigned max_trail) {
+  CADICAL_assert (shrinkable.empty ());
+  CADICAL_assert (blevel <= this->level);
+  CADICAL_assert (open < clause.size ());
+  CADICAL_assert (rbegin_lits >= clause.rbegin ());
+  CADICAL_assert (rend_block < clause.rend ());
+  CADICAL_assert (rbegin_lits < rend_block);
+  CADICAL_assert (opts.shrink);
+
+#ifdef LOGGING
+
+  LOG ("trying to shrink %u literals on level %u", open, blevel);
+
+  const auto &t = &trail;
+
+  LOG ("maximum trail position %zd on level %u", t->size (), blevel);
+  if (opts.shrinkreap)
+    LOG ("shrinking up to %u", max_trail);
+#endif
+
+  const bool resolve_large_clauses = (opts.shrink > 1);
+  bool failed = false;
+  unsigned block_shrunken = 0;
+  std::vector<int>::size_type minimized_start = minimized.size ();
+  int uip = uip0;
+  unsigned max_trail2 = max_trail;
+
+  if (!failed) {
+    push_literals_of_block (rbegin_lits, rend_block, blevel, max_trail);
+    CADICAL_assert (!opts.shrinkreap || reap.size () == open);
+
+    CADICAL_assert (open > 0);
+    while (!failed) {
+      CADICAL_assert (!opts.shrinkreap || reap.size () == open);
+      uip = shrink_next (blevel, open, max_trail);
+      if (open == 0) {
+        break;
+      }
+      open += shrink_along_reason (uip, blevel, resolve_large_clauses,
+                                   failed, max_trail2);
+      CADICAL_assert (open >= 1);
+    }
+
+    if (!failed)
+      LOG ("shrinking found UIP %i on level %i (open: %d)", uip, blevel,
+           open);
+    else
+      LOG ("shrinking failed on level %i", blevel);
+  }
+
+  if (failed)
+    reset_shrinkable (), shrunken_block_no_uip (rbegin_lits, rend_block,
+                                                block_minimized, uip0);
+  else
+    block_shrunken = shrunken_block_uip (uip, blevel, rbegin_lits,
+                                         rend_block, minimized_start, uip0);
+
+  if (opts.shrinkreap)
+    reap.clear ();
+  shrinkable.clear ();
+  return block_shrunken;
+}
+
+// Smaller level and trail.  Comparing literals on their level is necessary
+// for chronological backtracking, since trail order might in this case not
+// respect level order.
+
+struct shrink_trail_negative_rank {
+  Internal *internal;
+  shrink_trail_negative_rank (Internal *s) : internal (s) {}
+  typedef uint64_t Type;
+  Type operator() (int a) {
+    Var &v = internal->var (a);
+    uint64_t res = v.level;
+    res <<= 32;
+    res |= v.trail;
+    return ~res;
+  }
+};
+
+struct shrink_trail_larger {
+  Internal *internal;
+  shrink_trail_larger (Internal *s) : internal (s) {}
+  bool operator() (const int &a, const int &b) const {
+    return shrink_trail_negative_rank (internal) (a) <
+           shrink_trail_negative_rank (internal) (b);
+  }
+};
+
+// Finds the beginning of the block (rend_block, non-included) ending at
+// rend_block (included). Then tries to shrinks and minimizes literals  the
+// block
+std::vector<int>::reverse_iterator Internal::minimize_and_shrink_block (
+    std::vector<int>::reverse_iterator &rbegin_block,
+    unsigned &total_shrunken, unsigned &total_minimized, const int uip0)
+
+{
+  LOG ("shrinking block");
+  CADICAL_assert (rbegin_block < clause.rend () - 1);
+  int blevel;
+  unsigned open = 0;
+  unsigned max_trail;
+
+  // find begining of block;
+  std::vector<int>::reverse_iterator rend_block;
+  {
+    CADICAL_assert (rbegin_block <= clause.rend ());
+    const int lit = *rbegin_block;
+    const int idx = vidx (lit);
+    blevel = vtab[idx].level;
+    max_trail = vtab[idx].trail;
+    LOG ("Block at level %i (first lit: %i)", blevel, lit);
+
+    rend_block = rbegin_block;
+    bool finished;
+    do {
+      CADICAL_assert (rend_block < clause.rend () - 1);
+      const int lit = *(++rend_block);
+      const int idx = vidx (lit);
+      finished = (blevel != vtab[idx].level);
+      if (!finished && (unsigned) vtab[idx].trail > max_trail)
+        max_trail = vtab[idx].trail;
+      ++open;
+      LOG (
+          "testing if lit %i is on the same level (of lit: %i, global: %i)",
+          lit, vtab[idx].level, blevel);
+
+    } while (!finished);
+  }
+  CADICAL_assert (open > 0);
+  CADICAL_assert (open < clause.size ());
+  CADICAL_assert (rbegin_block < clause.rend ());
+  CADICAL_assert (rend_block < clause.rend ());
+
+  unsigned block_shrunken = 0, block_minimized = 0;
+  if (open < 2) {
+    flags (*rbegin_block).keep = true;
+    minimized.push_back (*rbegin_block);
+  } else
+    block_shrunken = shrink_block (rbegin_block, rend_block, blevel, open,
+                                   block_minimized, uip0, max_trail);
+
+  LOG ("shrunken %u literals on level %u (including %u minimized)",
+       block_shrunken, blevel, block_minimized);
+
+  total_shrunken += block_shrunken;
+  total_minimized += block_minimized;
+
+  return rend_block;
+}
+
+void Internal::shrink_and_minimize_clause () {
+  CADICAL_assert (opts.minimize || opts.shrink > 0);
+  LOG (clause, "shrink first UIP clause");
+
+  START (shrink);
+  external->check_learned_clause (); // check 1st UIP learned clause first
+  MSORT (opts.radixsortlim, clause.begin (), clause.end (),
+         shrink_trail_negative_rank (this), shrink_trail_larger (this));
+  unsigned total_shrunken = 0;
+  unsigned total_minimized = 0;
+
+  LOG (clause, "shrink first UIP clause (CADICAL_asserting lit: %i)", clause[0]);
+
+  auto rend_lits = clause.rend () - 1;
+  auto rend_block = clause.rbegin ();
+  const int uip0 = clause[0];
+
+  // for direct LRAT we remember how the clause used to look
+  vector<int> old_clause_lrat;
+  CADICAL_assert (minimize_chain.empty ());
+  if (lrat)
+    for (auto &i : clause)
+      old_clause_lrat.push_back (i);
+
+  while (rend_block != rend_lits) {
+    rend_block = minimize_and_shrink_block (rend_block, total_shrunken,
+                                            total_minimized, uip0);
+  }
+
+  LOG (clause,
+       "post shrink pass (with uips, not removed) first UIP clause");
+  LOG (old_clause_lrat, "(used for lratdirect) before shrink: clause");
+#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
+  const unsigned old_size = clause.size ();
+#endif
+  std::vector<int> stack;
+  {
+    std::vector<int>::size_type i = 1;
+    for (std::vector<int>::size_type j = 1; j < clause.size (); ++j) {
+      CADICAL_assert (i <= j);
+      clause[i] = clause[j];
+      if (lrat) {
+        CADICAL_assert (j < old_clause_lrat.size ());
+        CADICAL_assert (mini_chain.empty ());
+        if (clause[j] != old_clause_lrat[j]) {
+          calculate_minimize_chain (-old_clause_lrat[j], stack);
+          for (auto p : mini_chain) {
+            minimize_chain.push_back (p);
+          }
+          mini_chain.clear ();
+        }
+      }
+      if (clause[j] == uip0) {
+        continue;
+      }
+      CADICAL_assert (flags (clause[i]).keep);
+      ++i;
+      LOG ("keeping literal %i", clause[j]);
+    }
+    clause.resize (i);
+  }
+  CADICAL_assert (old_size ==
+          (unsigned) clause.size () + total_shrunken + total_minimized);
+  LOG (clause, "after shrinking first UIP clause");
+  LOG ("clause shrunken by %zd literals (including %u minimized)",
+       old_size - clause.size (), total_minimized);
+
+  stats.shrunken += total_shrunken;
+  stats.minishrunken += total_minimized;
+  STOP (shrink);
+
+  START (minimize);
+  clear_minimized_literals ();
+  for (auto p = minimize_chain.rbegin (); p != minimize_chain.rend ();
+       p++) {
+    lrat_chain.push_back (*p);
+  }
+  minimize_chain.clear ();
+  STOP (minimize);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_signal.cpp b/src/sat/cadical/cadical_signal.cpp
new file mode 100644
index 000000000..099277f03
--- /dev/null
+++ b/src/sat/cadical/cadical_signal.cpp
@@ -0,0 +1,144 @@
+#include "global.h"
+
+#include "signal.hpp"
+#include "cadical.hpp"
+#include "resources.hpp"
+
+/*------------------------------------------------------------------------*/
+
+#include <cassert>
+#include <csignal>
+
+/*------------------------------------------------------------------------*/
+
+#ifndef WIN32
+extern "C" {
+#include <unistd.h>
+}
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+/*------------------------------------------------------------------------*/
+
+// Signal handlers for printing statistics even if solver is interrupted.
+
+namespace CaDiCaL {
+
+static volatile bool caught_signal = false;
+static Handler *signal_handler;
+
+#ifndef WIN32
+
+static volatile bool caught_alarm = false;
+static volatile bool alarm_set = false;
+static int alarm_time = -1;
+
+void Handler::catch_alarm () { catch_signal (SIGALRM); }
+
+#endif
+
+#define SIGNALS \
+  SIGNAL (SIGABRT) \
+  SIGNAL (SIGINT) \
+  SIGNAL (SIGSEGV) \
+  SIGNAL (SIGTERM)
+
+#define SIGNAL(SIG) static void (*SIG##_handler) (int);
+SIGNALS
+#undef SIGNAL
+
+#ifndef WIN32
+
+static void (*SIGALRM_handler) (int);
+
+void Signal::reset_alarm () {
+  if (!alarm_set)
+    return;
+  (void) signal (SIGALRM, SIGALRM_handler);
+  SIGALRM_handler = 0;
+  caught_alarm = false;
+  alarm_set = false;
+  alarm_time = -1;
+}
+
+#endif
+
+void Signal::reset () {
+  signal_handler = 0;
+#define SIGNAL(SIG) \
+  (void) signal (SIG, SIG##_handler); \
+  SIG##_handler = 0;
+  SIGNALS
+#undef SIGNAL
+#ifndef WIN32
+  reset_alarm ();
+#endif
+  caught_signal = false;
+}
+
+const char *Signal::name (int sig) {
+#define SIGNAL(SIG) \
+  if (sig == SIG) \
+    return #SIG;
+  SIGNALS
+#undef SIGNAL
+#ifndef WIN32
+  if (sig == SIGALRM)
+    return "SIGALRM";
+#endif
+  return "UNKNOWN";
+}
+
+// TODO printing is not reentrant and might lead to deadlock if the signal
+// is raised during another print attempt (and locked IO is used).  To avoid
+// this we have to either run our own low-level printing routine here or in
+// 'Message' or just dump those statistics somewhere else were we have
+// exclusive access to.  All these solutions are painful and not elegant.
+
+static void catch_signal (int sig) {
+#ifndef WIN32
+  if (sig == SIGALRM && absolute_real_time () >= alarm_time) {
+    if (!caught_alarm) {
+      caught_alarm = true;
+      if (signal_handler)
+        signal_handler->catch_alarm ();
+    }
+    Signal::reset_alarm ();
+  } else
+#endif
+  {
+    if (!caught_signal) {
+      caught_signal = true;
+      if (signal_handler)
+        signal_handler->catch_signal (sig);
+    }
+    Signal::reset ();
+    ::raise (sig);
+  }
+}
+
+void Signal::set (Handler *h) {
+  signal_handler = h;
+#define SIGNAL(SIG) SIG##_handler = signal (SIG, catch_signal);
+  SIGNALS
+#undef SIGNAL
+}
+
+#ifndef WIN32
+
+void Signal::alarm (int seconds) {
+  CADICAL_assert (seconds >= 0);
+  CADICAL_assert (!alarm_set);
+  CADICAL_assert (alarm_time < 0);
+  SIGALRM_handler = signal (SIGALRM, catch_signal);
+  alarm_set = true;
+  alarm_time = absolute_real_time () + seconds;
+  ::alarm (seconds);
+}
+
+#endif
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_solution.cpp b/src/sat/cadical/cadical_solution.cpp
new file mode 100644
index 000000000..1d7514e42
--- /dev/null
+++ b/src/sat/cadical/cadical_solution.cpp
@@ -0,0 +1,56 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+// Sam Buss suggested to debug the case where a solver incorrectly claims
+// the formula to be unsatisfiable by checking every learned clause to be
+// satisfied by a satisfying assignment.  Thus the first inconsistent
+// learned clause will be immediately flagged without the need to generate
+// proof traces and perform forward proof checking.  The incorrectly derived
+// clause will raise an abort signal and thus allows to debug the issue with
+// a symbolic debugger immediately.
+
+void External::check_solution_on_learned_clause () {
+  CADICAL_assert (solution);
+  for (const auto &lit : internal->clause)
+    if (sol (internal->externalize (lit)) == lit)
+      return;
+  fatal_message_start ();
+  fputs ("learned clause unsatisfied by solution:\n", stderr);
+  for (const auto &lit : internal->clause)
+    fprintf (stderr, "%d ", lit);
+  fputc ('0', stderr);
+  fatal_message_end ();
+}
+
+void External::check_solution_on_shrunken_clause (Clause *c) {
+  CADICAL_assert (solution);
+  for (const auto &lit : *c)
+    if (sol (internal->externalize (lit)) == lit)
+      return;
+  fatal_message_start ();
+  for (const auto &lit : *c)
+    fprintf (stderr, "%d ", lit);
+  fputc ('0', stderr);
+  fatal_message_end ();
+}
+
+void External::check_no_solution_after_learning_empty_clause () {
+  CADICAL_assert (solution);
+  FATAL ("learned empty clause but got solution");
+}
+
+void External::check_solution_on_learned_unit_clause (int unit) {
+  CADICAL_assert (solution);
+  if (sol (internal->externalize (unit)) == unit)
+    return;
+  FATAL ("learned unit %d contradicts solution", unit);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_solver.cpp b/src/sat/cadical/cadical_solver.cpp
new file mode 100644
index 000000000..df051f4de
--- /dev/null
+++ b/src/sat/cadical/cadical_solver.cpp
@@ -0,0 +1,1764 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// See corresponding header file 'cadical.hpp' (!) for more information.
+//
+// Again, to avoid confusion, note that, 'cadical.hpp' is the header file of
+// this file 'solver.cpp', since we want to call the application and main
+// file 'cadical.cpp', while at the same time using 'cadical.hpp' as the
+// main header file of the library (and not 'solver.hpp').
+
+/*------------------------------------------------------------------------*/
+#ifdef LOGGING
+
+// Needs to be kept in sync with the color schemes used in 'logging.cpp'.
+//
+#define api_code blue_code            // API call color
+#define log_code magenta_code         // standard/default logging color
+#define emph_code bright_magenta_code // emphasized logging color
+
+#endif
+/*------------------------------------------------------------------------*/
+
+// Log state transitions.
+
+#define STATE(S) \
+  do { \
+    CADICAL_assert (is_power_of_two (S)); \
+    if (_state == S) \
+      break; \
+    _state = S; \
+    LOG ("API enters state %s" #S "%s", tout.emph_code (), \
+         tout.normal_code ()); \
+  } while (0)
+
+void Solver::transition_to_steady_state () {
+  if (state () == CONFIGURING) {
+    LOG ("API leaves state %sCONFIGURING%s", tout.emph_code (),
+         tout.normal_code ());
+    if (internal->opts.check && internal->opts.checkproof) {
+      internal->check ();
+    }
+  } else if (state () == SATISFIED) {
+    LOG ("API leaves state %sSATISFIED%s", tout.emph_code (),
+         tout.normal_code ());
+    external->reset_assumptions ();
+    external->reset_concluded ();
+    external->reset_constraint ();
+  } else if (state () == UNSATISFIED) {
+    LOG ("API leaves state %sUNSATISFIED%s", tout.emph_code (),
+         tout.normal_code ());
+    external->reset_assumptions ();
+    external->reset_concluded ();
+    external->reset_constraint ();
+  } else if (state() == INCONCLUSIVE) {
+    external->reset_assumptions ();
+    external->reset_concluded ();
+    external->reset_constraint ();
+  }
+  if (state () != STEADY)
+    STATE (STEADY);
+}
+
+/*------------------------------------------------------------------------*/
+#ifdef LOGGING
+/*------------------------------------------------------------------------*/
+
+// The following logging code is useful for debugging mostly (or trying to
+// understand what the solver is actually doing).  It needs to be enabled
+// during configuration using the '-l' option for './configure', which
+// forces 'LOGGING' to be defined during compilation.  This includes all the
+// logging code, which then still needs to enabled during run-time with the
+// '-l' or 'log' option.
+
+static void log_api_call (Internal *internal, const char *name,
+                          const char *suffix) {
+  Logger::log (internal, "API call %s'%s ()'%s %s", tout.api_code (), name,
+               tout.log_code (), suffix);
+}
+
+static void log_api_call (Internal *internal, const char *name, int arg,
+                          const char *suffix) {
+  Logger::log (internal, "API call %s'%s (%d)'%s %s", tout.api_code (),
+               name, arg, tout.log_code (), suffix);
+}
+
+static void log_api_call (Internal *internal, const char *name,
+                          const char *arg, const char *suffix) {
+  Logger::log (internal, "API call %s'%s (\"%s\")'%s %s", tout.api_code (),
+               name, arg, tout.log_code (), suffix);
+}
+
+static void log_api_call (Internal *internal, const char *name,
+                          const char *a1, int a2, const char *s) {
+  Logger::log (internal, "API call %s'%s (\"%s\", %d)'%s %s",
+               tout.api_code (), name, a1, a2, tout.log_code (), s);
+}
+
+/*------------------------------------------------------------------------*/
+
+// We factored out API call begin/end logging and use overloaded functions.
+
+static void log_api_call_begin (Internal *internal, const char *name) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, "started");
+}
+
+static void log_api_call_begin (Internal *internal, const char *name,
+                                int arg) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, arg, "started");
+}
+
+static void log_api_call_begin (Internal *internal, const char *name,
+                                const char *arg) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, arg, "started");
+}
+
+static void log_api_call_begin (Internal *internal, const char *name,
+                                const char *arg1, int arg2) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, arg1, arg2, "started");
+}
+
+/*------------------------------------------------------------------------*/
+
+static void log_api_call_end (Internal *internal, const char *name) {
+  log_api_call (internal, name, "succeeded");
+}
+
+static void log_api_call_end (Internal *internal, const char *name,
+                              int lit) {
+  log_api_call (internal, name, lit, "succeeded");
+}
+
+static void log_api_call_end (Internal *internal, const char *name,
+                              const char *arg) {
+  Logger::log_empty_line (internal);
+  log_api_call (internal, name, arg, "succeeded");
+}
+
+static void log_api_call_end (Internal *internal, const char *name,
+                              const char *arg, bool res) {
+  log_api_call (internal, name, arg, res ? "succeeded" : "failed");
+}
+
+static void log_api_call_end (Internal *internal, const char *name,
+                              const char *arg, int val, bool res) {
+  log_api_call (internal, name, arg, val, res ? "succeeded" : "failed");
+}
+
+static void log_api_call_returns (Internal *internal, const char *name,
+                                  bool res) {
+  log_api_call (internal, name, res ? "returns 'true'" : "returns 'false'");
+}
+
+static void log_api_call_returns (Internal *internal, const char *name,
+                                  int res) {
+  char fmt[32];
+  snprintf (fmt, sizeof fmt, "returns '%d'", res);
+  log_api_call (internal, name, fmt);
+}
+
+static void log_api_call_returns (Internal *internal, const char *name,
+                                  int64_t res) {
+  char fmt[32];
+  snprintf (fmt, sizeof fmt, "returns '%" PRId64 "'", res);
+  log_api_call (internal, name, fmt);
+}
+
+static void log_api_call_returns (Internal *internal, const char *name,
+                                  int lit, int res) {
+  char fmt[32];
+  snprintf (fmt, sizeof fmt, "returns '%d'", res);
+  log_api_call (internal, name, lit, fmt);
+}
+
+static void log_api_call_returns (Internal *internal, const char *name,
+                                  const char *arg, bool res) {
+  log_api_call (internal, name, arg,
+                res ? "returns 'true'" : "returns 'false'");
+}
+
+static void log_api_call_returns (Internal *internal, const char *name,
+                                  int lit, bool res) {
+  log_api_call (internal, name, lit,
+                res ? "returns 'true'" : "returns 'false'");
+}
+
+static void log_api_call_returns (Internal *internal, const char *name,
+                                  const char *arg, const char *res) {
+  Logger::log (internal, "API call %s'%s (\"%s\")'%s returns '%s'",
+               tout.api_code (), name, arg, tout.log_code (),
+               res ? res : "<null>");
+}
+
+static void log_api_call_returns (Internal *internal, const char *name,
+                                  const char *arg1, int arg2,
+                                  const char *res) {
+  Logger::log (internal, "API call %s'%s (\"%s\", %d)'%s returns '%s'",
+               tout.api_code (), name, arg1, arg2, tout.log_code (),
+               res ? res : "<null>");
+}
+
+/*------------------------------------------------------------------------*/
+
+#define LOG_API_CALL_BEGIN(...) \
+  do { \
+    if (!internal->opts.log) \
+      break; \
+    log_api_call_begin (internal, __VA_ARGS__); \
+  } while (0)
+
+#define LOG_API_CALL_END(...) \
+  do { \
+    if (!internal->opts.log) \
+      break; \
+    log_api_call_end (internal, __VA_ARGS__); \
+  } while (0)
+
+#define LOG_API_CALL_RETURNS(...) \
+  do { \
+    if (!internal->opts.log) \
+      break; \
+    log_api_call_returns (internal, __VA_ARGS__); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+#else // end of 'then' part of 'ifdef LOGGING'
+/*------------------------------------------------------------------------*/
+
+#define LOG_API_CALL_BEGIN(...) \
+  do { \
+  } while (0)
+#define LOG_API_CALL_END(...) \
+  do { \
+  } while (0)
+#define LOG_API_CALL_RETURNS(...) \
+  do { \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif // end of 'else' part of 'ifdef LOGGING'
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+#ifndef CADICAL_NTRACING
+/*------------------------------------------------------------------------*/
+
+#define TRACE(...) \
+  do { \
+    /*if ((this == 0)) break; */ /* gcc-12 produces warning */ \
+    if ((internal == 0)) \
+      break; \
+    LOG_API_CALL_BEGIN (__VA_ARGS__); \
+    if (!trace_api_file) \
+      break; \
+    trace_api_call (__VA_ARGS__); \
+  } while (0)
+
+void Solver::trace_api_call (const char *s0) const {
+  CADICAL_assert (trace_api_file);
+  LOG ("TRACE %s", s0);
+  fprintf (trace_api_file, "%s\n", s0);
+  fflush (trace_api_file);
+}
+
+void Solver::trace_api_call (const char *s0, int i1) const {
+  CADICAL_assert (trace_api_file);
+  LOG ("TRACE %s %d", s0, i1);
+  fprintf (trace_api_file, "%s %d\n", s0, i1);
+  fflush (trace_api_file);
+}
+
+void Solver::trace_api_call (const char *s0, const char *s1) const {
+  CADICAL_assert (trace_api_file);
+  LOG ("TRACE %s %s", s0, s1);
+  fprintf (trace_api_file, "%s %s\n", s0, s1);
+  fflush (trace_api_file);
+}
+
+void Solver::trace_api_call (const char *s0, const char *s1, int i2) const {
+  CADICAL_assert (trace_api_file);
+  LOG ("TRACE %s %s %d", s0, s1, i2);
+  fprintf (trace_api_file, "%s %s %d\n", s0, s1, i2);
+  fflush (trace_api_file);
+}
+
+/*------------------------------------------------------------------------*/
+
+// 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 // CADICAL_NTRACING
+/*------------------------------------------------------------------------*/
+
+#define TRACE(...) \
+  do { \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif
+/*------------------------------------------------------------------------*/
+
+static bool tracing_nb_lidrup_env_var_method = false;
+
+Solver::Solver () {
+
+#ifndef CADICAL_NTRACING
+  const char *path = getenv ("CADICAL_API_TRACE");
+  if (!path)
+    path = getenv ("CADICALAPITRACE");
+  if (path) {
+    if (tracing_api_calls_through_environment_variable_method)
+      FATAL ("can not trace API calls of two solver instances "
+             "using environment variable 'CADICAL_API_TRACE'");
+    if (!(trace_api_file = fopen (path, "w")))
+      FATAL ("failed to open file '%s' to trace API calls "
+             "using environment variable 'CADICAL_API_TRACE'",
+             path);
+    close_trace_api_file = true;
+    tracing_api_calls_through_environment_variable_method = true;
+  } else {
+    tracing_api_calls_through_environment_variable_method = false;
+    close_trace_api_file = false;
+    trace_api_file = 0;
+  }
+#endif
+
+  adding_clause = false;
+  adding_constraint = false;
+  _state = INITIALIZING;
+  internal = new Internal ();
+  DeferDeletePtr<Internal> delete_internal (internal);
+  TRACE ("init");
+  external = new External (internal);
+  DeferDeletePtr<External> delete_external (external);
+  STATE (CONFIGURING);
+#ifndef CADICAL_NTRACING
+  if (tracing_api_calls_through_environment_variable_method)
+    message ("tracing API calls to '%s'", path);
+#endif
+
+  const char *lidrup_path = getenv ("CADICAL_LIDRUP_TRACE");
+  if (!lidrup_path)
+    lidrup_path = getenv ("CADICALLIDRUPTRACE");
+  if (lidrup_path) {
+
+    // if (tracing_nb_lidrup_env_var_method)
+    // FATAL ("can not trace LIDRUP of two solver instances "
+    //   "using environment variable 'CADICAL_LIDRUP_TRACE'");
+    // Here we use the solver interface to setup non-binary IDRUP tracing to
+    // the defined file. Options set by the user can and will overwrite
+    // these settings if neeed be.
+    set ("lidrup", 1);
+    set ("binary", 0);
+    trace_proof (lidrup_path);
+    tracing_nb_lidrup_env_var_method = true;
+  } else {
+    tracing_nb_lidrup_env_var_method = false;
+  }
+
+  delete_internal.release ();
+  delete_external.release ();
+}
+
+Solver::~Solver () {
+
+  TRACE ("reset");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  STATE (DELETING);
+
+  tracing_nb_lidrup_env_var_method = false;
+
+#ifdef LOGGING
+  //
+  // After deleting 'internal' logging does not work anymore.
+  //
+  bool logging = internal->opts.log;
+  int level = internal->level;
+  string prefix = internal->prefix;
+#endif
+
+  delete internal;
+  delete external;
+
+#ifndef CADICAL_NTRACING
+  if (close_trace_api_file) {
+    close_trace_api_file = false;
+    CADICAL_assert (trace_api_file);
+    CADICAL_assert (tracing_api_calls_through_environment_variable_method);
+    fclose (trace_api_file);
+    tracing_api_calls_through_environment_variable_method = false;
+  }
+#endif
+
+#ifdef LOGGING
+  //
+  // Need to log success of this API call manually.
+  //
+  if (logging) {
+    printf ("%s%sLOG %s%d%s API call %s'reset ()'%s succeeded%s\n",
+            prefix.c_str (), tout.log_code (), tout.emph_code (), level,
+            tout.log_code (), tout.api_code (), tout.log_code (),
+            tout.normal_code ());
+    fflush (stdout);
+  }
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+int Solver::vars () {
+  TRACE ("vars");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  int res = external->max_var;
+  LOG_API_CALL_RETURNS ("vars", res);
+  return res;
+}
+
+void Solver::reserve (int min_max_var) {
+  TRACE ("reserve", min_max_var);
+  REQUIRE_VALID_STATE ();
+  transition_to_steady_state ();
+  external->reset_extended ();
+  external->init (min_max_var);
+  LOG_API_CALL_END ("reserve", min_max_var);
+}
+
+int Solver::reserve_difference (int number_of_vars) {
+  TRACE ("reserve_difference", number_of_vars);
+  REQUIRE_VALID_STATE ();
+  transition_to_steady_state ();
+  external->reset_extended ();
+  int new_max_var = external->max_var + number_of_vars;
+  external->init (new_max_var);
+  LOG_API_CALL_END ("reserve_difference", number_of_vars);
+  return new_max_var;
+}
+
+/*------------------------------------------------------------------------*/
+#ifndef CADICAL_NTRACING
+
+void Solver::trace_api_calls (FILE *file) {
+  LOG_API_CALL_BEGIN ("trace_api_calls");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (file != 0, "invalid zero file argument");
+  REQUIRE (!tracing_api_calls_through_environment_variable_method,
+           "already tracing API calls "
+           "using environment variable 'CADICAL_API_TRACE'");
+  REQUIRE (!trace_api_file, "called twice");
+  trace_api_file = file;
+  LOG_API_CALL_END ("trace_api_calls");
+  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;
+  return Options::parse_long_option (arg, name, tmp);
+}
+
+int Solver::get (const char *arg) {
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  return internal->opts.get (arg);
+}
+
+bool Solver::set (const char *arg, int val) {
+  TRACE ("set", arg, 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",
+        arg, val);
+  }
+  bool res = internal->opts.set (arg, val);
+  LOG_API_CALL_END ("set", arg, val, res);
+
+  return res;
+}
+
+bool Solver::set_long_option (const char *arg) {
+  LOG_API_CALL_BEGIN ("set", arg);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+           "can only set option '%s' right after initialization", arg);
+  bool res;
+  if (arg[0] != '-' || arg[1] != '-')
+    res = false;
+  else {
+    int val;
+    string name;
+    res = Options::parse_long_option (arg, name, val);
+    if (res)
+      set (name.c_str (), val);
+  }
+  LOG_API_CALL_END ("set", arg, res);
+  return res;
+}
+
+void Solver::optimize (int arg) {
+  LOG_API_CALL_BEGIN ("optimize", arg);
+  REQUIRE_VALID_STATE ();
+  internal->opts.optimize (arg);
+  LOG_API_CALL_END ("optimize", arg);
+}
+
+bool Solver::limit (const char *arg, int val) {
+  TRACE ("limit", arg, val);
+  REQUIRE_VALID_STATE ();
+  bool res = internal->limit (arg, val);
+  LOG_API_CALL_END ("limit", arg, val, res);
+  return res;
+}
+
+bool Solver::is_valid_limit (const char *arg) {
+  return Internal::is_valid_limit (arg);
+}
+
+void Solver::prefix (const char *str) {
+  LOG_API_CALL_BEGIN ("prefix", str);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  internal->prefix = str;
+  LOG_API_CALL_END ("prefix", str);
+}
+
+bool Solver::is_valid_configuration (const char *name) {
+  return Config::has (name);
+}
+
+bool Solver::configure (const char *name) {
+  TRACE ("configure", 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 (internal->opts, name);
+  LOG_API_CALL_END ("configure", name, res);
+  return res;
+}
+
+/*===== IPASIR BEGIN =====================================================*/
+
+void Solver::add (int lit) {
+  TRACE ("add", lit);
+  REQUIRE_VALID_STATE ();
+  if (lit)
+    REQUIRE_VALID_LIT (lit);
+  transition_to_steady_state ();
+  external->add (lit);
+  adding_clause = lit;
+  if (adding_clause)
+    STATE (ADDING);
+  else if (!adding_constraint)
+    STATE (STEADY);
+  LOG_API_CALL_END ("add", lit);
+}
+
+void Solver::clause (int a) {
+  REQUIRE_VALID_LIT (a);
+  add (a), add (0);
+}
+
+void Solver::clause (int a, int b) {
+  REQUIRE_VALID_LIT (a);
+  REQUIRE_VALID_LIT (b);
+  add (a), add (b), add (0);
+}
+
+void Solver::clause (int a, int b, int c) {
+  REQUIRE_VALID_LIT (a);
+  REQUIRE_VALID_LIT (b);
+  REQUIRE_VALID_LIT (c);
+  add (a), add (b), add (c), add (0);
+}
+
+void Solver::clause (int a, int b, int c, int d) {
+  REQUIRE_VALID_LIT (a);
+  REQUIRE_VALID_LIT (b);
+  REQUIRE_VALID_LIT (c);
+  REQUIRE_VALID_LIT (d);
+  add (a), add (b), add (c), add (d), add (0);
+}
+
+void Solver::clause (int a, int b, int c, int d, int e) {
+  REQUIRE_VALID_LIT (a);
+  REQUIRE_VALID_LIT (b);
+  REQUIRE_VALID_LIT (c);
+  REQUIRE_VALID_LIT (d);
+  REQUIRE_VALID_LIT (e);
+  add (a), add (b), add (c), add (d), add (e), add (0);
+}
+
+void Solver::clause (const int *lits, size_t size) {
+  REQUIRE (!size || lits,
+           "first argument 'lits' zero while second argument 'size' not");
+  const int *end = lits + size;
+  for (const int *p = lits; p != end; p++) {
+    const int lit = *p;
+    REQUIRE_VALID_LIT (lit);
+    add (lit);
+  }
+  add (0);
+}
+
+void Solver::clause (const std::vector<int> &lits) {
+  for (auto lit : lits) {
+    REQUIRE_VALID_LIT (lit);
+    add (lit);
+  }
+  add (0);
+}
+
+bool Solver::inconsistent () { return internal->unsat; }
+
+void Solver::constrain (int lit) {
+  TRACE ("constrain", lit);
+  REQUIRE_VALID_STATE ();
+  if (lit)
+    REQUIRE_VALID_LIT (lit);
+  transition_to_steady_state ();
+  external->constrain (lit);
+  adding_constraint = lit;
+  if (adding_constraint)
+    STATE (ADDING);
+  else if (!adding_clause)
+    STATE (STEADY);
+  LOG_API_CALL_END ("constrain", lit);
+}
+
+void Solver::assume (int lit) {
+  TRACE ("assume", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  transition_to_steady_state ();
+  external->assume (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, int min_depth) {
+  TRACE ("lookahead_cubes");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  auto cubes = external->generate_cubes (depth, min_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_steady_state ();
+  external->reset_assumptions ();
+  external->reset_concluded ();
+  LOG_API_CALL_END ("reset_assumptions");
+}
+
+void Solver::reset_constraint () {
+  TRACE ("reset_constraint");
+  REQUIRE_VALID_STATE ();
+  transition_to_steady_state ();
+  external->reset_constraint ();
+  external->reset_concluded ();
+  LOG_API_CALL_END ("reset_constraint");
+}
+
+/*------------------------------------------------------------------------*/
+
+int Solver::propagate () {
+  TRACE ("propagate_assumptions");
+  REQUIRE_VALID_STATE ();
+  transition_to_steady_state ();
+  const int res = external->propagate_assumptions ();
+  if (tracing_nb_lidrup_env_var_method)
+    flush_proof_trace (true);
+  LOG_API_CALL_RETURNS ("propagate_assumptions", res);
+  if (res == 10)
+    STATE (SATISFIED);
+  else if (res == 20)
+    STATE (UNSATISFIED);
+  else
+    STATE (INCONCLUSIVE);
+  return res;
+}
+
+void Solver::implied (std::vector<int> &entrailed) {
+  TRACE ("implied");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == INCONCLUSIVE,
+          "can only get implied literals only in unknown state");
+  external->conclude_unknown ();
+  external->implied (entrailed);
+  if (tracing_nb_lidrup_env_var_method)
+    flush_proof_trace (true);
+  LOG_API_CALL_RETURNS ("implied", (int) entrailed.size ());
+}
+
+/*------------------------------------------------------------------------*/
+
+int Solver::call_external_solve_and_check_results (bool preprocess_only) {
+  transition_to_steady_state ();
+  CADICAL_assert (state () & READY);
+  STATE (SOLVING);
+  const int res = external->solve (preprocess_only);
+  if (res == 10)
+    STATE (SATISFIED);
+  else if (res == 20)
+    STATE (UNSATISFIED);
+  else
+    STATE (INCONCLUSIVE);
+#if 0 // EXPENSIVE ALTERNATIVE ASSUMPTION CHECKING
+  // This checks that the set of failed assumptions form a core using the
+  // external 'copy (...)' function to copy the solver, which can be trusted
+  // less, since it involves copying the extension stack too.  The
+  // 'External::check_assumptions_failing' is a better alternative and can
+  // be enabled by options too.  We keep this code though to have an
+  // alternative failed assumption checking available for debugging.
+  //
+  if (res == 20 && !external->assumptions.empty ()) {
+    Solver checker;
+    // checking restored clauses does not work (because the clauses are not added)
+    checker.set("checkproof", 1);
+    checker.set("lrat", 0);
+    checker.prefix ("checker ");
+    copy (checker);
+    checker.set("log", 1);
+    for (const auto & lit : external->assumptions)
+      if (failed (lit))
+        checker.add (lit), checker.add (0);
+    if (checker.solve () != 20)
+      FATAL ("copying assumption checker failed");
+  }
+#endif
+  if (!res) {
+    external->reset_assumptions ();
+    external->reset_constraint ();
+    external->reset_concluded ();
+  }
+  return res;
+}
+
+int Solver::solve () {
+  TRACE ("solve");
+  REQUIRE_READY_STATE ();
+  const int res = call_external_solve_and_check_results (false);
+  LOG_API_CALL_RETURNS ("solve", res);
+  if (tracing_nb_lidrup_env_var_method)
+    flush_proof_trace (true);
+  return res;
+}
+
+int Solver::simplify (int rounds) {
+  TRACE ("simplify", rounds);
+  REQUIRE_READY_STATE ();
+  REQUIRE (rounds >= 0, "negative number of simplification rounds '%d'",
+           rounds);
+  internal->limit ("preprocessing", rounds);
+  const int res = call_external_solve_and_check_results (true);
+  LOG_API_CALL_RETURNS ("simplify", rounds, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+int Solver::val (int lit) {
+  TRACE ("val", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  REQUIRE (state () == SATISFIED, "can only get value in satisfied state");
+  if (!external->extended)
+    external->extend ();
+  external->conclude_sat ();
+  int res = external->ival (lit);
+  LOG_API_CALL_RETURNS ("val", lit, res);
+  CADICAL_assert (state () == SATISFIED);
+  CADICAL_assert (res == lit || res == -lit);
+  return res;
+}
+
+bool Solver::flip (int lit) {
+  TRACE ("flip", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  REQUIRE (state () == SATISFIED, "can only flip value in satisfied state");
+  REQUIRE (!external->propagator,
+           "can only flip when no external propagator is present");
+  bool res = external->flip (lit);
+  LOG_API_CALL_RETURNS ("flip", lit, res);
+  CADICAL_assert (state () == SATISFIED);
+  return res;
+}
+
+bool Solver::flippable (int lit) {
+  TRACE ("flippable", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  REQUIRE (state () == SATISFIED, "can only flip value in satisfied state");
+  REQUIRE (!external->propagator,
+           "can only flip when no external propagator is present");
+  bool res = external->flippable (lit);
+  LOG_API_CALL_RETURNS ("flippable", lit, res);
+  CADICAL_assert (state () == SATISFIED);
+  return res;
+}
+
+bool Solver::failed (int lit) {
+  TRACE ("failed", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  REQUIRE (state () == UNSATISFIED,
+           "can only get failed assumptions in unsatisfied state");
+  bool res = external->failed (lit);
+  LOG_API_CALL_RETURNS ("failed", lit, res);
+  CADICAL_assert (state () == UNSATISFIED);
+  return res;
+}
+
+bool Solver::constraint_failed () {
+  TRACE ("constraint_failed");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == UNSATISFIED,
+           "can only determine if constraint failed in unsatisfied state");
+  bool res = external->failed_constraint ();
+  LOG_API_CALL_RETURNS ("constraint_failed", res);
+  CADICAL_assert (state () == UNSATISFIED);
+  return res;
+}
+
+int Solver::fixed (int lit) const {
+  TRACE ("fixed", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  int res = external->fixed (lit);
+  LOG_API_CALL_RETURNS ("fixed", lit, res);
+  return res;
+}
+
+void Solver::phase (int lit) {
+  TRACE ("phase", lit);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  external->phase (lit);
+  LOG_API_CALL_END ("phase", lit);
+}
+
+void Solver::unphase (int lit) {
+  TRACE ("unphase", lit);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  external->unphase (lit);
+  LOG_API_CALL_END ("unphase", lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::terminate () {
+  LOG_API_CALL_BEGIN ("terminate");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  external->terminate ();
+  LOG_API_CALL_END ("terminate");
+}
+
+void Solver::connect_terminator (Terminator *terminator) {
+  LOG_API_CALL_BEGIN ("connect_terminator");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (terminator, "can not connect zero terminator");
+#ifdef LOGGING
+  if (external->terminator)
+    LOG ("connecting new terminator (disconnecting previous one)");
+  else
+    LOG ("connecting new terminator (no previous one)");
+#endif
+  external->terminator = terminator;
+  LOG_API_CALL_END ("connect_terminator");
+}
+
+void Solver::disconnect_terminator () {
+  LOG_API_CALL_BEGIN ("disconnect_terminator");
+  REQUIRE_VALID_STATE ();
+#ifdef LOGGING
+  if (external->terminator)
+    LOG ("disconnecting previous terminator");
+  else
+    LOG ("ignoring to disconnect terminator (no previous one)");
+#endif
+  external->terminator = 0;
+  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 =======================================================*/
+
+void Solver::connect_fixed_listener (
+    FixedAssignmentListener *fixed_listener) {
+  LOG_API_CALL_BEGIN ("connect_fixed_listener");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (fixed_listener, "can not connect zero fixed listener");
+
+#ifdef LOGGING
+  if (external->fixed_listener)
+    LOG ("connecting new listener of fixed assignments (disconnecting "
+         "previous one)");
+  else
+    LOG ("connecting new listener of fixed assigments (no previous one)");
+#endif
+  if (external->fixed_listener)
+    disconnect_fixed_listener ();
+  external->fixed_listener = fixed_listener;
+  // Listeners are treated as real-time listeners, thus previously found
+  // fixed assignments are not sent out (would be rather expensive to
+  // recover it retrospect, see external_propagate.cpp/get_fixed_literals ()
+  // function).
+  LOG_API_CALL_END ("connect_fixed_listener");
+}
+
+void Solver::disconnect_fixed_listener () {
+  LOG_API_CALL_BEGIN ("disconnect_fixed_listener");
+  REQUIRE_VALID_STATE ();
+#ifdef LOGGING
+  if (external->fixed_listener)
+    LOG ("disconnecting previous listener of fixed assignments");
+  else
+    LOG ("ignoring to disconnect listener of fixed assignments (no "
+         "previous one)");
+#endif
+  external->fixed_listener = 0;
+  LOG_API_CALL_END ("disconnect_fixed_listener");
+}
+
+/*===== IPASIR-UP BEGIN ==================================================*/
+
+void Solver::connect_external_propagator (ExternalPropagator *propagator) {
+  LOG_API_CALL_BEGIN ("connect_external_propagator");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (propagator, "can not connect zero propagator");
+#ifdef LOGGING
+  if (external->propagator)
+    LOG ("connecting new external propagator (disconnecting previous one)");
+  else
+    LOG ("connecting new external propagator (no previous one)");
+#endif
+  if (external->propagator)
+    disconnect_external_propagator ();
+
+  external->propagator = propagator;
+  internal->connect_propagator ();
+  internal->external_prop = true;
+  internal->external_prop_is_lazy = propagator->is_lazy;
+  LOG_API_CALL_END ("connect_external_propagator");
+}
+
+void Solver::disconnect_external_propagator () {
+  LOG_API_CALL_BEGIN ("disconnect_external_propagator");
+  REQUIRE_VALID_STATE ();
+
+#ifdef LOGGING
+  if (external->propagator)
+    LOG ("disconnecting previous external propagator");
+  else
+    LOG ("ignoring to disconnect external propagator (no previous one)");
+#endif
+  if (external->propagator)
+    external->reset_observed_vars ();
+
+  external->propagator = 0;
+  internal->set_tainted_literal ();
+  internal->external_prop = false;
+  internal->external_prop_is_lazy = true;
+  LOG_API_CALL_END ("disconnect_external_propagator");
+}
+
+void Solver::add_observed_var (int idx) {
+  TRACE ("observe", idx);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  REQUIRE_VALID_LIT (idx);
+  external->add_observed_var (idx);
+  LOG_API_CALL_END ("observe", idx);
+}
+
+void Solver::remove_observed_var (int idx) {
+  TRACE ("unobserve", idx);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (idx);
+  external->remove_observed_var (idx);
+  LOG_API_CALL_END ("unobserve", idx);
+}
+
+void Solver::reset_observed_vars () {
+  TRACE ("reset_observed_vars");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  external->reset_observed_vars ();
+  LOG_API_CALL_END ("reset_observed_vars");
+}
+
+/*===== IPASIR-UP END ====================================================*/
+
+int Solver::active () const {
+  TRACE ("active");
+  REQUIRE_VALID_STATE ();
+  int res = internal->active ();
+  LOG_API_CALL_RETURNS ("active", res);
+  return res;
+}
+
+int64_t Solver::redundant () const {
+  TRACE ("redundant");
+  REQUIRE_VALID_STATE ();
+  int64_t res = internal->redundant ();
+  LOG_API_CALL_RETURNS ("redundant", res);
+  return res;
+}
+
+int64_t Solver::irredundant () const {
+  TRACE ("irredundant");
+  REQUIRE_VALID_STATE ();
+  int64_t res = internal->irredundant ();
+  LOG_API_CALL_RETURNS ("irredundant", res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::freeze (int lit) {
+  TRACE ("freeze", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  external->freeze (lit);
+  LOG_API_CALL_END ("freeze", lit);
+}
+
+void Solver::melt (int lit) {
+  TRACE ("melt", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  REQUIRE (external->frozen (lit),
+           "can not melt completely melted literal '%d'", lit);
+  external->melt (lit);
+  LOG_API_CALL_END ("melt", lit);
+}
+
+bool Solver::frozen (int lit) const {
+  TRACE ("frozen", lit);
+  REQUIRE_VALID_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  bool res = external->frozen (lit);
+  LOG_API_CALL_RETURNS ("frozen", lit, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Solver::trace_proof (FILE *external_file, const char *name) {
+  TRACE ("trace_proof", name);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (
+      state () == CONFIGURING,
+      "can only start proof tracing to '%s' right after initialization",
+      name);
+  File *internal_file = File::write (internal, external_file, name);
+  CADICAL_assert (internal_file);
+  internal->trace (internal_file);
+  LOG_API_CALL_RETURNS ("trace_proof", name, true);
+  return true;
+}
+
+bool Solver::trace_proof (const char *path) {
+  TRACE ("trace_proof", path);
+  REQUIRE_VALID_STATE ();
+  REQUIRE (
+      state () == CONFIGURING,
+      "can only start proof tracing to '%s' right after initialization",
+      path);
+  File *internal_file = File::write (internal, path);
+  bool res = (internal_file != 0);
+  internal->trace (internal_file);
+  LOG_API_CALL_RETURNS ("trace_proof", path, res);
+  return res;
+}
+
+void Solver::flush_proof_trace (bool print_statistics_unless_quiet) {
+  TRACE ("flush_proof_trace");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (!internal->file_tracers.empty (), "proof is not traced");
+  REQUIRE (!internal->file_tracers.back ()->closed (),
+           "proof trace already closed");
+  internal->flush_trace (print_statistics_unless_quiet);
+  LOG_API_CALL_END ("flush_proof_trace");
+}
+
+void Solver::close_proof_trace (bool print_statistics_unless_quiet) {
+  TRACE ("close_proof_trace");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (!internal->file_tracers.empty (), "proof is not traced");
+  REQUIRE (!internal->file_tracers.back ()->closed (),
+           "proof trace already closed");
+  internal->close_trace (print_statistics_unless_quiet);
+  LOG_API_CALL_END ("close_proof_trace");
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::connect_proof_tracer (Tracer *tracer, bool antecedents,
+                                   bool finalize_clauses) {
+  LOG_API_CALL_BEGIN ("connect proof tracer");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+           "can only start proof tracing to right after initialization");
+  REQUIRE (tracer, "can not connect zero tracer");
+  internal->connect_proof_tracer (tracer, antecedents, finalize_clauses);
+  LOG_API_CALL_END ("connect proof tracer");
+}
+
+void Solver::connect_proof_tracer (InternalTracer *tracer, bool antecedents,
+                                   bool finalize_clauses) {
+  LOG_API_CALL_BEGIN ("connect proof tracer");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+           "can only start proof tracing to right after initialization");
+  REQUIRE (tracer, "can not connect zero tracer");
+  internal->connect_proof_tracer (tracer, antecedents, finalize_clauses);
+  LOG_API_CALL_END ("connect proof tracer");
+}
+
+void Solver::connect_proof_tracer (StatTracer *tracer, bool antecedents,
+                                   bool finalize_clauses) {
+  LOG_API_CALL_BEGIN ("connect proof tracer with stats");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+           "can only start proof tracing to right after initialization");
+  REQUIRE (tracer, "can not connect zero tracer");
+  internal->connect_proof_tracer (tracer, antecedents, finalize_clauses);
+  LOG_API_CALL_END ("connect proof tracer with stats");
+}
+
+void Solver::connect_proof_tracer (FileTracer *tracer, bool antecedents,
+                                   bool finalize_clauses) {
+  LOG_API_CALL_BEGIN ("connect proof tracer with file");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == CONFIGURING,
+           "can only start proof tracing right after initialization");
+  REQUIRE (tracer, "can not connect zero tracer");
+  internal->connect_proof_tracer (tracer, antecedents, finalize_clauses);
+  LOG_API_CALL_END ("connect proof tracer with file");
+}
+
+bool Solver::disconnect_proof_tracer (Tracer *tracer) {
+  LOG_API_CALL_BEGIN ("disconnect proof tracer");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (tracer, "can not disconnect zero tracer");
+  bool res = internal->disconnect_proof_tracer (tracer);
+  LOG_API_CALL_RETURNS ("connect proof tracer", res);
+  return res;
+}
+
+bool Solver::disconnect_proof_tracer (StatTracer *tracer) {
+  LOG_API_CALL_BEGIN ("disconnect proof tracer");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (tracer, "can not disconnect zero tracer");
+  bool res = internal->disconnect_proof_tracer (tracer);
+  LOG_API_CALL_RETURNS ("disconnect proof tracer", res);
+  return res;
+}
+
+bool Solver::disconnect_proof_tracer (FileTracer *tracer) {
+  LOG_API_CALL_BEGIN ("disconnect proof tracer");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (tracer, "can not disconnect zero tracer");
+  bool res = internal->disconnect_proof_tracer (tracer);
+  LOG_API_CALL_RETURNS ("disconnect proof tracer", res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::conclude () {
+  TRACE ("conclude");
+  REQUIRE_VALID_STATE ();
+  REQUIRE (state () == UNSATISFIED || state () == SATISFIED ||
+               state () == INCONCLUSIVE,
+           "can only conclude in satisfied, unsatisfied or inconclusive state");
+  if (state () == UNSATISFIED)
+    internal->conclude_unsat ();
+  else if (state () == SATISFIED)
+    external->conclude_sat ();
+  else if (state () == INCONCLUSIVE)
+    external->conclude_unknown ();
+  CADICAL_assert (state () == UNSATISFIED || state () == SATISFIED ||
+          state () == INCONCLUSIVE);
+  LOG_API_CALL_END ("conclude");
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::build (FILE *file, const char *prefix) {
+
+  CADICAL_assert (file == stdout || file == stderr);
+
+  Terminal *terminal;
+
+  if (file == stdout)
+    terminal = &tout;
+  else if (file == stderr)
+    terminal = &terr;
+  else
+    terminal = 0;
+
+  const char *v = CaDiCaL::version ();
+  const char *i = identifier ();
+  const char *c = compiler ();
+  const char *b = date ();
+  const char *f = flags ();
+
+  CADICAL_assert (v);
+
+  fputs (prefix, file);
+  if (terminal)
+    terminal->magenta ();
+  fputs ("Version ", file);
+  if (terminal)
+    terminal->normal ();
+  fputs (v, file);
+  if (i) {
+    if (terminal)
+      terminal->magenta ();
+    fputc (' ', file);
+    fputs (i, file);
+    if (terminal)
+      terminal->normal ();
+  }
+  fputc ('\n', file);
+
+  if (c) {
+    fputs (prefix, file);
+    if (terminal)
+      terminal->magenta ();
+    fputs (c, file);
+    if (f) {
+      fputc (' ', file);
+      fputs (f, file);
+    }
+    if (terminal)
+      terminal->normal ();
+    fputc ('\n', file);
+  }
+
+  if (b) {
+    fputs (prefix, file);
+    if (terminal)
+      terminal->magenta ();
+    fputs (b, file);
+    if (terminal)
+      terminal->normal ();
+    fputc ('\n', file);
+  }
+
+  fflush (file);
+}
+
+const char *Solver::version () { return CaDiCaL::version (); }
+
+const char *Solver::signature () { return CaDiCaL::signature (); }
+
+void Solver::options () {
+  REQUIRE_VALID_STATE ();
+  internal->opts.print ();
+}
+
+void Solver::usage () { Options::usage (); }
+
+void Solver::configurations () { Config::usage (); }
+
+void Solver::statistics () {
+  if (state () == DELETING)
+    return;
+  TRACE ("stats");
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  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,
+                                 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, incremental, cubes);
+  const char *err = parser->parse_dimacs (vars, strict);
+  delete parser;
+  return err;
+}
+
+const char *Solver::read_dimacs (FILE *external_file, const char *name,
+                                 int &vars, int strict) {
+  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);
+  CADICAL_assert (file);
+  const char *err = read_dimacs (file, vars, strict);
+  delete file;
+  LOG_API_CALL_RETURNS ("read_dimacs", name, err);
+  return err;
+}
+
+const char *Solver::read_dimacs (const char *path, int &vars, int strict) {
+  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);
+  delete file;
+  LOG_API_CALL_RETURNS ("read_dimacs", path, err);
+  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);
+  CADICAL_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, 0, 0);
+  const char *err = parser->parse_solution ();
+  delete parser;
+  delete file;
+  if (!err)
+    external->check_assignment (&External::sol);
+  LOG_API_CALL_RETURNS ("read_solution", path, err);
+  return err;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::dump_cnf () {
+  TRACE ("dump");
+  REQUIRE_INITIALIZED ();
+  internal->dump ();
+  LOG_API_CALL_END ("dump");
+}
+
+/*------------------------------------------------------------------------*/
+
+ExternalPropagator *Solver::get_propagator () {
+  return external->propagator;
+}
+
+bool Solver::observed (int lit) {
+  TRACE ("observed", lit);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  bool res = external->observed (lit);
+  LOG_API_CALL_RETURNS ("observed", lit, res);
+  return res;
+}
+
+bool Solver::is_witness (int lit) {
+  TRACE ("is_witness", lit);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  bool res = external->is_witness (lit);
+  LOG_API_CALL_RETURNS ("is_witness", lit, res);
+  return res;
+}
+
+bool Solver::is_decision (int lit) {
+  TRACE ("is_decision", lit);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  REQUIRE_VALID_LIT (lit);
+  bool res = external->is_decision (lit);
+  LOG_API_CALL_RETURNS ("is_decision", lit, res);
+  return res;
+}
+
+void Solver::force_backtrack (size_t new_level) {
+  TRACE ("force_backtrack", new_level);
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+  external->force_backtrack (new_level);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Solver::traverse_clauses (ClauseIterator &it) const {
+  LOG_API_CALL_BEGIN ("traverse_clauses");
+  REQUIRE_VALID_STATE ();
+  bool res = external->traverse_all_frozen_units_as_clauses (it) &&
+             internal->traverse_clauses (it) &&
+             internal->traverse_constraint (it);
+  LOG_API_CALL_RETURNS ("traverse_clauses", res);
+  return res;
+}
+
+bool Solver::traverse_witnesses_backward (WitnessIterator &it) const {
+  LOG_API_CALL_BEGIN ("traverse_witnesses_backward");
+  REQUIRE_VALID_STATE ();
+  bool res = external->traverse_all_non_frozen_units_as_witnesses (it) &&
+             external->traverse_witnesses_backward (it);
+  LOG_API_CALL_RETURNS ("traverse_witnesses_backward", res);
+  return res;
+}
+
+bool Solver::traverse_witnesses_forward (WitnessIterator &it) const {
+  LOG_API_CALL_BEGIN ("traverse_witnesses_forward");
+  REQUIRE_VALID_STATE ();
+  bool res = external->traverse_witnesses_forward (it) &&
+             external->traverse_all_non_frozen_units_as_witnesses (it);
+  LOG_API_CALL_RETURNS ("traverse_witnesses_forward", res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+class ClauseCounter : public ClauseIterator {
+public:
+  int vars;
+  int64_t clauses;
+  ClauseCounter () : vars (0), clauses (0) {}
+  bool clause (const vector<int> &c) {
+    for (const auto &lit : c) {
+      CADICAL_assert (lit != INT_MIN);
+      int idx = abs (lit);
+      if (idx > vars)
+        vars = idx;
+    }
+    clauses++;
+    return true;
+  }
+};
+
+class ClauseWriter : public ClauseIterator {
+  File *file;
+
+public:
+  ClauseWriter (File *f) : file (f) {}
+  bool clause (const vector<int> &c) {
+    for (const auto &lit : c) {
+      if (!file->put (lit))
+        return false;
+      if (!file->put (' '))
+        return false;
+    }
+    return file->put ("0\n");
+  }
+};
+
+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 CADICAL_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);
+  File *file = File::write (internal, path);
+  const char *res = 0;
+  if (file) {
+    int actual_max_vars = max (min_max_var, counter.vars);
+    MSG ("writing %s'p cnf %d %" PRId64 "'%s header", tout.green_code (),
+         actual_max_vars, counter.clauses, tout.normal_code ());
+    file->put ("p cnf ");
+    file->put (actual_max_vars);
+    file->put (' ');
+    file->put (counter.clauses);
+    file->put ('\n');
+    ClauseWriter writer (file);
+    if (!traverse_clauses (writer))
+      res = internal->error_message.init (
+          "writing to DIMACS file '%s' failed", path);
+    delete file;
+  } else
+    res = internal->error_message.init (
+        "failed to open DIMACS file '%s' for writing", path);
+#ifndef CADICAL_QUIET
+  if (!res) {
+    const double end = internal->time ();
+    MSG ("wrote %" PRId64 " clauses in %.2f seconds %s time",
+         counter.clauses, end - start,
+         internal->opts.realtime ? "real" : "process");
+  }
+#endif
+  LOG_API_CALL_RETURNS ("write_dimacs", path, min_max_var, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+struct WitnessWriter : public WitnessIterator {
+  File *file;
+  int64_t witnesses;
+  WitnessWriter (File *f) : file (f), witnesses (0) {}
+  bool write (const vector<int> &a) {
+    for (const auto &lit : a) {
+      if (!file->put (lit))
+        return false;
+      if (!file->put (' '))
+        return false;
+    }
+    return file->put ('0');
+  }
+  bool witness (const vector<int> &c, const vector<int> &w, int64_t) {
+    if (!write (c))
+      return false;
+    if (!file->put (' '))
+      return false;
+    if (!write (w))
+      return false;
+    if (!file->put ('\n'))
+      return false;
+    witnesses++;
+    return true;
+  }
+};
+
+const char *Solver::write_extension (const char *path) {
+  LOG_API_CALL_BEGIN ("write_extension", path);
+  REQUIRE_VALID_STATE ();
+  const char *res = 0;
+#ifndef CADICAL_QUIET
+  const double start = internal->time ();
+#endif
+  File *file = File::write (internal, path);
+  WitnessWriter writer (file);
+  if (file) {
+    if (!traverse_witnesses_backward (writer))
+      res = internal->error_message.init (
+          "writing to DIMACS file '%s' failed", path);
+    delete file;
+  } else
+    res = internal->error_message.init (
+        "failed to open extension file '%s' for writing", path);
+#ifndef CADICAL_QUIET
+  if (!res) {
+    const double end = internal->time ();
+    MSG ("wrote %" PRId64 " witnesses in %.2f seconds %s time",
+         writer.witnesses, end - start,
+         internal->opts.realtime ? "real" : "process");
+  }
+#endif
+  LOG_API_CALL_RETURNS ("write_extension", path, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+struct ClauseCopier : public ClauseIterator {
+  Solver &dst;
+
+public:
+  ClauseCopier (Solver &d) : dst (d) {}
+  bool clause (const vector<int> &c) {
+    for (const auto &lit : c)
+      dst.add (lit);
+    dst.add (0);
+    return true;
+  }
+};
+
+struct WitnessCopier : public WitnessIterator {
+  External *dst;
+
+public:
+  WitnessCopier (External *d) : dst (d) {}
+  bool witness (const vector<int> &c, const vector<int> &w, int64_t id) {
+    dst->push_external_clause_and_witness_on_extension_stack (c, w, id);
+    return true;
+  }
+};
+
+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);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Solver::section (const char *title) {
+  if (state () == DELETING)
+    return;
+#ifdef CADICAL_QUIET
+  (void) title;
+#endif
+  REQUIRE_INITIALIZED ();
+  SECTION (title);
+}
+
+void Solver::message (const char *fmt, ...) {
+  if (state () == DELETING)
+    return;
+#ifdef CADICAL_QUIET
+  (void) fmt;
+#else
+  REQUIRE_INITIALIZED ();
+  va_list ap;
+  va_start (ap, fmt);
+  internal->vmessage (fmt, ap);
+  va_end (ap);
+#endif
+}
+
+void Solver::message () {
+  if (state () == DELETING)
+    return;
+  REQUIRE_INITIALIZED ();
+#ifndef CADICAL_QUIET
+  internal->message ();
+#endif
+}
+
+void Solver::verbose (int level, const char *fmt, ...) {
+  if (state () == DELETING)
+    return;
+  REQUIRE_VALID_OR_SOLVING_STATE ();
+#ifdef CADICAL_QUIET
+  (void) level;
+  (void) fmt;
+#else
+  va_list ap;
+  va_start (ap, fmt);
+  internal->vverbose (level, fmt, ap);
+  va_end (ap);
+#endif
+}
+
+void Solver::error (const char *fmt, ...) {
+  if (state () == DELETING)
+    return;
+  REQUIRE_INITIALIZED ();
+  va_list ap;
+  va_start (ap, fmt);
+  internal->verror (fmt, ap);
+  va_end (ap);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_stable.cpp b/src/sat/cadical/cadical_stable.cpp
new file mode 100644
index 000000000..f177139ac
--- /dev/null
+++ b/src/sat/cadical/cadical_stable.cpp
@@ -0,0 +1,39 @@
+#include "global.h"
+
+#ifdef PROFILE_MODE
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+bool Internal::propagate_stable () {
+  CADICAL_assert (stable);
+  START (propstable);
+  bool res = propagate ();
+  STOP (propstable);
+  return res;
+}
+
+void Internal::analyze_stable () {
+  CADICAL_assert (stable);
+  START (analyzestable);
+  analyze ();
+  STOP (analyzestable);
+}
+
+int Internal::decide_stable () {
+  CADICAL_assert (stable);
+  return decide ();
+}
+
+}; // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+#else
+ABC_NAMESPACE_IMPL_START
+int stable_if_not_profile_mode_dummy;
+ABC_NAMESPACE_IMPL_END
+#endif
diff --git a/src/sat/cadical/cadical_stats.cpp b/src/sat/cadical/cadical_stats.cpp
new file mode 100644
index 000000000..8b07745d6
--- /dev/null
+++ b/src/sat/cadical/cadical_stats.cpp
@@ -0,0 +1,826 @@
+// vim: set tw=300: set VIM text width to 300 characters for this file.
+#include "global.h"
+
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+Stats::Stats () {
+  time.real = absolute_real_time ();
+  time.process = absolute_process_time ();
+  walk.minimum = LONG_MAX;
+  used.resize (2);
+  used[0].resize (127);
+  used[1].resize (127);
+}
+
+/*------------------------------------------------------------------------*/
+
+#define PRT(FMT, ...) \
+  do { \
+    if (FMT[0] == ' ' && !all) \
+      break; \
+    MSG (FMT, __VA_ARGS__); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+
+void Stats::print (Internal *internal) {
+
+#ifdef CADICAL_QUIET
+  (void) internal;
+#else
+
+  Stats &stats = internal->stats;
+
+  int all = internal->opts.verbose > 0 || internal->opts.stats;
+#ifdef LOGGING
+  if (internal->opts.log)
+    all = true;
+#endif // ifdef LOGGING
+
+  if (internal->opts.profile)
+    internal->print_profile ();
+
+  double t = internal->solve_time ();
+
+  int64_t propagations = 0;
+  propagations += stats.propagations.cover;
+  propagations += stats.propagations.probe;
+  propagations += stats.propagations.search;
+  propagations += stats.propagations.transred;
+  propagations += stats.propagations.vivify;
+  propagations += stats.propagations.walk;
+
+  int64_t vivified = stats.vivifysubs + stats.vivifystrs;
+  int64_t searchticks = stats.ticks.search[0] + stats.ticks.search[1];
+  int64_t inprobeticks = stats.ticks.vivify + stats.ticks.probe +
+                         stats.ticks.factor + stats.ticks.ternary +
+                         stats.ticks.sweep;
+  int64_t totalticks = searchticks + inprobeticks;
+
+  size_t extendbytes = internal->external->extension.size ();
+  extendbytes *= sizeof (int);
+
+  SECTION ("statistics");
+
+  if (all || stats.blocked) {
+    PRT ("blocked:         %15" PRId64
+         "   %10.2f %%  of irredundant clauses",
+         stats.blocked, percent (stats.blocked, stats.added.irredundant));
+    PRT ("  blockings:     %15" PRId64 "   %10.2f    internal",
+         stats.blockings, relative (stats.conflicts, stats.blockings));
+    PRT ("  candidates:    %15" PRId64 "   %10.2f    per blocking ",
+         stats.blockcands, relative (stats.blockcands, stats.blockings));
+    PRT ("  blockres:      %15" PRId64 "   %10.2f    per candidate",
+         stats.blockres, relative (stats.blockres, stats.blockcands));
+    PRT ("  pure:          %15" PRId64 "   %10.2f %%  of all variables",
+         stats.all.pure, percent (stats.all.pure, stats.vars));
+    PRT ("  pureclauses:   %15" PRId64 "   %10.2f    per pure literal",
+         stats.blockpured, relative (stats.blockpured, stats.all.pure));
+  }
+  if (all || stats.chrono)
+    PRT ("chronological:   %15" PRId64 "   %10.2f %%  of conflicts",
+         stats.chrono, percent (stats.chrono, stats.conflicts));
+  if (all)
+    PRT ("compacts:        %15" PRId64 "   %10.2f    interval",
+         stats.compacts, relative (stats.conflicts, stats.compacts));
+  if (all || stats.conflicts) {
+    PRT ("conflicts:       %15" PRId64 "   %10.2f    per second",
+         stats.conflicts, relative (stats.conflicts, t));
+    PRT ("  backtracked:   %15" PRId64 "   %10.2f %%  of conflicts",
+         stats.backtracks, percent (stats.backtracks, stats.conflicts));
+  }
+  if (all || stats.conditioned) {
+    PRT ("conditioned:     %15" PRId64
+         "   %10.2f %%  of irredundant clauses",
+         stats.conditioned,
+         percent (stats.conditioned, stats.added.irredundant));
+    PRT ("  conditionings: %15" PRId64 "   %10.2f    interval",
+         stats.conditionings,
+         relative (stats.conflicts, stats.conditionings));
+    PRT ("  condcands:     %15" PRId64 "   %10.2f    candidate clauses",
+         stats.condcands, relative (stats.condcands, stats.conditionings));
+    PRT ("  condassinit:   %17.1f  %9.2f %%  initial assigned",
+         relative (stats.condassinit, stats.conditionings),
+         percent (stats.condassinit, stats.condassvars));
+    PRT ("  condcondinit:  %17.1f  %9.2f %%  initial condition",
+         relative (stats.condcondinit, stats.conditionings),
+         percent (stats.condcondinit, stats.condassinit));
+    PRT ("  condautinit:   %17.1f  %9.2f %%  initial autarky",
+         relative (stats.condautinit, stats.conditionings),
+         percent (stats.condautinit, stats.condassinit));
+    PRT ("  condassrem:    %17.1f  %9.2f %%  final assigned",
+         relative (stats.condassrem, stats.conditioned),
+         percent (stats.condassrem, stats.condassirem));
+    PRT ("  condcondrem:   %19.3f  %7.2f %%  final conditional",
+         relative (stats.condcondrem, stats.conditioned),
+         percent (stats.condcondrem, stats.condassrem));
+    PRT ("  condautrem:    %19.3f  %7.2f %%  final autarky",
+         relative (stats.condautrem, stats.conditioned),
+         percent (stats.condautrem, stats.condassrem));
+    PRT ("  condprops:     %15" PRId64 "   %10.2f    per candidate",
+         stats.condprops, relative (stats.condprops, stats.condcands));
+  }
+  if (all || stats.cover.total) {
+    PRT ("covered:         %15" PRId64
+         "   %10.2f %%  of irredundant clauses",
+         stats.cover.total,
+         percent (stats.cover.total, stats.added.irredundant));
+    PRT ("  coverings:     %15" PRId64 "   %10.2f    interval",
+         stats.cover.count, relative (stats.conflicts, stats.cover.count));
+    PRT ("  asymmetric:    %15" PRId64 "   %10.2f %%  of covered clauses",
+         stats.cover.asymmetric,
+         percent (stats.cover.asymmetric, stats.cover.total));
+    PRT ("  blocked:       %15" PRId64 "   %10.2f %%  of covered clauses",
+         stats.cover.blocked,
+         percent (stats.cover.blocked, stats.cover.total));
+  }
+  if (all || stats.decisions) {
+    PRT ("decisions:       %15" PRId64 "   %10.2f    per second",
+         stats.decisions, relative (stats.decisions, t));
+    PRT ("  searched:      %15" PRId64 "   %10.2f    per decision",
+         stats.searched, relative (stats.searched, stats.decisions));
+  }
+  if (all || stats.all.eliminated) {
+    PRT ("eliminated:      %15" PRId64 "   %10.2f %%  of all variables",
+         stats.all.eliminated, percent (stats.all.eliminated, stats.vars));
+    PRT ("  fastelim:      %15" PRId64 "   %10.2f %%  of eliminated",
+         stats.all.fasteliminated,
+         percent (stats.all.fasteliminated, stats.all.eliminated));
+    PRT ("  elimphases:    %15" PRId64 "   %10.2f    interval",
+         stats.elimphases, relative (stats.conflicts, stats.elimphases));
+    PRT ("  elimrounds:    %15" PRId64 "   %10.2f    per phase",
+         stats.elimrounds, relative (stats.elimrounds, stats.elimphases));
+    PRT ("  elimtried:     %15" PRId64 "   %10.2f %%  eliminated",
+         stats.elimtried, percent (stats.all.eliminated, stats.elimtried));
+    PRT ("  elimgates:     %15" PRId64 "   %10.2f %%  gates per tried",
+         stats.elimgates, percent (stats.elimgates, stats.elimtried));
+    PRT ("  elimequivs:    %15" PRId64 "   %10.2f %%  equivalence gates",
+         stats.elimequivs, percent (stats.elimequivs, stats.elimgates));
+    PRT ("  elimands:      %15" PRId64 "   %10.2f %%  and gates",
+         stats.elimands, percent (stats.elimands, stats.elimgates));
+    PRT ("  elimites:      %15" PRId64 "   %10.2f %%  if-then-else gates",
+         stats.elimites, percent (stats.elimites, stats.elimgates));
+    PRT ("  elimxors:      %15" PRId64 "   %10.2f %%  xor gates",
+         stats.elimxors, percent (stats.elimxors, stats.elimgates));
+    PRT ("  elimdefs:      %15" PRId64 "   %10.2f %%  definitions",
+         stats.definitions_extracted,
+         percent (stats.definitions_extracted, stats.elimgates));
+    PRT ("  elimsubst:     %15" PRId64 "   %10.2f %%  substituted",
+         stats.elimsubst, percent (stats.elimsubst, stats.all.eliminated));
+    PRT ("  elimsubstequi: %15" PRId64 "   %10.2f %%  equivalence gates",
+         stats.eliminated_equi,
+         percent (stats.eliminated_equi, stats.elimsubst));
+    PRT ("  elimsubstands: %15" PRId64 "   %10.2f %%  and gates",
+         stats.eliminated_and,
+         percent (stats.eliminated_and, stats.elimsubst));
+    PRT ("  elimsubstites: %15" PRId64 "   %10.2f %%  if-then-else gates",
+         stats.eliminated_ite,
+         percent (stats.eliminated_ite, stats.elimsubst));
+    PRT ("  elimsubstxors: %15" PRId64 "   %10.2f %%  xor gates",
+         stats.eliminated_xor,
+         percent (stats.eliminated_xor, stats.elimsubst));
+    PRT ("  elimsubstdefs: %15" PRId64 "   %10.2f %%  definitions",
+         stats.eliminated_def,
+         percent (stats.eliminated_def, stats.elimsubst));
+    PRT ("  elimres:       %15" PRId64 "   %10.2f    per eliminated",
+         stats.elimres, relative (stats.elimres, stats.all.eliminated));
+    PRT ("  elimrestried:  %15" PRId64 "   %10.2f %%  per resolution",
+         stats.elimrestried, percent (stats.elimrestried, stats.elimres));
+    PRT ("  def checked:   %15" PRId64 "   %10.2f    per phase",
+         stats.definitions_checked,
+         relative (stats.definitions_checked, stats.elimphases));
+    PRT ("  def extracted: %15" PRId64 "   %10.2f %%  per checked",
+         stats.definitions_extracted,
+         percent (stats.definitions_extracted, stats.definitions_checked));
+    PRT ("  def units:     %15" PRId64 "   %10.2f %%  per checked",
+         stats.definition_units,
+         percent (stats.definition_units, stats.definitions_checked));
+  }
+  if (all || stats.ext_prop.ext_cb) {
+    PRT ("ext.prop. calls: %15" PRId64 "   %10.2f %%  of queries",
+         stats.ext_prop.eprop_call,
+         percent (stats.ext_prop.eprop_call, stats.ext_prop.ext_cb));
+    PRT ("  propagating:   %15" PRId64 "   %10.2f %%  per eprop-call",
+         stats.ext_prop.eprop_prop,
+         percent (stats.ext_prop.eprop_prop, stats.ext_prop.eprop_call));
+    PRT ("  explained:     %15" PRId64 "   %10.2f %%  per eprop-call",
+         stats.ext_prop.eprop_expl,
+         percent (stats.ext_prop.eprop_expl, stats.ext_prop.eprop_call));
+    PRT ("  falsified:     %15" PRId64 "   %10.2f %%  per eprop-call",
+         stats.ext_prop.eprop_conf,
+         percent (stats.ext_prop.eprop_conf, stats.ext_prop.eprop_call));
+    PRT ("ext.clause calls:%15" PRId64 "   %10.2f %%  of queries",
+         stats.ext_prop.elearn_call,
+         percent (stats.ext_prop.elearn_call, stats.ext_prop.ext_cb));
+    PRT ("  learned:       %15" PRId64 "   %10.2f %%  per called",
+         stats.ext_prop.elearned,
+         percent (stats.ext_prop.elearned, stats.ext_prop.elearn_call));
+    PRT ("  conflicting:   %15" PRId64 "   %10.2f %%  per learned",
+         stats.ext_prop.elearn_conf,
+         percent (stats.ext_prop.elearn_conf, stats.ext_prop.elearned));
+    PRT ("  propagating:   %15" PRId64 "   %10.2f %%  per learned",
+         stats.ext_prop.elearn_prop,
+         percent (stats.ext_prop.elearn_prop, stats.ext_prop.elearned));
+    PRT ("ext.final check: %15" PRId64 "   %10.2f %%  of queries",
+         stats.ext_prop.echeck_call,
+         percent (stats.ext_prop.echeck_call, stats.ext_prop.ext_cb));
+  }
+  if (all || stats.factored) {
+    PRT ("factored:        %15" PRId64 "   %10.2f %%  of variables",
+         stats.factored, percent (stats.factored, internal->max_var));
+    PRT ("  factor:        %15" PRId64 "   %10.2f    conflict interval",
+         stats.factor, relative (stats.conflicts, stats.factor));
+    PRT ("  cls factored:  %15" PRId64 "   %10.2f    per factored",
+         stats.factor_added, relative (stats.factor_added, factored));
+    PRT ("  lits factored: %15" PRId64 "   %10.2f    per factored",
+         stats.literals_factored,
+         relative (stats.literals_factored, factored));
+    PRT ("  cls unfactored:%15" PRId64 "   %10.2f    per factored",
+         stats.clauses_unfactored,
+         relative (stats.clauses_unfactored, factored));
+    PRT ("  lits unfactored:%14" PRId64 "   %10.2f    per factored",
+         stats.literals_unfactored,
+         relative (stats.literals_unfactored, factored));
+  }
+  if (all || stats.all.fixed) {
+    PRT ("fixed:           %15" PRId64 "   %10.2f %%  of all variables",
+         stats.all.fixed, percent (stats.all.fixed, stats.vars));
+    PRT ("  failed:        %15" PRId64 "   %10.2f %%  of all variables",
+         stats.failed, percent (stats.failed, stats.vars));
+    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 ("  inprobephases: %15" PRId64 "   %10.2f    interval",
+         stats.inprobingphases,
+         relative (stats.conflicts, stats.inprobingphases));
+    PRT ("  inprobesuccess:%15" PRId64 "   %10.2f %%  phases",
+         stats.inprobesuccess,
+         percent (stats.inprobesuccess, stats.inprobingphases));
+    PRT ("  probingrounds: %15" PRId64 "   %10.2f    per phase",
+         stats.probingrounds,
+         relative (stats.probingrounds, stats.inprobingphases));
+    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));
+    PRT ("  hbrsizes:      %15" PRId64 "   %10.2f    per hbr",
+         stats.hbrsizes, relative (stats.hbrsizes, stats.hbrs));
+    PRT ("  hbreds:        %15" PRId64 "   %10.2f %%  per hbr",
+         stats.hbreds, percent (stats.hbreds, stats.hbrs));
+    PRT ("  hbrsubs:       %15" PRId64 "   %10.2f %%  per hbr",
+         stats.hbrsubs, percent (stats.hbrsubs, stats.hbrs));
+  }
+  PRT ("  units:         %15" PRId64 "   %10.2f    interval", stats.units,
+       relative (stats.conflicts, stats.units));
+  PRT ("  binaries:      %15" PRId64 "   %10.2f    interval",
+       stats.binaries, relative (stats.conflicts, stats.binaries));
+  if (all || stats.flush.learned) {
+    PRT ("flushed:         %15" PRId64 "   %10.2f %%  per conflict",
+         stats.flush.learned,
+         percent (stats.flush.learned, stats.conflicts));
+    PRT ("  hyper:         %15" PRId64 "   %10.2f %%  per conflict",
+         stats.flush.hyper, relative (stats.flush.hyper, stats.conflicts));
+    PRT ("  flushings:     %15" PRId64 "   %10.2f    interval",
+         stats.flush.count, relative (stats.conflicts, stats.flush.count));
+  }
+  if (all || stats.instantiated) {
+    PRT ("instantiated:    %15" PRId64 "   %10.2f %%  of tried",
+         stats.instantiated, percent (stats.instantiated, stats.instried));
+    PRT ("  instrounds:    %15" PRId64 "   %10.2f %%  of elimrounds",
+         stats.instrounds, percent (stats.instrounds, stats.elimrounds));
+  }
+  if (all || stats.conflicts) {
+    PRT ("learned:         %15" PRId64 "   %10.2f %%  per conflict",
+         stats.learned.clauses,
+         percent (stats.learned.clauses, stats.conflicts));
+    PRT ("@ bumped:        %15" PRId64 "   %10.2f    per learned",
+         stats.bumped, relative (stats.bumped, stats.learned.clauses));
+    PRT ("  recomputed:    %15" PRId64 "   %10.2f %%  per learned",
+         stats.recomputed,
+         percent (stats.recomputed, stats.learned.clauses));
+    PRT ("  promoted1:     %15" PRId64 "   %10.2f %%  per learned",
+         stats.promoted1, percent (stats.promoted1, stats.learned.clauses));
+    PRT ("  promoted2:     %15" PRId64 "   %10.2f %%  per learned",
+         stats.promoted2, percent (stats.promoted2, stats.learned.clauses));
+    PRT ("  improvedglue:  %15" PRId64 "   %10.2f %%  per learned",
+         stats.improvedglue,
+         percent (stats.improvedglue, stats.learned.clauses));
+  }
+  if (all || stats.lucky.succeeded) {
+    PRT ("lucky:           %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.succeeded,
+         percent (stats.lucky.succeeded, stats.lucky.tried));
+    PRT ("  constantzero   %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.constant.zero,
+         percent (stats.lucky.constant.zero, stats.lucky.tried));
+    PRT ("  constantone    %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.constant.one,
+         percent (stats.lucky.constant.one, stats.lucky.tried));
+    PRT ("  backwardone    %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.backward.one,
+         percent (stats.lucky.backward.one, stats.lucky.tried));
+    PRT ("  backwardzero   %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.backward.zero,
+         percent (stats.lucky.backward.zero, stats.lucky.tried));
+    PRT ("  forwardone     %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.forward.one,
+         percent (stats.lucky.forward.one, stats.lucky.tried));
+    PRT ("  forwardzero    %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.forward.zero,
+         percent (stats.lucky.forward.zero, stats.lucky.tried));
+    PRT ("  positivehorn   %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.horn.positive,
+         percent (stats.lucky.horn.positive, stats.lucky.tried));
+    PRT ("  negativehorn   %15" PRId64 "   %10.2f %%  of tried",
+         stats.lucky.horn.negative,
+         percent (stats.lucky.horn.negative, stats.lucky.tried));
+  }
+  PRT ("  extendbytes:   %15zd   %10.2f    bytes and MB", extendbytes,
+       extendbytes / (double) (1l << 20));
+  if (all || stats.learned.clauses)
+    PRT ("learned_lits:    %15" PRId64 "   %10.2f %%  learned literals",
+         stats.learned.literals,
+         percent (stats.learned.literals, stats.learned.literals));
+  PRT ("minimized:       %15" PRId64 "   %10.2f %%  learned literals",
+       stats.minimized, percent (stats.minimized, stats.learned.literals));
+  PRT ("shrunken:        %15" PRId64 "   %10.2f %%  learned literals",
+       stats.shrunken, percent (stats.shrunken, stats.learned.literals));
+  PRT ("minishrunken:    %15" PRId64 "   %10.2f %%  learned literals",
+       stats.minishrunken,
+       percent (stats.minishrunken, stats.learned.literals));
+
+  if (all || stats.conflicts) {
+    PRT ("otfs:            %15" PRId64 "   %10.2f %%  of conflict",
+         stats.otfs.subsumed + stats.otfs.strengthened,
+         percent (stats.otfs.subsumed + stats.otfs.strengthened,
+                  stats.conflicts));
+    PRT ("  subsumed       %15" PRId64 "   %10.2f %%  of conflict",
+         stats.otfs.subsumed,
+         percent (stats.otfs.subsumed, stats.conflicts));
+    PRT ("  strengthened   %15" PRId64 "   %10.2f %%  of conflict",
+         stats.otfs.strengthened,
+         percent (stats.otfs.strengthened, stats.conflicts));
+  }
+
+  PRT ("propagations:    %15" PRId64 "   %10.2f M  per second",
+       propagations, relative (propagations / 1e6, t));
+  PRT ("  coverprops:    %15" PRId64 "   %10.2f %%  of propagations",
+       stats.propagations.cover,
+       percent (stats.propagations.cover, propagations));
+  PRT ("  probeprops:    %15" PRId64 "   %10.2f %%  of propagations",
+       stats.propagations.probe,
+       percent (stats.propagations.probe, propagations));
+  PRT ("  searchprops:   %15" PRId64 "   %10.2f %%  of propagations",
+       stats.propagations.search,
+       percent (stats.propagations.search, propagations));
+  PRT ("  transredprops: %15" PRId64 "   %10.2f %%  of propagations",
+       stats.propagations.transred,
+       percent (stats.propagations.transred, propagations));
+  PRT ("  vivifyprops:   %15" PRId64 "   %10.2f %%  of propagations",
+       stats.propagations.vivify,
+       percent (stats.propagations.vivify, propagations));
+  PRT ("  walkprops:     %15" PRId64 "   %10.2f %%  of propagations",
+       stats.propagations.walk,
+       percent (stats.propagations.walk, propagations));
+  if (all || stats.reactivated) {
+    PRT ("reactivated:     %15" PRId64 "   %10.2f %%  of all variables",
+         stats.reactivated, percent (stats.reactivated, stats.vars));
+  }
+  if (all || stats.reduced) {
+    PRT ("reduced:         %15" PRId64 "   %10.2f %%  per conflict",
+         stats.reduced, percent (stats.reduced, stats.conflicts));
+    PRT ("  reductions:    %15" PRId64 "   %10.2f    interval",
+         stats.reductions, relative (stats.conflicts, stats.reductions));
+    PRT ("  sqrt scheme:   %15" PRId64 "   %10.2f %%  reductions",
+         stats.reduced_sqrt,
+         relative (stats.reduced_sqrt, stats.reductions));
+    PRT ("  prct scheme:   %15" PRId64 "   %10.2f %%  reductions",
+         stats.reduced_prct,
+         relative (stats.reduced_prct, stats.reductions));
+    PRT ("  collections:   %15" PRId64 "   %10.2f    interval",
+         stats.collections, relative (stats.conflicts, stats.collections));
+  }
+  if (all || stats.rephased.total) {
+    PRT ("rephased:        %15" PRId64 "   %10.2f    interval",
+         stats.rephased.total,
+         relative (stats.conflicts, stats.rephased.total));
+    PRT ("  rephasedbest:  %15" PRId64 "   %10.2f %%  rephased best",
+         stats.rephased.best,
+         percent (stats.rephased.best, stats.rephased.total));
+    PRT ("  rephasedflip:  %15" PRId64 "   %10.2f %%  rephased flipping",
+         stats.rephased.flipped,
+         percent (stats.rephased.flipped, stats.rephased.total));
+    PRT ("  rephasedinv:   %15" PRId64 "   %10.2f %%  rephased inverted",
+         stats.rephased.inverted,
+         percent (stats.rephased.inverted, stats.rephased.total));
+    PRT ("  rephasedorig:  %15" PRId64 "   %10.2f %%  rephased original",
+         stats.rephased.original,
+         percent (stats.rephased.original, stats.rephased.total));
+    PRT ("  rephasedrand:  %15" PRId64 "   %10.2f %%  rephased random",
+         stats.rephased.random,
+         percent (stats.rephased.random, stats.rephased.total));
+    PRT ("  rephasedwalk:  %15" PRId64 "   %10.2f %%  rephased walk",
+         stats.rephased.walk,
+         percent (stats.rephased.walk, stats.rephased.total));
+  }
+  if (all)
+    PRT ("rescored:        %15" PRId64 "   %10.2f    interval",
+         stats.rescored, relative (stats.conflicts, stats.rescored));
+  if (all || stats.restarts) {
+    PRT ("restarts:        %15" PRId64 "   %10.2f    interval",
+         stats.restarts, relative (stats.conflicts, stats.restarts));
+    PRT ("  reused:        %15" PRId64 "   %10.2f %%  per restart",
+         stats.reused, percent (stats.reused, stats.restarts));
+    PRT ("  reusedlevels:  %15" PRId64 "   %10.2f %%  per restart levels",
+         stats.reusedlevels,
+         percent (stats.reusedlevels, stats.restartlevels));
+  }
+  if (all || stats.restored) {
+    PRT ("restored:        %15" PRId64 "   %10.2f %%  per weakened",
+         stats.restored, percent (stats.restored, stats.weakened));
+    PRT ("  restorations:  %15" PRId64 "   %10.2f %%  per extension",
+         stats.restorations,
+         percent (stats.restorations, stats.extensions));
+    PRT ("  literals:      %15" PRId64 "   %10.2f    per restored clause",
+         stats.restoredlits, relative (stats.restoredlits, stats.restored));
+  }
+  if (all || stats.stabphases) {
+    PRT ("stabilizing:     %15" PRId64 "   %10.2f %%  of conflicts",
+         stats.stabphases, percent (stats.stabconflicts, stats.conflicts));
+    PRT ("  restartstab:   %15" PRId64 "   %10.2f %%  of all restarts",
+         stats.restartstable,
+         percent (stats.restartstable, stats.restarts));
+    PRT ("  reusedstab:    %15" PRId64 "   %10.2f %%  per stable restarts",
+         stats.reusedstable,
+         percent (stats.reusedstable, stats.restartstable));
+  }
+  if (all || stats.all.substituted) {
+    PRT ("substituted:     %15" PRId64 "   %10.2f %%  of all variables",
+         stats.all.substituted,
+         percent (stats.all.substituted, stats.vars));
+    PRT ("  decompositions:%15" PRId64 "   %10.2f    per phase",
+         stats.decompositions,
+         relative (stats.decompositions, stats.inprobingphases));
+  }
+  if (all || stats.sweep_equivalences) {
+    PRT ("sweep equivs:    %15" PRId64 "   %10.2f %%  of swept variables",
+         stats.sweep_equivalences,
+         percent (stats.sweep_equivalences, stats.sweep_variables));
+    PRT ("  sweepings:     %15" PRId64 "   %10.2f    vars per sweeping",
+         stats.sweep, relative (stats.sweep_variables, stats.sweep));
+    PRT ("  swept vars:    %15" PRId64 "   %10.2f %%  of all variables",
+         stats.sweep_variables,
+         percent (stats.sweep_variables, stats.vars));
+    PRT ("  sweep units:   %15" PRId64 "   %10.2f %%  of all variables",
+         stats.sweep_units, percent (stats.sweep_units, stats.vars));
+    PRT ("  solved:        %15" PRId64 "   %10.2f    per swept variable",
+         stats.sweep_solved,
+         relative (stats.sweep_solved, stats.sweep_variables));
+    PRT ("  sat:           %15" PRId64 "   %10.2f %%  solved",
+         stats.sweep_sat, percent (stats.sweep_sat, stats.sweep_solved));
+    PRT ("  unsat:         %15" PRId64 "   %10.2f %%  solved",
+         stats.sweep_unsat,
+         percent (stats.sweep_unsat, stats.sweep_solved));
+    PRT ("  backbone solved:%14" PRId64 "   %10.2f %%  solved",
+         stats.sweep_solved_backbone,
+         percent (stats.sweep_solved_backbone, stats.sweep_solved));
+    PRT ("    sat:         %15" PRId64 "   %10.2f %%  backbone solved",
+         stats.sweep_sat_backbone,
+         percent (stats.sweep_sat_backbone, stats.sweep_solved_backbone));
+    PRT ("    unsat:       %15" PRId64 "   %10.2f %%  backbone solved",
+         stats.sweep_unsat_backbone,
+         percent (stats.sweep_unsat_backbone, stats.sweep_solved_backbone));
+    PRT ("    unknown:     %15" PRId64 "   %10.2f %%  backbone solved",
+         stats.sweep_unknown_backbone,
+         percent (stats.sweep_unknown_backbone,
+                  stats.sweep_solved_backbone));
+    PRT ("    fixed:       %15" PRId64 "   %10.2f   per swept variable",
+         stats.sweep_fixed_backbone,
+         relative (stats.sweep_fixed_backbone, stats.sweep_variables));
+    PRT ("    flip:        %15" PRId64 "   %10.2f   per swept variable",
+         stats.sweep_flip_backbone,
+         relative (stats.sweep_flip_backbone, stats.sweep_variables));
+    PRT ("    flipped:     %15" PRId64 "   %10.2f %%  of backbone flip",
+         stats.sweep_flipped_backbone,
+         percent (stats.sweep_flipped_backbone, stats.sweep_flip_backbone));
+    PRT ("  equiv solved:  %15" PRId64 "   %10.2f %%  solved",
+         stats.sweep_solved_equivalences,
+         percent (stats.sweep_solved_equivalences, stats.sweep_solved));
+    PRT ("    sat:         %15" PRId64 "   %10.2f %%  equiv solved",
+         stats.sweep_sat_equivalences,
+         percent (stats.sweep_sat_equivalences,
+                  stats.sweep_solved_equivalences));
+    PRT ("    unsat:       %15" PRId64 "   %10.2f %%  equiv solved",
+         stats.sweep_unsat_equivalences,
+         percent (stats.sweep_unsat_equivalences,
+                  stats.sweep_solved_equivalences));
+    PRT ("    unknown:     %15" PRId64 "   %10.2f %%  equiv solved",
+         stats.sweep_unknown_equivalences,
+         percent (stats.sweep_unknown_equivalences,
+                  stats.sweep_solved_equivalences));
+    PRT ("    flip:        %15" PRId64 "   %10.2f    per swept variable",
+         stats.sweep_flip_equivalences,
+         relative (stats.sweep_flip_equivalences, stats.sweep_variables));
+    PRT ("    flipped:     %15" PRId64 "   %10.2f %%  of equiv flip",
+         stats.sweep_flipped_equivalences,
+         percent (stats.sweep_flipped_equivalences,
+                  stats.sweep_flip_equivalences));
+    PRT ("  depth:         %15" PRId64 "   %10.2f    per swept variable",
+         stats.sweep_depth,
+         relative (stats.sweep_depth, stats.sweep_variables));
+    PRT ("  environment:   %15" PRId64 "   %10.2f    per swept variable",
+         stats.sweep_environment,
+         relative (stats.sweep_environment, stats.sweep_variables));
+    PRT ("  clauses:       %15" PRId64 "   %10.2f    per swept variable",
+         stats.sweep_clauses,
+         relative (stats.sweep_clauses, stats.sweep_variables));
+    PRT ("  completed:     %15" PRId64 "   %10.2f    sweeps to complete",
+         stats.sweep_completed,
+         relative (stats.sweep, stats.sweep_completed));
+  }
+  if (all || stats.subsumed) {
+    PRT ("subsumed:        %15" PRId64 "   %10.2f %%  of all clauses",
+         stats.subsumed, percent (stats.subsumed, stats.added.total));
+    PRT ("  subsumephases: %15" PRId64 "   %10.2f    interval",
+         stats.subsumephases,
+         relative (stats.conflicts, stats.subsumephases));
+    PRT ("  subsumerounds: %15" PRId64 "   %10.2f    per phase",
+         stats.subsumerounds,
+         relative (stats.subsumerounds, stats.subsumephases));
+    PRT ("  deduplicated:  %15" PRId64 "   %10.2f %%  per subsumed",
+         stats.deduplicated, percent (stats.deduplicated, stats.subsumed));
+    PRT ("  transreds:     %15" PRId64 "   %10.2f    interval",
+         stats.transreds, relative (stats.conflicts, stats.transreds));
+    PRT ("  transitive:    %15" PRId64 "   %10.2f %%  per subsumed",
+         stats.transitive, percent (stats.transitive, stats.subsumed));
+    PRT ("  subirr:        %15" PRId64 "   %10.2f %%  of subsumed",
+         stats.subirr, percent (stats.subirr, stats.subsumed));
+    PRT ("  subred:        %15" PRId64 "   %10.2f %%  of subsumed",
+         stats.subred, percent (stats.subred, stats.subsumed));
+    PRT ("  subtried:      %15" PRId64 "   %10.2f    tried per subsumed",
+         stats.subtried, relative (stats.subtried, stats.subsumed));
+    PRT ("  subchecks:     %15" PRId64 "   %10.2f    per tried",
+         stats.subchecks, relative (stats.subchecks, stats.subtried));
+    PRT ("  subchecks2:    %15" PRId64 "   %10.2f %%  per subcheck",
+         stats.subchecks2, percent (stats.subchecks2, stats.subchecks));
+    PRT ("  elimotfsub:    %15" PRId64 "   %10.2f %%  of subsumed",
+         stats.elimotfsub, percent (stats.elimotfsub, stats.subsumed));
+    PRT ("  elimbwsub:     %15" PRId64 "   %10.2f %%  of subsumed",
+         stats.elimbwsub, percent (stats.elimbwsub, stats.subsumed));
+    PRT ("  eagersub:      %15" PRId64 "   %10.2f %%  of subsumed",
+         stats.eagersub, percent (stats.eagersub, stats.subsumed));
+    PRT ("  eagertried:    %15" PRId64 "   %10.2f    tried per eagersub",
+         stats.eagertried, relative (stats.eagertried, stats.eagersub));
+  }
+  if (all || stats.strengthened) {
+    PRT ("strengthened:    %15" PRId64 "   %10.2f %%  of all clauses",
+         stats.strengthened,
+         percent (stats.strengthened, stats.added.total));
+    PRT ("  elimotfstr:    %15" PRId64 "   %10.2f %%  of strengthened",
+         stats.elimotfstr, percent (stats.elimotfstr, stats.strengthened));
+    PRT ("  elimbwstr:     %15" PRId64 "   %10.2f %%  of strengthened",
+         stats.elimbwstr, percent (stats.elimbwstr, stats.strengthened));
+  }
+  if (all || stats.htrs) {
+    PRT ("ternary:         %15" PRId64 "   %10.2f %%  of resolved",
+         stats.htrs, percent (stats.htrs, stats.ternres));
+    PRT ("  phases:        %15" PRId64 "   %10.2f    interval",
+         stats.ternary, relative (stats.conflicts, stats.ternary));
+    PRT ("  htr3:          %15" PRId64
+         "   %10.2f %%  ternary hyper ternres",
+         stats.htrs3, percent (stats.htrs3, stats.htrs));
+    PRT ("  htr2:          %15" PRId64 "   %10.2f %%  binary hyper ternres",
+         stats.htrs2, percent (stats.htrs2, stats.htrs));
+  }
+  PRT ("ticks:           %15" PRId64 "   %10.2f    propagation", totalticks,
+       relative (totalticks, stats.propagations.search));
+  PRT (" searchticks:    %15" PRId64 "   %10.2f %%  totalticks",
+       searchticks, percent (searchticks, totalticks));
+  PRT ("   stableticks:  %15" PRId64 "   %10.2f %%  searchticks",
+       stats.ticks.search[1], percent (stats.ticks.search[1], searchticks));
+  PRT ("   unstableticks:%15" PRId64 "   %10.2f %%  searchticks",
+       stats.ticks.search[0], percent (stats.ticks.search[0], searchticks));
+  PRT (" inprobeticks:   %15" PRId64 "   %10.2f %%  totalticks",
+       inprobeticks, percent (inprobeticks, totalticks));
+  PRT ("   factorticks:  %15" PRId64 "   %10.2f %%  searchticks",
+       stats.ticks.factor, percent (stats.ticks.factor, searchticks));
+  PRT ("   probeticks:   %15" PRId64 "   %10.2f %%  searchticks",
+       stats.ticks.probe, percent (stats.ticks.probe, searchticks));
+  PRT ("   sweepticks:   %15" PRId64 "   %10.2f %%  searchticks",
+       stats.ticks.sweep, percent (stats.ticks.sweep, searchticks));
+  PRT ("   ternaryticks: %15" PRId64 "   %10.2f %%  searchticks",
+       stats.ticks.ternary, percent (stats.ticks.ternary, searchticks));
+  PRT ("   vivifyticks:  %15" PRId64 "   %10.2f %%  searchticks",
+       stats.ticks.vivify, percent (stats.ticks.vivify, searchticks));
+  if (all) {
+    PRT ("tier recomputed: %15" PRId64 "   %10.2f    interval",
+         stats.tierecomputed,
+         relative (stats.conflicts, stats.tierecomputed));
+  }
+  if (all || stats.ilbtriggers) {
+    PRT ("trail reuses:    %15" PRId64 "   %10.2f %%  of incremental calls",
+         stats.ilbsuccess, percent (stats.ilbsuccess, stats.ilbtriggers));
+    PRT ("  levels:        %15" PRId64 "   %10.2f    per reuse",
+         stats.levelsreused,
+         relative (stats.levelsreused, stats.ilbsuccess));
+    PRT ("  literals:      %15" PRId64 "   %10.2f    per reuse",
+         stats.literalsreused,
+         relative (stats.literalsreused, stats.ilbsuccess));
+    PRT ("  assumptions:   %15" PRId64 "   %10.2f    per reuse",
+         stats.assumptionsreused,
+         relative (stats.assumptionsreused, stats.ilbsuccess));
+  }
+  if (all || vivified) {
+    PRT ("vivified:        %15" PRId64 "   %10.2f %%  of all clauses",
+         vivified, percent (vivified, stats.added.total));
+    PRT ("  vivifications: %15" PRId64 "   %10.2f    interval",
+         stats.vivifications,
+         relative (stats.conflicts, stats.vivifications));
+    PRT ("  vivifychecks:  %15" PRId64 "   %10.2f %%  per conflict",
+         stats.vivifychecks, percent (stats.vivifychecks, stats.conflicts));
+    PRT ("  vivifysched:   %15" PRId64 "   %10.2f %%  checks per scheduled",
+         stats.vivifysched,
+         percent (stats.vivifychecks, stats.vivifysched));
+    PRT ("  vivifyunits:   %15" PRId64 "   %10.2f %%  per vivify check",
+         stats.vivifyunits,
+         percent (stats.vivifyunits, stats.vivifychecks));
+    PRT ("  vivifyinst:    %15" PRId64 "   %10.2f %%  per vivify check",
+         stats.vivifyinst, percent (stats.vivifyinst, stats.vivifychecks));
+    PRT ("  vivifysubs:    %15" PRId64 "   %10.2f %%  per subsumed",
+         stats.vivifysubs, percent (stats.vivifysubs, stats.subsumed));
+    PRT ("  vivifysubred:  %15" PRId64 "   %10.2f %%  per subs",
+         stats.vivifysubred,
+         percent (stats.vivifysubred, stats.vivifysubs));
+    PRT ("  vivifysubirr:  %15" PRId64 "   %10.2f %%  per subs",
+         stats.vivifysubirr,
+         percent (stats.vivifysubirr, stats.vivifysubs));
+    PRT ("  vivifystrs:    %15" PRId64 "   %10.2f %%  per strengthened",
+         stats.vivifystrs, percent (stats.vivifystrs, stats.strengthened));
+    PRT ("  vivifystrirr:  %15" PRId64 "   %10.2f %%  per vivifystrs",
+         stats.vivifystrirr,
+         percent (stats.vivifystrirr, stats.vivifystrs));
+    PRT ("  vivifystred1:  %15" PRId64 "   %10.2f %%  per vivifystrs",
+         stats.vivifystred1,
+         percent (stats.vivifystred1, stats.vivifystrs));
+    PRT ("  vivifystred2:  %15" PRId64 "   %10.2f %%  per viviyfstrs",
+         stats.vivifystred2,
+         percent (stats.vivifystred2, stats.vivifystrs));
+    PRT ("  vivifystred3:  %15" PRId64 "   %10.2f %%  per vivifystrs",
+         stats.vivifystred3,
+         percent (stats.vivifystred3, stats.vivifystrs));
+    PRT ("  vivifydemote:  %15" PRId64 "   %10.2f %%  per vivifystrs",
+         stats.vivifydemote,
+         percent (stats.vivifydemote, stats.vivifystrs));
+    PRT ("  vivifydecs:    %15" PRId64 "   %10.2f    per checks",
+         stats.vivifydecs, relative (stats.vivifydecs, stats.vivifychecks));
+    PRT ("  vivifyreused:  %15" PRId64 "   %10.2f %%  per decision",
+         stats.vivifyreused,
+         percent (stats.vivifyreused, stats.vivifydecs));
+  }
+  if (all || stats.walk.count) {
+    PRT ("walked:          %15" PRId64 "   %10.2f    interval",
+         stats.walk.count, relative (stats.conflicts, stats.walk.count));
+#ifndef CADICAL_QUIET
+    if (internal->profiles.walk.value > 0)
+      PRT ("  flips:         %15" PRId64 "   %10.2f M  per second",
+           stats.walk.flips,
+           relative (1e-6 * stats.walk.flips,
+                     internal->profiles.walk.value));
+    else
+#endif
+      PRT ("  flips:         %15" PRId64 "   %10.2f    per walk",
+           stats.walk.flips, relative (stats.walk.flips, stats.walk.count));
+    if (stats.walk.minimum < LONG_MAX)
+      PRT ("  minimum:       %15" PRId64 "   %10.2f %%  clauses",
+           stats.walk.minimum,
+           percent (stats.walk.minimum, stats.added.irredundant));
+    PRT ("  broken:        %15" PRId64 "   %10.2f    per flip",
+         stats.walk.broken, relative (stats.walk.broken, stats.walk.flips));
+  }
+  if (all || stats.weakened) {
+    PRT ("weakened:        %15" PRId64 "   %10.2f    average size",
+         stats.weakened, relative (stats.weakenedlen, stats.weakened));
+    PRT ("  extensions:    %15" PRId64 "   %10.2f    interval",
+         stats.extensions, relative (stats.conflicts, stats.extensions));
+    PRT ("  flipped:       %15" PRId64 "   %10.2f    per weakened",
+         stats.extended, relative (stats.extended, stats.weakened));
+  }
+
+  if (all || stats.congruence.gates) {
+    PRT ("congruence:      %15" PRId64 "   %10.2f    interval",
+         stats.congruence.rounds,
+         relative (stats.conflicts, stats.congruence.rounds));
+    PRT ("   units:        %15" PRId64 "   %10.2f    per congruent",
+         stats.congruence.units,
+         relative (stats.congruence.units, stats.congruence.congruent));
+    PRT ("   cong-and:     %15" PRId64 "   %10.2f    per found gates",
+         stats.congruence.ands,
+         relative (stats.congruence.ands, stats.congruence.gates));
+    PRT ("   cong-ite:     %15" PRId64 "   %10.2f    per found gates",
+         stats.congruence.ites,
+         relative (stats.congruence.ites, stats.congruence.gates));
+    PRT ("   cong-xor:     %15" PRId64 "   %10.2f    per found gates",
+         stats.congruence.xors,
+         relative (stats.congruence.xors, stats.congruence.gates));
+    PRT ("   congruent:    %15" PRId64 "   %10.2f    per round",
+         stats.congruence.congruent,
+         relative (stats.congruence.rounds, stats.congruence.congruent));
+    PRT ("   unaries:      %15" PRId64 "   %10.2f    per round",
+         stats.congruence.unaries,
+         relative (stats.congruence.rounds, stats.congruence.unaries));
+    PRT ("   rewri.-ands:  %15" PRId64 "   %10.2f    per round",
+         stats.congruence.rewritten_ands,
+         relative (stats.congruence.rounds,
+                   stats.congruence.rewritten_ands));
+    PRT ("   subsumed:     %15" PRId64 "   %10.2f    per round",
+         stats.congruence.subsumed,
+         relative (stats.congruence.rounds, stats.congruence.subsumed));
+  }
+
+  LINE ();
+  MSG ("%sseconds are measured in %s time for solving%s",
+       tout.magenta_code (), internal->opts.realtime ? "real" : "process",
+       tout.normal_code ());
+
+#endif // ifndef CADICAL_QUIET
+}
+
+void Internal::print_resource_usage () {
+#ifndef CADICAL_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
+}
+
+/*------------------------------------------------------------------------*/
+
+void Checker::print_stats () {
+
+  if (!stats.added && !stats.deleted)
+    return;
+
+  SECTION ("checker statistics");
+
+  MSG ("checks:          %15" PRId64 "", stats.checks);
+  MSG ("assumptions:     %15" PRId64 "   %10.2f    per check",
+       stats.assumptions, relative (stats.assumptions, stats.checks));
+  MSG ("propagations:    %15" PRId64 "   %10.2f    per check",
+       stats.propagations, relative (stats.propagations, stats.checks));
+  MSG ("original:        %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.original, percent (stats.original, stats.added));
+  MSG ("derived:         %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.derived, percent (stats.derived, stats.added));
+  MSG ("deleted:         %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.deleted, percent (stats.deleted, stats.added));
+  MSG ("insertions:      %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.insertions, percent (stats.insertions, stats.added));
+  MSG ("collections:     %15" PRId64 "   %10.2f    deleted per collection",
+       stats.collections, relative (stats.collections, stats.deleted));
+  MSG ("collisions:      %15" PRId64 "   %10.2f    per search",
+       stats.collisions, relative (stats.collisions, stats.searches));
+  MSG ("searches:        %15" PRId64 "", stats.searches);
+  MSG ("units:           %15" PRId64 "", stats.units);
+}
+
+void LratChecker::print_stats () {
+
+  if (!stats.added && !stats.deleted)
+    return;
+
+  SECTION ("lrat checker statistics");
+
+  MSG ("checks:          %15" PRId64 "", stats.checks);
+  MSG ("insertions:      %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.insertions, percent (stats.insertions, stats.added));
+  MSG ("original:        %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.original, percent (stats.original, stats.added));
+  MSG ("derived:         %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.derived, percent (stats.derived, stats.added));
+  MSG ("deleted:         %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.deleted, percent (stats.deleted, stats.added));
+  MSG ("finalized:       %15" PRId64 "   %10.2f %%  of all clauses",
+       stats.finalized, percent (stats.finalized, stats.added));
+  MSG ("collections:     %15" PRId64 "   %10.2f    deleted per collection",
+       stats.collections, relative (stats.collections, stats.deleted));
+  MSG ("collisions:      %15" PRId64 "   %10.2f    per search",
+       stats.collisions, relative (stats.collisions, stats.searches));
+  MSG ("searches:        %15" PRId64 "", stats.searches);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_subsume.cpp b/src/sat/cadical/cadical_subsume.cpp
new file mode 100644
index 000000000..b75040ca8
--- /dev/null
+++ b/src/sat/cadical/cadical_subsume.cpp
@@ -0,0 +1,652 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+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 likely to be kept.
+// This is abstracted away in the 'likely_to_be_kept_clause' function, which
+// implicitly relies on 'opts.reducetier1glue' (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
+// size) clauses.  Since 'vivification' is an extended version of subsume,
+// more powerful, but also slower, we schedule 'vivify' right after
+// 'subsume', which in contrast to 'subsume' is not run until to completion.
+//
+// This implementation is inspired by Bayardo's SDM'11 analysis of our
+// subsumption algorithm in our SATeLite preprocessor in the context of
+// finding extremal sets in data mining and his suggested improvements.
+
+// 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
+// literals in the larger subsume candidate clauses have to be traversed,
+// while for our forward approach the long subsumed candidate clause is only
+// marked once, while the literals of the shorter subsuming clauses have to
+// be checked.  We also use a fixed special more cache friendly data
+// structure for binary clauses, to avoid traversing them directly.
+
+// In our forward scheme it is still possible to skip occurrence lists of
+// literals which were not added since the last subsumption round, since
+// only those can contain subsuming candidates.  Actually, clauses which
+// contain at least one literal, which was not added since the last
+// subsumption round do not have to be connected at all, even though they
+// might still be subsumed them self.
+
+// Bayardo suggests to sort the literals in clauses and perform some kind of
+// partial merge-sort, while we mark literals, but do sort literals during
+// connecting a clause w.r.t. the number of occurrences, in order to find
+// literals which do not occur in the subsumed candidate fast with high
+// probability (less occurring literals have a higher chance).
+
+// This is the actual subsumption and strengthening check.  We assume that
+// all the literals of the candidate clause to be subsumed or strengthened
+// are marked, so we only have to check that all the literals of the
+// argument clause 'subsuming', which is checked for subsuming the candidate
+// clause 'subsumed', has all its literals marked (in the correct phase).
+// If exactly one is in the opposite phase we can still strengthen the
+// candidate clause by this single literal which occurs in opposite phase.
+//
+// The result is INT_MIN if all literals are marked and thus the candidate
+// clause can be subsumed.  It is zero if neither subsumption nor
+// strengthening is possible.  Otherwise the candidate clause can be
+// strengthened and as a result the negation of the literal which can be
+// removed is returned.
+
+inline int Internal::subsume_check (Clause *subsuming, Clause *subsumed) {
+#ifdef CADICAL_NDEBUG
+  (void) subsumed;
+#endif
+  // Only use 'subsumed' for these following CADICAL_assertion checks.  Otherwise we
+  // only require that 'subsumed' has all its literals marked.
+  //
+  CADICAL_assert (!subsumed->garbage);
+  CADICAL_assert (!subsuming->garbage);
+  CADICAL_assert (subsuming != subsumed);
+  CADICAL_assert (subsuming->size <= subsumed->size);
+
+  stats.subchecks++;
+  if (subsuming->size == 2)
+    stats.subchecks2++;
+
+  int flipped = 0, prev = 0;
+  bool failed = false;
+  const auto eoc = subsuming->end ();
+  for (auto i = subsuming->begin (); !failed && i != eoc; i++) {
+    int lit = *i;
+    *i = prev;
+    prev = lit;
+    const int tmp = marked (lit);
+    if (!tmp)
+      failed = true;
+    else if (tmp > 0)
+      continue;
+    else if (flipped)
+      failed = true;
+    else
+      flipped = lit;
+  }
+  CADICAL_assert (prev);
+  CADICAL_assert (!subsuming->literals[0]);
+  subsuming->literals[0] = prev;
+  if (failed)
+    return 0;
+
+  if (!flipped)
+    return INT_MIN; // subsumed!!
+  else if (!opts.subsumestr)
+    return 0;
+  else
+    return flipped; // strengthen!!
+}
+
+/*------------------------------------------------------------------------*/
+
+// Candidate clause 'subsumed' is subsumed by 'subsuming'.
+
+inline void Internal::subsume_clause (Clause *subsuming, Clause *subsumed) {
+  stats.subsumed++;
+  CADICAL_assert (subsuming->size <= subsumed->size);
+  LOG (subsumed, "subsumed");
+  if (subsumed->redundant)
+    stats.subred++;
+  else
+    stats.subirr++;
+  if (subsumed->redundant || !subsuming->redundant) {
+    mark_garbage (subsumed);
+    return;
+  }
+  LOG ("turning redundant subsuming clause into irredundant clause");
+  subsuming->redundant = false;
+  if (proof)
+    proof->strengthen (subsuming->id);
+  mark_garbage (subsumed);
+  stats.current.irredundant++;
+  stats.added.irredundant++;
+  stats.irrlits += subsuming->size;
+  CADICAL_assert (stats.current.redundant > 0);
+  stats.current.redundant--;
+  CADICAL_assert (stats.added.redundant > 0);
+  stats.added.redundant--;
+  // ... and keep 'stats.added.total'.
+}
+
+/*------------------------------------------------------------------------*/
+
+// Candidate clause 'c' is strengthened by removing 'lit'.
+
+void Internal::strengthen_clause (Clause *c, int lit) {
+  if (opts.check && is_external_forgettable (c->id))
+    mark_garbage_external_forgettable (c->id);
+  stats.strengthened++;
+  CADICAL_assert (c->size > 2);
+  LOG (c, "removing %d in", lit);
+  if (proof) {
+    LOG (lrat_chain, "strengthening clause with chain");
+    proof->strengthen_clause (c, lit, lrat_chain);
+  }
+  if (!c->redundant)
+    mark_removed (lit);
+  auto new_end = remove (c->begin (), c->end (), lit);
+  CADICAL_assert (new_end + 1 == c->end ()), (void) new_end;
+  (void) shrink_clause (c, c->size - 1);
+  // bump_clause2 (c);
+  LOG (c, "strengthened");
+  external->check_shrunken_clause (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find clauses connected in the occurrence lists 'occs' which subsume the
+// candidate clause 'c' given as first argument.  If this is the case the
+// clause is subsumed and the result is positive.   If the clause was
+// strengthened the result is negative.  Otherwise the candidate clause
+// can not be subsumed nor strengthened and zero is returned.
+
+inline int Internal::try_to_subsume_clause (Clause *c,
+                                            vector<Clause *> &shrunken) {
+
+  stats.subtried++;
+  CADICAL_assert (!level);
+  LOG (c, "trying to subsume");
+
+  mark (c); // signed!
+
+  Clause *d = 0;
+  int flipped = 0;
+
+  for (const auto &lit : *c) {
+
+    // Only clauses which have a variable which has recently been added are
+    // checked for being subsumed.  The idea is that all these newly added
+    // clauses are candidates for subsuming the clause.  Then we also only
+    // need to check occurrences of these variables.  The occurrence lists
+    // of other literal do not have to be checked.
+    //
+    if (!flags (lit).subsume)
+      continue;
+
+    for (int sign = -1; !d && sign <= 1; sign += 2) {
+
+      // First we check against all binary clauses.  The other literals of
+      // all binary clauses of 'sign*lit' are stored in one consecutive
+      // array, which is way faster than storing clause pointers and
+      // dereferencing them.  Since this binary clause array is also not
+      // shrunken, we also can bail out earlier if subsumption or
+      // strengthening is determined.
+
+      // In both cases the (self-)subsuming clause is stored in 'd', which
+      // makes it nonzero and forces aborting both the outer and inner loop.
+      // If the binary clause can strengthen the candidate clause 'c'
+      // (through self-subsuming resolution), then 'filled' is set to the
+      // literal which can be removed in 'c', otherwise to 'INT_MIN' which
+      // is a non-valid literal.
+
+      for (const auto &bin : bins (sign * lit)) {
+        const auto &other = bin.lit;
+        const int tmp = marked (other);
+        if (!tmp)
+          continue;
+        if (tmp < 0 && sign < 0)
+          continue;
+        if (tmp < 0) {
+          if (sign < 0)
+            continue; // tautological resolvent
+          dummy_binary->literals[0] = lit;
+          dummy_binary->literals[1] = other;
+          flipped = other;
+        } else {
+          dummy_binary->literals[0] = sign * lit;
+          dummy_binary->literals[1] = other;
+          flipped = (sign < 0) ? -lit : INT_MIN;
+        }
+
+        // This dummy binary clauses is initialized in 'Internal::Internal'
+        // and only changes it literals in the lines above.   By using such
+        // a faked binary clause we can simply reuse 'subsume_clause' as
+        // well as the code around 'strengthen_clause' uniform for both real
+        // clauses and this special case for binary clauses
+
+        dummy_binary->id = bin.id;
+        d = dummy_binary;
+
+        break;
+      }
+
+      if (d)
+        break;
+
+      // In this second loop we check for larger than binary clauses to
+      // subsume or strengthen the candidate clause.   This is more costly,
+      // and needs a call to 'subsume_check'.  Otherwise the same contract
+      // as above for communicating 'subsumption' or 'strengthening' to the
+      // code after the loop is used.
+      //
+      const Occs &os = occs (sign * lit);
+      for (const auto &e : os) {
+        CADICAL_assert (!e->garbage); // sanity check
+        if (e->garbage)
+          continue; // defensive: not needed
+        flipped = subsume_check (e, c);
+        if (!flipped)
+          continue;
+        d = e; // leave also outer loop
+        break;
+      }
+    }
+
+    if (d)
+      break;
+  }
+
+  unmark (c);
+
+  if (flipped == INT_MIN) {
+    LOG (d, "subsuming");
+    subsume_clause (d, c);
+    return 1;
+  }
+
+  if (flipped) {
+    LOG (d, "strengthening");
+    if (lrat) {
+      CADICAL_assert (lrat_chain.empty ());
+      lrat_chain.push_back (c->id);
+      lrat_chain.push_back (d->id);
+    }
+    if (d->used > c->used)
+      c->used = d->used;
+    strengthen_clause (c, -flipped);
+    lrat_chain.clear ();
+    CADICAL_assert (likely_to_be_kept_clause (c));
+    shrunken.push_back (c);
+    return -1;
+  }
+
+  return 0;
+}
+
+
+struct subsume_less_noccs {
+  Internal *internal;
+  subsume_less_noccs (Internal *i) : internal (i) {}
+  bool operator() (int a, int b) {
+    const signed char u = internal->val (a), v = internal->val (b);
+    if (!u && v)
+      return true;
+    if (u && !v)
+      return false;
+    const int64_t m = internal->noccs (a), n = internal->noccs (b);
+    if (m < n)
+      return true;
+    if (m > n)
+      return false;
+    return abs (a) < abs (b);
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Usually called from 'subsume' below if 'subsuming' triggered it.  Then
+// the idea is to subsume both redundant and irredundant clauses. It is also
+// called in the elimination loop in 'elim' in which case we focus on
+// irredundant clauses only to help bounded variable elimination.  The
+// function returns true of an irredundant clause was removed or
+// strengthened, which might then in the second usage scenario trigger new
+// variable eliminations.
+
+bool Internal::subsume_round () {
+
+  if (!opts.subsume)
+    return false;
+  if (unsat)
+    return false;
+  if (terminated_asynchronously ())
+    return false;
+  if (!stats.current.redundant && !stats.current.irredundant)
+    return false;
+
+  START_SIMPLIFIER (subsume, SUBSUME);
+  stats.subsumerounds++;
+
+  int64_t check_limit;
+  if (opts.subsumelimited) {
+    int64_t delta = stats.propagations.search;
+    delta *= 1e-3 * opts.subsumeeffort;
+    if (delta < opts.subsumemineff)
+      delta = opts.subsumemineff;
+    if (delta > opts.subsumemaxeff)
+      delta = opts.subsumemaxeff;
+    delta = max (delta, (int64_t) 2l * active ());
+
+    PHASE ("subsume-round", stats.subsumerounds,
+           "limit of %" PRId64 " subsumption checks", delta);
+
+    check_limit = stats.subchecks + delta;
+  } else {
+    PHASE ("subsume-round", stats.subsumerounds,
+           "unlimited subsumption checks");
+    check_limit = LONG_MAX;
+  }
+
+  int old_marked_candidate_variables_for_elimination = stats.mark.elim;
+
+  CADICAL_assert (!level);
+
+  // Allocate schedule and occurrence lists.
+  //
+  vector<ClauseSize> schedule;
+  init_noccs ();
+
+  // Determine candidate clauses and sort them by size.
+  //
+  int64_t left_over_from_last_subsumption_round = 0;
+
+  for (auto c : clauses) {
+
+    if (c->garbage)
+      continue;
+    if (c->size > opts.subsumeclslim)
+      continue;
+    if (!likely_to_be_kept_clause (c))
+      continue;
+
+    bool fixed = false;
+    int subsume = 0;
+    for (const auto &lit : *c)
+      if (val (lit))
+        fixed = true;
+      else if (flags (lit).subsume)
+        subsume++;
+
+    // If the clause contains a root level assigned (fixed) literal we will
+    // not work on it.  This simplifies the code substantially since we do
+    // not have to care about assignments at all.  Strengthening becomes
+    // much simpler too.
+    //
+    if (fixed) {
+      LOG (c, "skipping (fixed literal)");
+      continue;
+    }
+
+    // Further, if less than two variables in the clause were added since
+    // the last subsumption round, the clause is ignored too.
+    //
+    if (subsume < 2) {
+      LOG (c, "skipping (only %d added literals)", subsume);
+      continue;
+    }
+
+    if (c->subsume)
+      left_over_from_last_subsumption_round++;
+    schedule.push_back (ClauseSize (c->size, c));
+    for (const auto &lit : *c)
+      noccs (lit)++;
+  }
+  shrink_vector (schedule);
+
+  // Smaller clauses are checked and connected first.
+  //
+  rsort (schedule.begin (), schedule.end (), smaller_clause_size_rank ());
+
+  if (!left_over_from_last_subsumption_round)
+    for (auto cs : schedule)
+      if (cs.clause->size > 2)
+        cs.clause->subsume = true;
+
+#ifndef CADICAL_QUIET
+  int64_t scheduled = schedule.size ();
+  int64_t total = stats.current.irredundant + stats.current.redundant;
+  PHASE ("subsume-round", stats.subsumerounds,
+         "scheduled %" PRId64 " clauses %.0f%% out of %" PRId64 " clauses",
+         scheduled, percent (scheduled, total), total);
+#endif
+
+  // Now go over the scheduled clauses in the order of increasing size and
+  // try to forward subsume and strengthen them. Forward subsumption tries
+  // to find smaller or same size clauses which subsume or might strengthen
+  // the candidate.  After the candidate has been processed connect one
+  // of its literals (with smallest number of occurrences at this point) in
+  // a one-watched scheme.
+
+  int64_t subsumed = 0, strengthened = 0, checked = 0;
+
+  vector<Clause *> shrunken;
+  init_occs ();
+  init_bins ();
+
+  for (const auto &s : schedule) {
+
+    if (terminated_asynchronously ())
+      break;
+    if (stats.subchecks >= check_limit)
+      break;
+
+    Clause *c = s.clause;
+    CADICAL_assert (!c->garbage);
+
+    checked++;
+
+    // First try to subsume or strengthen this candidate clause.  For binary
+    // clauses this could be done much faster by hashing and is costly due
+    // to a usually large number of binary clauses.  There is further the
+    // issue, that strengthening binary clauses (through double
+    // self-subsuming resolution) would produce units, which needs much more
+    // care. In the same (lazy) spirit we also ignore clauses with fixed
+    // literals (false or true).
+    //
+    if (c->size > 2 && c->subsume) {
+      c->subsume = false;
+      const int tmp = try_to_subsume_clause (c, shrunken);
+      if (tmp > 0) {
+        subsumed++;
+        continue;
+      }
+      if (tmp < 0)
+        strengthened++;
+    }
+
+    // If not subsumed connect smallest occurring literal, where occurring
+    // means the number of times it was used to connect (as a one-watch) a
+    // previous smaller or equal sized clause.  This minimizes the length of
+    // the occurrence lists traversed during 'try_to_subsume_clause'. Also
+    // note that this number is usually way smaller than the number of
+    // occurrences computed before and stored in 'noccs'.
+    //
+    int minlit = 0;
+    int64_t minoccs = 0;
+    size_t minsize = 0;
+    bool subsume = true;
+    bool binary = (c->size == 2 && !c->redundant);
+
+    for (const auto &lit : *c) {
+
+      if (!flags (lit).subsume)
+        subsume = false;
+      const size_t size = binary ? bins (lit).size () : occs (lit).size ();
+      if (minlit && minsize <= size)
+        continue;
+      const int64_t tmp = noccs (lit);
+      if (minlit && minsize == size && tmp <= minoccs)
+        continue;
+      minlit = lit, minsize = size, minoccs = tmp;
+    }
+
+    // If there is a variable in a clause different from is not 'subsume'
+    // (has been added since the last subsumption round), then this clause
+    // can not serve to strengthen or subsume another clause, since all
+    // shrunken or added clauses mark all their variables as 'subsume'.
+    //
+    if (!subsume)
+      continue;
+
+    if (!binary) {
+
+      // If smallest occurring literal occurs too often do not connect.
+      //
+      if (minsize > (size_t) opts.subsumeocclim)
+        continue;
+
+      LOG (c,
+           "watching %d with %zd current and total %" PRId64 " occurrences",
+           minlit, minsize, minoccs);
+
+      occs (minlit).push_back (c);
+
+      // This sorting should give faster failures for assumption checks
+      // since the less occurring variables are put first in a clause and
+      // thus will make it more likely to be found as witness for a clause
+      // not to be subsuming.  One could in principle (see also the
+      // discussion on 'subsumption' in our 'Splatz' solver) replace marking
+      // by a kind of merge sort, as also suggested by Bayardo.  It would
+      // avoid 'marked' calls and thus might be slightly faster but could
+      // not take benefit of this sorting optimization.
+      //
+      sort (c->begin (), c->end (), subsume_less_noccs (this));
+
+    } else {
+
+      // If smallest occurring literal occurs too often do not connect.
+      //
+      if (minsize > (size_t) opts.subsumebinlim)
+        continue;
+
+      LOG (c,
+           "watching %d with %zd current binary and total %" PRId64
+           " occurrences",
+           minlit, minsize, minoccs);
+
+      const int minlit_pos = (c->literals[1] == minlit);
+      const int other = c->literals[!minlit_pos];
+      bins (minlit).push_back (Bin{other, c->id});
+    }
+  }
+
+  PHASE ("subsume-round", stats.subsumerounds,
+         "subsumed %" PRId64 " and strengthened %" PRId64 " out of %" PRId64
+         " clauses %.0f%%",
+         subsumed, strengthened, scheduled,
+         percent (subsumed + strengthened, scheduled));
+
+  const int64_t remain = schedule.size () - checked;
+  const bool completed = !remain;
+
+  if (completed)
+    PHASE ("subsume-round", stats.subsumerounds,
+           "checked all %" PRId64 " scheduled clauses", checked);
+  else
+    PHASE ("subsume-round", stats.subsumerounds,
+           "checked %" PRId64 " clauses %.0f%% of scheduled (%" PRId64
+           " remain)",
+           checked, percent (checked, scheduled), remain);
+
+  // Release occurrence lists and schedule.
+  //
+  erase_vector (schedule);
+  reset_noccs ();
+  reset_occs ();
+  reset_bins ();
+
+  // Reset all old 'added' flags and mark variables in shrunken
+  // clauses as 'added' for the next subsumption round.
+  //
+  if (completed)
+    reset_subsume_bits ();
+
+  for (const auto &c : shrunken)
+    mark_added (c);
+  erase_vector (shrunken);
+
+  report ('s', !opts.reportall && !(subsumed + strengthened));
+
+  STOP_SIMPLIFIER (subsume, SUBSUME);
+
+  return old_marked_candidate_variables_for_elimination < stats.mark.elim;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::subsume () {
+
+  if (!stats.current.redundant && !stats.current.irredundant)
+    return;
+
+  if (unsat)
+    return;
+
+  backtrack ();
+  if (!propagate ()) {
+    learn_empty_clause ();
+    return;
+  }
+
+  stats.subsumephases++;
+
+  if (external_prop) {
+    CADICAL_assert (!level);
+    private_steps = true;
+  }
+
+  if (opts.subsume) {
+    reset_watches ();
+    subsume_round ();
+    init_watches ();
+    connect_watches ();
+    if (!unsat && !propagate ()) {
+      LOG ("propagation after subsume rounds results in inconsistency");
+      learn_empty_clause ();
+    }
+  }
+
+  transred ();
+  if (external_prop) {
+    CADICAL_assert (!level);
+    private_steps = false;
+  }
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_sweep.cpp b/src/sat/cadical/cadical_sweep.cpp
new file mode 100644
index 000000000..4dca2b4bc
--- /dev/null
+++ b/src/sat/cadical/cadical_sweep.cpp
@@ -0,0 +1,1959 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+Sweeper::Sweeper (Internal *i)
+    : internal (i), random (internal->opts.seed) {
+  random += internal->stats.sweep; // different seed every time
+  internal->init_sweeper (*this);
+}
+
+Sweeper::~Sweeper () {
+  // this is already called actively
+  // internal->release_sweeper (this);
+  return;
+}
+
+#define INVALID64 INT64_MAX
+#define INVALID UINT_MAX
+
+int Internal::sweep_solve () {
+  START (sweepsolve);
+  cadical_kitten_randomize_phases (citten);
+  stats.sweep_solved++;
+  int res = cadical_kitten_solve (citten);
+  if (res == 10)
+    stats.sweep_sat++;
+  if (res == 20)
+    stats.sweep_unsat++;
+  STOP (sweepsolve);
+  return res;
+}
+
+bool Internal::sweep_flip (int lit) {
+  START (sweepflip);
+  bool res = cadical_kitten_flip_signed_literal (citten, lit);
+  STOP (sweepflip);
+  return res;
+}
+
+int Internal::sweep_flip_and_implicant (int lit) {
+  START (sweepimplicant);
+  int res = cadical_kitten_flip_and_implicant_for_signed_literal (citten, lit);
+  STOP (sweepimplicant);
+  return res;
+}
+
+void Internal::sweep_set_cadical_kitten_ticks_limit (Sweeper &sweeper) {
+  uint64_t remaining = 0;
+  const uint64_t current = sweeper.current_ticks;
+  if (current < sweeper.limit.ticks)
+    remaining = sweeper.limit.ticks - current;
+  LOG ("'cadical_kitten_ticks' remaining %" PRIu64, remaining);
+  cadical_kitten_set_ticks_limit (citten, remaining);
+}
+
+void Internal::sweep_update_noccs (Clause *c) {
+  if (c->redundant)
+    return;
+  for (const auto &lit : *c) {
+    noccs (lit)--;
+  }
+}
+
+bool Internal::can_sweep_clause (Clause *c) {
+  if (c->garbage)
+    return false;
+  if (!c->redundant)
+    return true;
+  return c->size == 2; // && !c->hyper;  // could ignore hyper
+}
+
+// essentially do full occurence list as in elim.cpp
+void Internal::sweep_dense_mode_and_watch_irredundant () {
+  reset_watches ();
+
+  init_noccs ();
+
+  // mark satisfied irredundant clauses as garbage
+  for (const auto &c : clauses) {
+    if (!can_sweep_clause (c))
+      continue;
+    bool satisfied = false;
+    for (const auto &lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp <= 0)
+        continue;
+      if (tmp > 0) {
+        satisfied = true;
+        break;
+      }
+    }
+    if (satisfied)
+      mark_garbage (c); // forces more precise counts
+    else {
+      for (const auto &lit : *c)
+        noccs (lit)++;
+    }
+  }
+
+  init_occs ();
+
+  // Connect irredundant clauses.
+  //
+  for (const auto &c : clauses) {
+    if (!c->garbage) {
+      for (const auto &lit : *c)
+        if (active (lit))
+          occs (lit).push_back (c);
+    } else if (c->size == 2) {
+      if (!c->flushed) {
+        if (proof) {
+          c->flushed = true;
+          proof->delete_clause (c);
+        }
+      }
+    }
+  }
+}
+
+// go back to two watch scheme
+void Internal::sweep_sparse_mode () {
+  reset_occs ();
+  reset_noccs ();
+  init_watches ();
+  connect_watches ();
+}
+
+// propagate without watches but full occurence list
+void Internal::sweep_dense_propagate (Sweeper &sweeper) {
+  vector<int> &work = sweeper.propagate;
+  size_t i = 0;
+  uint64_t &ticks = sweeper.current_ticks;
+  while (i < work.size ()) {
+    int lit = work[i++];
+    LOG ("sweeping propagation of %d", lit);
+    CADICAL_assert (val (lit) > 0);
+    ticks += 1 + cache_lines (occs (-lit).size (), sizeof (Clause *));
+    const Occs &ns = occs (-lit);
+    for (const auto &c : ns) {
+      ticks++;
+      if (!can_sweep_clause (c))
+        continue;
+      int unit = 0, satisfied = 0;
+      for (const auto &other : *c) {
+        const signed char tmp = val (other);
+        if (tmp < 0)
+          continue;
+        if (tmp > 0) {
+          satisfied = other;
+          break;
+        }
+        if (unit)
+          unit = INT_MIN;
+        else
+          unit = other;
+      }
+      if (satisfied) {
+        LOG (c, "sweeping propagation of %d finds %d satisfied", lit,
+             satisfied);
+        mark_garbage (c);
+        sweep_update_noccs (c);
+      } else if (!unit) {
+        LOG ("empty clause during sweeping propagation of %d", lit);
+        // need to set conflict = c for lrat
+        conflict = c;
+        learn_empty_clause ();
+        conflict = 0;
+        break;
+      } else if (unit != INT_MIN) {
+        LOG ("new unit %d during sweeping propagation of %d", unit, lit);
+        build_chain_for_units (unit, c, 0);
+        assign_unit (unit);
+        work.push_back (unit);
+        ticks++;
+      }
+    }
+    if (unsat)
+      break;
+
+    // not necessary but should help
+    ticks += 1 + cache_lines (occs (lit).size (), sizeof (Clause *));
+    const Occs &ps = occs (lit);
+    for (const auto &c : ps) {
+      ticks++;
+      if (c->garbage)
+        continue;
+      // if (c->redundant)  // TODO I assume it does not hurt to mark
+      // everything here continue;
+      LOG (c, "sweeping propagation of %d produces satisfied", lit);
+      mark_garbage (c);
+      sweep_update_noccs (c);
+    }
+  }
+  work.clear ();
+}
+
+bool Internal::cadical_kitten_ticks_limit_hit (Sweeper &sweeper, const char *when) {
+  const uint64_t current =
+      cadical_kitten_current_ticks (citten) + sweeper.current_ticks;
+  if (current >= sweeper.limit.ticks) {
+    LOG ("'cadical_kitten_ticks' limit of %" PRIu64 " ticks hit after %" PRIu64
+         " ticks during %s",
+         sweeper.limit.ticks, current, when);
+    return true;
+  }
+#ifndef LOGGING
+  (void) when;
+#endif
+  return false;
+}
+
+void Internal::init_sweeper (Sweeper &sweeper) {
+  sweeper.encoded = 0;
+  enlarge_zero (sweeper.depths, max_var + 1);
+  sweeper.reprs = new int[2 * max_var + 1];
+  sweeper.reprs += max_var;
+  enlarge_zero (sweeper.prev, max_var + 1);
+  enlarge_zero (sweeper.next, max_var + 1);
+  for (const auto &lit : lits)
+    sweeper.reprs[lit] = lit;
+  sweeper.first = sweeper.last = 0;
+  sweeper.current_ticks =
+      2 *
+      clauses
+          .size (); // initialize with the cost of building full occ list.
+  sweeper.current_ticks +=
+      2 + 2 * cache_lines (clauses.size (), sizeof (Clause *));
+  CADICAL_assert (!citten);
+  citten = cadical_kitten_init ();
+  citten_clear_track_log_terminate ();
+
+  sweep_dense_mode_and_watch_irredundant (); // full occurence list
+
+  if (lrat) {
+    sweeper.prev_units.push_back (0);
+    for (const auto &idx : vars) {
+      sweeper.prev_units.push_back (val (idx) != 0);
+    }
+  }
+
+  unsigned completed = stats.sweep_completed;
+  const unsigned max_completed = 32;
+  if (completed > max_completed)
+    completed = max_completed;
+
+  uint64_t vars_limit = opts.sweepvars;
+  vars_limit <<= completed;
+  const unsigned max_vars_limit = opts.sweepmaxvars;
+  if (vars_limit > max_vars_limit)
+    vars_limit = max_vars_limit;
+  sweeper.limit.vars = vars_limit;
+  VERBOSE (3, "sweeper variable limit %u", sweeper.limit.vars);
+
+  uint64_t depth_limit = stats.sweep_completed;
+  depth_limit += opts.sweepdepth;
+  const unsigned max_depth = opts.sweepmaxdepth;
+  if (depth_limit > max_depth)
+    depth_limit = max_depth;
+  sweeper.limit.depth = depth_limit;
+  VERBOSE (3, "sweeper depth limit %u", sweeper.limit.depth);
+
+  uint64_t clause_limit = opts.sweepclauses;
+  clause_limit <<= completed;
+  const unsigned max_clause_limit = opts.sweepmaxclauses;
+  if (clause_limit > max_clause_limit)
+    clause_limit = max_clause_limit;
+  sweeper.limit.clauses = clause_limit;
+  VERBOSE (3, "sweeper clause limit %u", sweeper.limit.clauses);
+}
+
+void Internal::release_sweeper (Sweeper &sweeper) {
+
+  sweeper.reprs -= max_var;
+  delete[] sweeper.reprs;
+
+  erase_vector (sweeper.depths);
+  erase_vector (sweeper.prev);
+  erase_vector (sweeper.next);
+  erase_vector (sweeper.vars);
+  erase_vector (sweeper.clause);
+  erase_vector (sweeper.backbone);
+  erase_vector (sweeper.partition);
+  erase_vector (sweeper.prev_units);
+  for (unsigned i = 0; i < 2; i++)
+    erase_vector (sweeper.core[i]);
+
+  cadical_kitten_release (citten);
+  citten = 0;
+  stats.ticks.sweep += sweeper.current_ticks;
+  sweep_sparse_mode ();
+  return;
+}
+
+void Internal::clear_sweeper (Sweeper &sweeper) {
+  LOG ("clearing sweeping environment");
+  sweeper.current_ticks += cadical_kitten_current_ticks (citten);
+
+  citten_clear_track_log_terminate ();
+  for (auto &idx : sweeper.vars) {
+    CADICAL_assert (sweeper.depths[idx]);
+    sweeper.depths[idx] = 0;
+  }
+  sweeper.vars.clear ();
+  for (auto c : sweeper.clauses) {
+    CADICAL_assert (c->swept);
+    c->swept = false;
+  }
+  sweeper.clauses.clear ();
+  sweeper.backbone.clear ();
+  sweeper.partition.clear ();
+  sweeper.encoded = 0;
+  sweep_set_cadical_kitten_ticks_limit (sweeper);
+}
+
+int Internal::sweep_repr (Sweeper &sweeper, int lit) {
+  int res;
+  {
+    int prev = lit;
+    while ((res = sweeper.reprs[prev]) != prev)
+      prev = res;
+  }
+  if (res == lit)
+    return res;
+  LOG ("sweeping repr[%d] = %d", lit, res);
+  {
+    const int not_res = -res;
+    int next, prev = lit;
+    while ((next = sweeper.reprs[prev]) != res) {
+      const int not_prev = -prev;
+      sweeper.reprs[not_prev] = not_res;
+      sweeper.reprs[prev] = res;
+      prev = next;
+    }
+    CADICAL_assert (sweeper.reprs[-prev] == not_res);
+  }
+  return res;
+}
+
+void Internal::add_literal_to_environment (Sweeper &sweeper, unsigned depth,
+                                           int lit) {
+  const int repr = sweep_repr (sweeper, lit);
+  if (repr != lit)
+    return;
+  const int idx = abs (lit);
+  if (sweeper.depths[idx])
+    return;
+  CADICAL_assert (depth < UINT_MAX);
+  sweeper.depths[idx] = depth + 1;
+  CADICAL_assert (idx);
+  sweeper.vars.push_back (idx);
+  LOG ("sweeping[%u] adding literal %d", depth, lit);
+}
+
+void Internal::sweep_add_clause (Sweeper &sweeper, unsigned depth) {
+  // TODO: CADICAL_assertion fails, check if this an issue or can be avoided
+  // CADICAL_assert (sweeper.clause.size () > 1);
+  for (const auto &lit : sweeper.clause)
+    add_literal_to_environment (sweeper, depth, lit);
+  citten_clause_with_id (citten, sweeper.clauses.size (),
+                         sweeper.clause.size (), sweeper.clause.data ());
+  sweeper.clause.clear ();
+  if (opts.sweepcountbinary || sweeper.clause.size () > 2)
+    sweeper.encoded++;
+}
+
+void Internal::sweep_clause (Sweeper &sweeper, unsigned depth, Clause *c) {
+  if (c->swept)
+    return;
+  CADICAL_assert (can_sweep_clause (c));
+  LOG (c, "sweeping[%u]", depth);
+  CADICAL_assert (sweeper.clause.empty ());
+  for (const auto &lit : *c) {
+    const signed char tmp = val (lit);
+    if (tmp > 0) {
+      mark_garbage (c);
+      sweep_update_noccs (c);
+      sweeper.clause.clear ();
+      return;
+    }
+    if (tmp < 0) {
+      if (lrat)
+        sweeper.prev_units[abs (lit)] = true;
+      continue;
+    }
+    sweeper.clause.push_back (lit);
+  }
+  c->swept = true;
+  sweep_add_clause (sweeper, depth);
+  sweeper.clauses.push_back (c);
+}
+
+extern "C" {
+static void save_core_clause (void *state, unsigned id, bool learned,
+                              size_t size, const unsigned *lits) {
+  Sweeper *sweeper = (Sweeper *) state;
+  Internal *internal = sweeper->internal;
+  if (internal->unsat)
+    return;
+  vector<sweep_proof_clause> &core = sweeper->core[sweeper->save];
+  sweep_proof_clause pc;
+  if (learned) {
+    pc.sweep_id = INVALID; // necessary
+    pc.cad_id = INVALID64; // delay giving ids
+  } else {
+    pc.sweep_id = id; // necessary
+    CADICAL_assert (id < sweeper->clauses.size ());
+    pc.cad_id = sweeper->clauses[id]->id;
+  }
+  pc.kit_id = 0;
+  pc.learned = learned;
+  const unsigned *end = lits + size;
+  for (const unsigned *p = lits; p != end; p++) {
+    pc.literals.push_back (internal->citten2lit (*p)); // conversion
+  }
+#ifdef LOGGING
+  LOG (pc.literals, "traced %s",
+       pc.learned == true ? "learned" : "original");
+#endif
+  core.push_back (pc);
+}
+
+static void save_core_clause_with_lrat (void *state, unsigned cid,
+                                        unsigned id, bool learned,
+                                        size_t size, const unsigned *lits,
+                                        size_t chain_size,
+                                        const unsigned *chain) {
+  Sweeper *sweeper = (Sweeper *) state;
+  Internal *internal = sweeper->internal;
+  if (internal->unsat)
+    return;
+  vector<sweep_proof_clause> &core = sweeper->core[sweeper->save];
+  vector<Clause *> &clauses = sweeper->clauses;
+  sweep_proof_clause pc;
+  pc.kit_id = cid;
+  pc.learned = learned;
+  pc.sweep_id = INVALID;
+  pc.cad_id = INVALID64;
+  if (!learned) {
+    CADICAL_assert (size);
+    CADICAL_assert (!chain_size);
+    CADICAL_assert (id < clauses.size ());
+    pc.sweep_id = id;
+    CADICAL_assert (id < clauses.size ());
+    pc.cad_id = clauses[id]->id;
+    for (const auto &lit : *clauses[id]) {
+      pc.literals.push_back (lit);
+    }
+  } else {
+    CADICAL_assert (chain_size);
+    pc.sweep_id = INVALID;
+    pc.cad_id = INVALID64; // delay giving ids
+    const unsigned *end = lits + size;
+    for (const unsigned *p = lits; p != end; p++) {
+      pc.literals.push_back (internal->citten2lit (*p)); // conversion
+    }
+    for (const unsigned *p = chain + chain_size; p != chain; p--) {
+      pc.chain.push_back (*(p - 1));
+    }
+  }
+#ifdef LOGGING
+  if (learned)
+    LOG (pc.literals, "traced %s",
+         pc.learned == true ? "learned" : "original");
+  else {
+    CADICAL_assert (id < clauses.size ());
+    LOG (clauses[id], "traced");
+  }
+#endif
+  core.push_back (pc);
+}
+
+static int citten_terminate (void *data) {
+  return ((Internal *) data)->terminated_asynchronously ();
+}
+
+} // end extern C
+
+void Internal::citten_clear_track_log_terminate () {
+  CADICAL_assert (citten);
+  cadical_kitten_clear (citten);
+  cadical_kitten_track_antecedents (citten);
+  if (external->terminator)
+    cadical_kitten_set_terminator (citten, internal, citten_terminate);
+#ifdef LOGGING
+  if (opts.log)
+    cadical_kitten_set_logging (citten);
+#endif
+}
+
+void Internal::add_core (Sweeper &sweeper, unsigned core_idx) {
+  if (unsat)
+    return;
+  LOG ("check and add extracted core[%u] lemmas to proof", core_idx);
+  CADICAL_assert (core_idx == 0 || core_idx == 1);
+  vector<sweep_proof_clause> &core = sweeper.core[core_idx];
+
+  CADICAL_assert (!lrat || proof);
+
+  unsigned unsat_size = 0;
+  for (auto &pc : core) {
+    unsat_size++;
+
+    if (!pc.learned) {
+      LOG (pc.literals,
+           "not adding already present core[%u] cadical_kitten[%u] clause",
+           core_idx, pc.kit_id);
+      continue;
+    }
+
+    LOG (pc.literals, "adding extracted core[%u] cadical_kitten[%u] lemma",
+         core_idx, pc.kit_id);
+
+    const unsigned new_size = pc.literals.size ();
+
+    if (lrat) {
+      CADICAL_assert (pc.cad_id == INVALID64);
+      for (auto &cid : pc.chain) {
+        int64_t id = 0;
+        for (const auto &cpc : core) {
+          if (cpc.kit_id == cid) {
+            if (cpc.learned)
+              id = cpc.cad_id;
+            else {
+              id = cpc.cad_id;
+              CADICAL_assert (cpc.cad_id == sweeper.clauses[cpc.sweep_id]->id);
+              CADICAL_assert (!sweeper.clauses[cpc.sweep_id]->garbage);
+              // avoid duplicate ids of units with seen flags
+              for (const auto &lit : cpc.literals) {
+                if (val (lit) >= 0)
+                  continue;
+                if (flags (lit).seen)
+                  continue;
+                const int idx = abs (lit);
+                if (sweeper.prev_units[idx]) {
+                  int64_t uid = unit_id (-lit);
+                  lrat_chain.push_back (uid);
+                  analyzed.push_back (lit);
+                  flags (lit).seen = true;
+                }
+              }
+            }
+            break;
+          }
+        }
+        CADICAL_assert (id);
+        if (id != INVALID64)
+          lrat_chain.push_back (id);
+      }
+      clear_analyzed_literals ();
+    }
+
+    if (!new_size) {
+      LOG ("sweeping produced empty clause");
+      learn_empty_clause ();
+      core.resize (unsat_size);
+      return;
+    }
+
+    if (new_size == 1) {
+      int unit = pc.literals[0];
+      if (val (unit) > 0) {
+        LOG ("already assigned sweeping unit %d", unit);
+        lrat_chain.clear ();
+      } else if (val (unit) < 0) {
+        LOG ("falsified sweeping unit %d leads to empty clause", unit);
+        if (lrat) {
+          int64_t id = unit_id (-unit);
+          lrat_chain.push_back (id);
+        }
+        learn_empty_clause ();
+        core.resize (unsat_size);
+        return;
+      } else {
+        LOG ("sweeping produced unit %d", unit);
+        assign_unit (unit);
+        stats.sweep_units++;
+        sweeper.propagate.push_back (unit);
+      }
+      if (proof && lrat)
+        pc.cad_id = unit_id (unit);
+      continue;
+    }
+
+    CADICAL_assert (new_size > 1);
+    CADICAL_assert (pc.learned);
+
+    if (proof) {
+      pc.cad_id = ++clause_id;
+      proof->add_derived_clause (pc.cad_id, true, pc.literals, lrat_chain);
+      lrat_chain.clear ();
+    }
+  }
+}
+
+void Internal::save_core (Sweeper &sweeper, unsigned core) {
+  LOG ("saving extracted core[%u] lemmas", core);
+  CADICAL_assert (core == 0 || core == 1);
+  CADICAL_assert (sweeper.core[core].empty ());
+  sweeper.save = core;
+  cadical_kitten_compute_clausal_core (citten, 0);
+  if (lrat)
+    cadical_kitten_trace_core (citten, &sweeper, save_core_clause_with_lrat);
+  else
+    cadical_kitten_traverse_core_clauses_with_id (citten, &sweeper,
+                                          save_core_clause);
+}
+
+void Internal::clear_core (Sweeper &sweeper, unsigned core_idx) {
+  CADICAL_assert (core_idx == 0 || core_idx == 1);
+  LOG ("clearing core[%u] lemmas", core_idx);
+  vector<sweep_proof_clause> &core = sweeper.core[core_idx];
+  if (proof) {
+    LOG ("deleting sub-solver core clauses");
+    for (auto &pc : core) {
+      if (pc.learned && pc.literals.size () > 1)
+        proof->delete_clause (pc.cad_id, true, pc.literals);
+    }
+  }
+  core.clear ();
+}
+
+void Internal::save_add_clear_core (Sweeper &sweeper) {
+  save_core (sweeper, 0);
+  add_core (sweeper, 0);
+  clear_core (sweeper, 0);
+}
+
+void Internal::init_backbone_and_partition (Sweeper &sweeper) {
+  LOG ("initializing backbone and equivalent literals candidates");
+  sweeper.backbone.clear ();
+  sweeper.partition.clear ();
+  for (const auto &idx : sweeper.vars) {
+    if (!active (idx))
+      continue;
+    CADICAL_assert (idx > 0);
+    const int lit = idx;
+    const int not_lit = -lit;
+    const signed char tmp = cadical_kitten_signed_value (citten, lit);
+    const int candidate = (tmp < 0) ? not_lit : lit;
+    LOG ("sweeping candidate %d", candidate);
+    sweeper.backbone.push_back (candidate);
+    sweeper.partition.push_back (candidate);
+  }
+  sweeper.partition.push_back (0);
+
+  LOG (sweeper.backbone, "initialized backbone candidates");
+  LOG (sweeper.partition, "initialized equivalence candidates");
+}
+
+void Internal::sweep_empty_clause (Sweeper &sweeper) {
+  CADICAL_assert (!unsat);
+  save_add_clear_core (sweeper);
+  CADICAL_assert (unsat);
+}
+
+void Internal::sweep_refine_partition (Sweeper &sweeper) {
+  LOG ("refining partition");
+  vector<int> &old_partition = sweeper.partition;
+  vector<int> new_partition;
+  auto old_begin = old_partition.begin ();
+  const auto old_end = old_partition.end ();
+#ifdef LOGGING
+  unsigned old_classes = 0;
+  unsigned new_classes = 0;
+#endif
+  for (auto p = old_begin, q = p; p != old_end; p = q + 1) {
+    unsigned assigned_true = 0;
+    int other;
+    for (q = p; (other = *q) != 0; q++) {
+      if (sweep_repr (sweeper, other) != other)
+        continue;
+      if (val (other))
+        continue;
+      signed char value = cadical_kitten_signed_value (citten, other);
+      if (!value)
+        LOG ("dropping sub-solver unassigned %d", other);
+      else if (value > 0) {
+        new_partition.push_back (other);
+        assigned_true++;
+      }
+    }
+#ifdef LOGGING
+    LOG ("refining class %u of size %zu", old_classes, (size_t) (q - p));
+    old_classes++;
+#endif
+    if (assigned_true == 0)
+      LOG ("no positive literal in class");
+    else if (assigned_true == 1) {
+#ifdef LOGGING
+      other =
+#else
+      (void)
+#endif
+          new_partition.back ();
+      new_partition.pop_back ();
+      LOG ("dropping singleton class %d", other);
+    } else {
+      LOG ("%u positive literal in class", assigned_true);
+      new_partition.push_back (0);
+#ifdef LOGGING
+      new_classes++;
+#endif
+    }
+
+    unsigned assigned_false = 0;
+    for (q = p; (other = *q) != 0; q++) {
+      if (sweep_repr (sweeper, other) != other)
+        continue;
+      if (val (other))
+        continue;
+      signed char value = cadical_kitten_signed_value (citten, other);
+      if (value < 0) {
+        new_partition.push_back (other);
+        assigned_false++;
+      }
+    }
+
+    if (assigned_false == 0)
+      LOG ("no negative literal in class");
+    else if (assigned_false == 1) {
+#ifdef LOGGING
+      other =
+#else
+      (void)
+#endif
+          new_partition.back ();
+      new_partition.pop_back ();
+      LOG ("dropping singleton class %d", other);
+    } else {
+      LOG ("%u negative literal in class", assigned_false);
+      new_partition.push_back (0);
+#ifdef LOGGING
+      new_classes++;
+#endif
+    }
+  }
+  old_partition.swap (new_partition);
+  LOG ("refined %u classes into %u", old_classes, new_classes);
+}
+
+void Internal::sweep_refine_backbone (Sweeper &sweeper) {
+  LOG ("refining backbone candidates");
+  const auto end = sweeper.backbone.end ();
+  auto q = sweeper.backbone.begin ();
+  for (auto p = q; p != end; p++) {
+    const int lit = *p;
+    if (val (lit))
+      continue;
+    signed char value = cadical_kitten_signed_value (citten, lit);
+    if (!value)
+      LOG ("dropping sub-solver unassigned %d", lit);
+    else if (value > 0)
+      *q++ = lit;
+  }
+  sweeper.backbone.resize (q - sweeper.backbone.begin ());
+}
+
+void Internal::sweep_refine (Sweeper &sweeper) {
+  CADICAL_assert (cadical_kitten_status (citten) == 10);
+  if (sweeper.backbone.empty ())
+    LOG ("no need to refine empty backbone candidates");
+  else
+    sweep_refine_backbone (sweeper);
+  if (sweeper.partition.empty ())
+    LOG ("no need to refine empty partition candidates");
+  else
+    sweep_refine_partition (sweeper);
+}
+
+void Internal::flip_backbone_literals (Sweeper &sweeper) {
+  const unsigned max_rounds = opts.sweepfliprounds;
+  if (!max_rounds)
+    return;
+  CADICAL_assert (sweeper.backbone.size ());
+  if (cadical_kitten_status (citten) != 10)
+    return;
+#ifdef LOGGING
+  unsigned total_flipped = 0;
+#endif
+  unsigned flipped, round = 0;
+  do {
+    round++;
+    flipped = 0;
+    bool refine = false;
+    auto begin = sweeper.backbone.begin (), q = begin, p = q;
+    const auto end = sweeper.backbone.end ();
+    bool limit_hit = false;
+    while (p != end) {
+      const int lit = *p++;
+      stats.sweep_flip_backbone++;
+      if (limit_hit || terminated_asynchronously ()) {
+        break;
+      } else if (sweep_flip (lit)) {
+        LOG ("flipping backbone candidate %d succeeded", lit);
+#ifdef LOGGING
+        total_flipped++;
+#endif
+        stats.sweep_flipped_backbone++;
+        flipped++;
+      } else {
+        LOG ("flipping backbone candidate %d failed", lit);
+        *q++ = lit;
+      }
+    }
+    while (p != end)
+      *q++ = *p++;
+    sweeper.backbone.resize (q - sweeper.backbone.begin ());
+    LOG ("flipped %u backbone candidates in round %u", flipped, round);
+
+    if (limit_hit)
+      break;
+    if (terminated_asynchronously ())
+      break;
+    if (cadical_kitten_ticks_limit_hit (sweeper, "backbone flipping"))
+      break;
+    if (refine)
+      sweep_refine (sweeper);
+  } while (flipped && round < max_rounds);
+  LOG ("flipped %u backbone candidates in total in %u rounds",
+       total_flipped, round);
+}
+
+bool Internal::sweep_extract_fixed (Sweeper &sweeper, int lit) {
+  const int not_lit = -lit;
+  stats.sweep_solved_backbone++;
+  cadical_kitten_assume_signed (citten, not_lit);
+  int res = sweep_solve ();
+  if (!res) {
+    stats.sweep_unknown_backbone++;
+    return false;
+  }
+  CADICAL_assert (res == 20);
+  LOG ("sweep unit %d", lit);
+  save_add_clear_core (sweeper);
+  stats.sweep_unsat_backbone++;
+  return true;
+}
+
+bool Internal::sweep_backbone_candidate (Sweeper &sweeper, int lit) {
+  LOG ("trying backbone candidate %d", lit);
+  signed char value = cadical_kitten_fixed_signed (citten, lit);
+  if (value) {
+    stats.sweep_fixed_backbone++;
+    CADICAL_assert (value > 0);
+    if (val (lit) <= 0) {
+      return sweep_extract_fixed (sweeper, lit);
+    } else
+      LOG ("literal %d already fixed", lit);
+    return false;
+  }
+
+  int res = cadical_kitten_status (citten);
+  if (res != 10) {
+    LOG ("not flipping due to status %d != 10", res);
+  }
+  stats.sweep_flip_backbone++;
+  if (res == 10 && sweep_flip (lit)) {
+    stats.sweep_flipped_backbone++;
+    LOG ("flipping %d succeeded", lit);
+    // LOGBACKBONE ("refined backbone candidates");
+    return false;
+  }
+
+  LOG ("flipping %d failed", lit);
+  const int not_lit = -lit;
+  stats.sweep_solved_backbone++;
+  cadical_kitten_assume_signed (citten, not_lit);
+  res = sweep_solve ();
+  if (res == 10) {
+    LOG ("sweeping backbone candidate %d failed", lit);
+    sweep_refine (sweeper);
+    stats.sweep_sat_backbone++;
+    return false;
+  }
+
+  if (res == 20) {
+    LOG ("sweep unit %d", lit);
+    save_add_clear_core (sweeper);
+    CADICAL_assert (val (lit));
+    stats.sweep_unsat_backbone++;
+    return true;
+  }
+
+  stats.sweep_unknown_backbone++;
+
+  LOG ("sweeping backbone candidate %d failed", lit);
+  return false;
+}
+
+// at this point the binary (lit or other) is already present
+// in the proof via 'add_core'.
+// We just copy it as an irredundant clause, call weaken minus
+// and push it on the extension stack.
+//
+int64_t Internal::add_sweep_binary (sweep_proof_clause pc, int lit,
+                                    int other) {
+  CADICAL_assert (!unsat);
+  if (unsat)
+    return 0; // sanity check, should be fuzzed
+
+  CADICAL_assert (!val (lit) && !val (other));
+  if (val (lit) || val (other))
+    return 0;
+
+  if (lrat) {
+    for (const auto &plit : pc.literals) {
+      if (val (plit)) {
+        int64_t id = unit_id (-plit);
+        lrat_chain.push_back (id);
+      }
+    }
+    lrat_chain.push_back (pc.cad_id);
+  }
+  clause.push_back (lit);
+  clause.push_back (other);
+  const int64_t id = ++clause_id;
+  if (proof) {
+    proof->add_derived_clause (id, false, clause, lrat_chain);
+    proof->weaken_minus (id, clause);
+  }
+  external->push_binary_clause_on_extension_stack (id, lit, other);
+  clause.clear ();
+  lrat_chain.clear ();
+  return id;
+}
+
+void Internal::delete_sweep_binary (const sweep_binary &sb) {
+  if (unsat)
+    return;
+  if (!proof)
+    return;
+  vector<int> bin;
+  bin.push_back (sb.lit);
+  bin.push_back (sb.other);
+  proof->delete_clause (sb.id, false, bin);
+}
+
+bool Internal::scheduled_variable (Sweeper &sweeper, int idx) {
+  return sweeper.prev[idx] != 0 || sweeper.first == idx;
+}
+
+void Internal::schedule_inner (Sweeper &sweeper, int idx) {
+  CADICAL_assert (idx);
+  if (!active (idx))
+    return;
+  const int next = sweeper.next[idx];
+  if (next != 0) {
+    LOG ("rescheduling inner %d as last", idx);
+    const unsigned prev = sweeper.prev[idx];
+    CADICAL_assert (sweeper.prev[next] == idx);
+    sweeper.prev[next] = prev;
+    if (prev == 0) {
+      CADICAL_assert (sweeper.first == idx);
+      sweeper.first = next;
+    } else {
+      CADICAL_assert (sweeper.next[prev] == idx);
+      sweeper.next[prev] = next;
+    }
+    const unsigned last = sweeper.last;
+    if (last == 0) {
+      CADICAL_assert (sweeper.first == 0);
+      sweeper.first = idx;
+    } else {
+      CADICAL_assert (sweeper.next[last] == 0);
+      sweeper.next[last] = idx;
+    }
+    sweeper.prev[idx] = last;
+    sweeper.next[idx] = 0;
+    sweeper.last = idx;
+  } else if (sweeper.last != idx) {
+    LOG ("scheduling inner %d as last", idx);
+    const unsigned last = sweeper.last;
+    if (last == 0) {
+      CADICAL_assert (sweeper.first == 0);
+      sweeper.first = idx;
+    } else {
+      CADICAL_assert (sweeper.next[last] == 0);
+      sweeper.next[last] = idx;
+    }
+    CADICAL_assert (sweeper.next[idx] == 0);
+    sweeper.prev[idx] = last;
+    sweeper.last = idx;
+  } else
+    LOG ("keeping inner %d scheduled as last", idx);
+}
+
+void Internal::schedule_outer (Sweeper &sweeper, int idx) {
+  CADICAL_assert (!scheduled_variable (sweeper, idx));
+  CADICAL_assert (active (idx));
+  const int first = sweeper.first;
+  if (first == 0) {
+    CADICAL_assert (sweeper.last == 0);
+    sweeper.last = idx;
+  } else {
+    CADICAL_assert (sweeper.prev[first] == 0);
+    sweeper.prev[first] = idx;
+  }
+  CADICAL_assert (sweeper.prev[idx] == 0);
+  sweeper.next[idx] = first;
+  sweeper.first = idx;
+  LOG ("scheduling outer %d as first", idx);
+}
+
+int Internal::next_scheduled (Sweeper &sweeper) {
+  int res = sweeper.last;
+  if (res == 0) {
+    LOG ("no more scheduled variables left");
+    return 0;
+  }
+  CADICAL_assert (res > 0);
+  LOG ("dequeuing next scheduled %d", res);
+  const unsigned prev = sweeper.prev[res];
+  CADICAL_assert (sweeper.next[res] == 0);
+  sweeper.prev[res] = 0;
+  if (prev == 0) {
+    CADICAL_assert (sweeper.first == res);
+    sweeper.first = 0;
+  } else {
+    CADICAL_assert (sweeper.next[prev] == res);
+    sweeper.next[prev] = 0;
+  }
+  sweeper.last = prev;
+  return res;
+}
+
+void Internal::sweep_substitute_lrat (Clause *c, int64_t id) {
+  if (!lrat)
+    return;
+  for (const auto &lit : *c) {
+    CADICAL_assert (val (lit) <= 0);
+    if (val (lit) < 0) {
+      int64_t id = unit_id (-lit);
+      lrat_chain.push_back (id);
+    }
+  }
+  lrat_chain.push_back (id);
+  lrat_chain.push_back (c->id);
+}
+
+#define all_scheduled(IDX) \
+  int IDX = sweeper.first, NEXT_##IDX; \
+  IDX != 0 && (NEXT_##IDX = sweeper.next[IDX], true); \
+  IDX = NEXT_##IDX
+
+// Substitute equivalences in clauses (see
+// 'sweep_substitute_new_equivalences' for explanation)
+void Internal::substitute_connected_clauses (Sweeper &sweeper, int lit,
+                                             int repr, int64_t id) {
+  if (unsat)
+    return;
+  if (val (lit))
+    return;
+  if (val (repr))
+    return;
+  LOG ("substituting %d with %d in all irredundant clauses", lit, repr);
+
+  CADICAL_assert (lit != repr);
+  CADICAL_assert (lit != -repr);
+
+  CADICAL_assert (active (lit));
+  CADICAL_assert (active (repr));
+
+  uint64_t &ticks = sweeper.current_ticks;
+
+  {
+    ticks += 1 + cache_lines (occs (lit).size (), sizeof (Clause *));
+    Occs &ns = occs (lit);
+    auto const begin = ns.begin ();
+    const auto end = ns.end ();
+    auto q = begin;
+    auto p = q;
+    while (p != end) {
+      Clause *c = *q++ = *p++;
+      ticks++;
+      if (c->garbage)
+        continue;
+      CADICAL_assert (clause.empty ());
+      bool satisfied = false;
+      bool repr_already_watched = false;
+      const int not_repr = -repr;
+#ifndef CADICAL_NDEBUG
+      bool found = false;
+#endif
+      for (const auto &other : *c) {
+        if (other == lit) {
+#ifndef CADICAL_NDEBUG
+          CADICAL_assert (!found);
+          found = true;
+#endif
+          clause.push_back (repr);
+          continue;
+        }
+        CADICAL_assert (other != -lit);
+        if (other == repr) {
+          CADICAL_assert (!repr_already_watched);
+          repr_already_watched = true;
+          continue;
+        }
+        if (other == not_repr) {
+          satisfied = true;
+          break;
+        }
+        const signed char tmp = val (other);
+        if (tmp < 0)
+          continue;
+        if (tmp > 0) {
+          satisfied = true;
+          break;
+        }
+        clause.push_back (other);
+      }
+      if (satisfied) {
+        clause.clear ();
+        mark_garbage (c);
+        sweep_update_noccs (c);
+        continue;
+      }
+      CADICAL_assert (found);
+      const unsigned new_size = clause.size ();
+      sweep_substitute_lrat (c, id);
+      if (new_size == 0) {
+        LOG (c, "substituted empty clause");
+        CADICAL_assert (!unsat);
+        learn_empty_clause ();
+        break;
+      }
+      ticks++;
+      if (new_size == 1) {
+        LOG (c, "reduces to unit");
+        const int unit = clause[0];
+        clause.clear ();
+        assign_unit (unit);
+        sweeper.propagate.push_back (unit);
+        mark_garbage (c);
+        sweep_update_noccs (c);
+        stats.sweep_units++;
+        break;
+      }
+      CADICAL_assert (c->size >= 2);
+      if (!c->redundant)
+        mark_removed (c);
+      uint64_t new_id = ++clause_id;
+      if (proof) {
+        proof->add_derived_clause (new_id, c->redundant, clause,
+                                   lrat_chain);
+        proof->delete_clause (c);
+      }
+      c->id = new_id;
+      lrat_chain.clear ();
+      size_t l;
+      int *literals = c->literals;
+      for (l = 0; l < clause.size (); l++)
+        literals[l] = clause[l];
+      int flushed = c->size - (int) l;
+      if (flushed) {
+        LOG ("flushed %d literals", flushed);
+        (void) shrink_clause (c, l);
+      } else if (likely_to_be_kept_clause (c))
+        mark_added (c);
+      LOG (c, "substituted");
+      if (!repr_already_watched) {
+        occs (repr).push_back (c);
+        noccs (repr)++;
+      }
+      clause.clear ();
+      q--;
+    }
+    while (p != end)
+      *q++ = *p++;
+    ns.resize (q - ns.begin ());
+  }
+}
+
+// In contrast to kissat we substitute the equivalences explicitely after
+// every successful round of sweeping. This is necessary in order to extract
+// valid LRAT proofs for subsequent rounds of sweeping.
+void Internal::sweep_substitute_new_equivalences (Sweeper &sweeper) {
+  if (unsat)
+    return;
+
+  unsigned count = 0;
+  CADICAL_assert (lrat_chain.empty ());
+
+  for (const auto &sb : sweeper.binaries) {
+    count++;
+    const auto lit = sb.lit;
+    const auto other = sb.other;
+    if (abs (lit) < abs (other)) {
+      substitute_connected_clauses (sweeper, -other, lit, sb.id);
+    } else {
+      substitute_connected_clauses (sweeper, -lit, other, sb.id);
+    }
+    CADICAL_assert (lrat_chain.empty ());
+    if (val (lit) < 0) {
+      if (lrat) {
+        const int64_t lid = unit_id (-lit);
+        lrat_chain.push_back (lid);
+      }
+      if (!val (other)) {
+        if (lrat)
+          lrat_chain.push_back (sb.id);
+        assign_unit (other);
+      } else if (val (other) < 0) {
+        if (lrat) {
+          const int64_t oid = unit_id (-other);
+          lrat_chain.push_back (oid);
+          lrat_chain.push_back (sb.id);
+        }
+        learn_empty_clause ();
+        return;
+      }
+    } else if (val (other) < 0) {
+      if (!val (lit)) {
+        if (lrat) {
+          const int64_t oid = unit_id (-other);
+          lrat_chain.push_back (oid);
+          lrat_chain.push_back (sb.id);
+        }
+        assign_unit (lit);
+      } else
+        CADICAL_assert (val (lit) > 0);
+    }
+    lrat_chain.clear ();
+    delete_sweep_binary (sb);
+    if (count == 2) {
+      if (!val (lit) && !val (other)) {
+        const auto idx = abs (lit) < abs (other) ? abs (other) : abs (lit);
+        if (!flags (idx).fixed ())
+          mark_substituted (idx);
+      }
+      count = 0;
+    }
+    CADICAL_assert (lrat_chain.empty ());
+  }
+  sweeper.binaries.clear ();
+}
+
+void Internal::sweep_remove (Sweeper &sweeper, int lit) {
+  CADICAL_assert (sweeper.reprs[lit] != lit);
+  vector<int> &partition = sweeper.partition;
+  const auto begin_partition = partition.begin ();
+  auto p = begin_partition;
+  const auto end_partition = partition.end ();
+  for (; *p != lit; p++)
+    CADICAL_assert (p + 1 != end_partition);
+  auto begin_class = p;
+  while (begin_class != begin_partition && begin_class[-1] != 0)
+    begin_class--;
+  auto end_class = p;
+  while (*end_class != 0)
+    end_class++;
+  const unsigned size = end_class - begin_class;
+  LOG ("removing non-representative %d from equivalence class of size %u",
+       lit, size);
+  CADICAL_assert (size > 1);
+  auto q = begin_class;
+  if (size == 2) {
+    LOG ("completely squashing equivalence class of %d", lit);
+    for (auto r = end_class + 1; r != end_partition; r++)
+      *q++ = *r;
+  } else {
+    for (auto r = begin_class; r != end_partition; r++)
+      if (r != p)
+        *q++ = *r;
+  }
+  partition.resize (q - partition.begin ());
+}
+
+void Internal::flip_partition_literals (Sweeper &sweeper) {
+  const unsigned max_rounds = opts.sweepfliprounds;
+  if (!max_rounds)
+    return;
+  CADICAL_assert (sweeper.partition.size ());
+  if (cadical_kitten_status (citten) != 10)
+    return;
+#ifdef LOGGING
+  unsigned total_flipped = 0;
+#endif
+  unsigned flipped, round = 0;
+  do {
+    round++;
+    flipped = 0;
+    bool refine = false;
+    bool limit_hit = false;
+    auto begin = sweeper.partition.begin (), dst = begin, src = dst;
+    const auto end = sweeper.partition.end ();
+    while (src != end) {
+      auto end_src = src;
+      while (CADICAL_assert (end_src != end), *end_src != 0)
+        end_src++;
+      unsigned size = end_src - src;
+      CADICAL_assert (size > 1);
+      auto q = dst;
+      for (auto p = src; p != end_src; p++) {
+        const int lit = *p;
+        if (limit_hit) {
+          *q++ = lit;
+          continue;
+        } else if (cadical_kitten_ticks_limit_hit (sweeper, "partition flipping")) {
+          *q++ = lit;
+          limit_hit = true;
+          continue;
+        } else if (sweep_flip (lit)) {
+          LOG ("flipping equivalence candidate %d succeeded", lit);
+#ifdef LOGGING
+          total_flipped++;
+#endif
+          flipped++;
+          if (--size < 2)
+            break;
+        } else {
+          LOG ("flipping equivalence candidate %d failed", lit);
+          *q++ = lit;
+        }
+        stats.sweep_flip_equivalences++;
+      }
+      if (size > 1) {
+        *q++ = 0;
+        dst = q;
+      }
+      src = end_src + 1;
+    }
+    stats.sweep_flipped_equivalences += flipped;
+    sweeper.partition.resize (dst - sweeper.partition.begin ());
+    LOG ("flipped %u equivalence candidates in round %u", flipped, round);
+    if (terminated_asynchronously ())
+      break;
+    if (cadical_kitten_ticks_limit_hit (sweeper, "partition flipping"))
+      break;
+    if (refine)
+      sweep_refine (sweeper);
+  } while (flipped && round < max_rounds);
+  LOG ("flipped %u equivalence candidates in total in %u rounds",
+       total_flipped, round);
+}
+
+bool Internal::sweep_equivalence_candidates (Sweeper &sweeper, int lit,
+                                             int other) {
+  LOG ("trying equivalence candidates %d = %d", lit, other);
+  const auto begin = sweeper.partition.begin ();
+  auto const end = sweeper.partition.end ();
+  CADICAL_assert (begin + 3 <= end);
+  CADICAL_assert (end[-3] == lit);
+  CADICAL_assert (end[-2] == other);
+  const int third = (end - begin == 3) ? 0 : end[-4];
+  int res = cadical_kitten_status (citten);
+  if (res == 10) {
+    stats.sweep_flip_equivalences++;
+    if (sweep_flip (lit)) {
+      stats.sweep_flipped_equivalences++;
+      LOG ("flipping %d succeeded", lit);
+      if (third == 0) {
+        LOG ("squashing equivalence class of %d", lit);
+        sweeper.partition.resize (sweeper.partition.size () - 3);
+      } else {
+        LOG ("removing %d from equivalence class of %d", lit, other);
+        end[-3] = other;
+        end[-2] = 0;
+        sweeper.partition.resize (sweeper.partition.size () - 1);
+      }
+      return false;
+    }
+    stats.sweep_flip_equivalences++;
+    if (sweep_flip (other)) {
+      stats.sweep_flipped_equivalences++;
+      LOG ("flipping %d succeeded", other);
+      if (third == 0) {
+        LOG ("squashing equivalence class of %d", lit);
+        sweeper.partition.resize (sweeper.partition.size () - 3);
+      } else {
+        LOG ("removing %d from equivalence class of %d", other, lit);
+        end[-2] = 0;
+        sweeper.partition.resize (sweeper.partition.size () - 1);
+      }
+      return false;
+    }
+  }
+  // frozen variables are not allowed to be eliminated.
+  // It might still be beneficial to learn the binaries, if they
+  // really are equivalent, but we avoid the issue by not trying
+  // for equivalence at all if the non-representative is frozen.
+  // i.e., the higher absolute value
+  if (abs (lit) > abs (other) && frozen (lit)) {
+    if (third == 0) {
+      LOG ("squashing equivalence class of %d", lit);
+      sweeper.partition.resize (sweeper.partition.size () - 3);
+    } else {
+      LOG ("removing %d from equivalence class of %d", lit, other);
+      end[-3] = other;
+      end[-2] = 0;
+      sweeper.partition.resize (sweeper.partition.size () - 1);
+    }
+    return false;
+  } else if (abs (other) > abs (lit) && frozen (other)) {
+    if (third == 0) {
+      LOG ("squashing equivalence class of %d", lit);
+      sweeper.partition.resize (sweeper.partition.size () - 3);
+    } else {
+      LOG ("removing %d from equivalence class of %d", lit, other);
+      end[-2] = 0;
+      sweeper.partition.resize (sweeper.partition.size () - 1);
+    }
+    return false;
+  }
+
+  const int not_other = -other;
+  const int not_lit = -lit;
+  LOG ("flipping %d and %d both failed", lit, other);
+  cadical_kitten_assume_signed (citten, not_lit);
+  cadical_kitten_assume_signed (citten, other);
+  stats.sweep_solved_equivalences++;
+  res = sweep_solve ();
+  if (res == 10) {
+    stats.sweep_sat_equivalences++;
+    LOG ("first sweeping implication %d -> %d failed", other, lit);
+    sweep_refine (sweeper);
+  } else if (!res) {
+    stats.sweep_unknown_equivalences++;
+    LOG ("first sweeping implication %d -> %d hit ticks limit", other, lit);
+  }
+
+  if (res != 20)
+    return false;
+
+  stats.sweep_unsat_equivalences++;
+  LOG ("first sweeping implication %d -> %d succeeded", other, lit);
+
+  save_core (sweeper, 0);
+
+  cadical_kitten_assume_signed (citten, lit);
+  cadical_kitten_assume_signed (citten, not_other);
+  res = sweep_solve ();
+  stats.sweep_solved_equivalences++;
+  if (res == 10) {
+    stats.sweep_sat_equivalences++;
+    LOG ("second sweeping implication %d <- %d failed", other, lit);
+    sweep_refine (sweeper);
+  } else if (!res) {
+    stats.sweep_unknown_equivalences++;
+    LOG ("second sweeping implication %d <- %d hit ticks limit", other,
+         lit);
+  }
+
+  if (res != 20) {
+    sweeper.core[0].clear ();
+    return false;
+  }
+
+  CADICAL_assert (res == 20);
+
+  stats.sweep_unsat_equivalences++;
+  LOG ("second sweeping implication %d <- %d succeeded too", other, lit);
+
+  save_core (sweeper, 1);
+
+  LOG ("sweep equivalence %d = %d", lit, other);
+
+  // If cadical_kitten behaves as expected, the two binaries of the equivalence
+  // should be stored at sweeper.core[i].back () for i in {0, 1}.
+  // We pick the smaller absolute valued literal as representative and
+  // store the equivalence .
+  add_core (sweeper, 0);
+  add_core (sweeper, 1);
+  if (!val (lit) && !val (other)) {
+    CADICAL_assert (sweeper.core[0].size ());
+    CADICAL_assert (sweeper.core[1].size ());
+    stats.sweep_equivalences++;
+    sweep_binary bin1;
+    sweep_binary bin2;
+    if (abs (lit) > abs (other)) {
+      bin1.lit = lit;
+      bin1.other = not_other;
+      bin2.lit = not_lit;
+      bin2.other = other;
+      bin1.id = add_sweep_binary (sweeper.core[0].back (), lit, not_other);
+      bin2.id = add_sweep_binary (sweeper.core[1].back (), not_lit, other);
+    } else {
+      bin1.lit = not_other;
+      bin1.other = lit;
+      bin2.lit = other;
+      bin2.other = not_lit;
+      bin1.id = add_sweep_binary (sweeper.core[0].back (), not_other, lit);
+      bin2.id = add_sweep_binary (sweeper.core[1].back (), other, not_lit);
+    }
+    if (bin1.id && bin2.id) {
+      sweeper.binaries.push_back (bin1);
+      sweeper.binaries.push_back (bin2);
+    }
+  }
+
+  int repr;
+  if (abs (lit) < abs (other)) {
+    repr = sweeper.reprs[other] = lit;
+    sweeper.reprs[not_other] = not_lit;
+    sweep_remove (sweeper, other);
+  } else {
+    repr = sweeper.reprs[lit] = other;
+    sweeper.reprs[not_lit] = not_other;
+    sweep_remove (sweeper, lit);
+  }
+  clear_core (sweeper, 0);
+  clear_core (sweeper, 1);
+
+  const int repr_idx = abs (repr);
+  schedule_inner (sweeper, repr_idx);
+
+  return true;
+}
+
+const char *Internal::sweep_variable (Sweeper &sweeper, int idx) {
+  CADICAL_assert (!unsat);
+  if (!active (idx))
+    return "inactive variable";
+  const int start = idx;
+  if (sweeper.reprs[start] != start)
+    return "non-representative variable";
+  CADICAL_assert (sweeper.vars.empty ());
+  CADICAL_assert (sweeper.clauses.empty ());
+  CADICAL_assert (sweeper.backbone.empty ());
+  CADICAL_assert (sweeper.partition.empty ());
+  CADICAL_assert (!sweeper.encoded);
+
+  stats.sweep_variables++;
+
+  LOG ("sweeping %d", idx);
+  CADICAL_assert (!val (start));
+  LOG ("starting sweeping[0]");
+  add_literal_to_environment (sweeper, 0, start);
+  LOG ("finished sweeping[0]");
+  LOG ("starting sweeping[1]");
+
+  bool limit_reached = false;
+  size_t expand = 0, next = 1;
+  bool success = false;
+  unsigned depth = 1;
+
+  uint64_t &ticks = sweeper.current_ticks;
+  while (!limit_reached) {
+    if (sweeper.encoded >= sweeper.limit.clauses) {
+      LOG ("environment clause limit reached");
+      limit_reached = true;
+      break;
+    }
+    if (expand == next) {
+      LOG ("finished sweeping[%u]", depth);
+      if (depth >= sweeper.limit.depth) {
+        LOG ("environment depth limit reached");
+        break;
+      }
+      next = sweeper.vars.size ();
+      if (expand == next) {
+        LOG ("completely copied all clauses");
+        break;
+      }
+      depth++;
+      LOG ("starting sweeping[%u]", depth);
+    }
+    const unsigned choices = next - expand;
+    if (opts.sweeprand && choices > 1) {
+      const unsigned swaps = sweeper.random.pick_int (0, choices - 1);
+      if (swaps) {
+        CADICAL_assert (expand + swaps < sweeper.vars.size ());
+        swap (sweeper.vars[expand], sweeper.vars[expand + swaps]);
+      }
+    }
+    const int idx = sweeper.vars[expand];
+    LOG ("traversing and adding clauses of %d", idx);
+    for (unsigned sign = 0; sign < 2; sign++) {
+      const int lit = sign ? -idx : idx;
+      ticks += 1 + cache_lines (occs (lit).size (), sizeof (Clause *));
+      Occs &ns = occs (lit);
+      for (auto c : ns) {
+        ticks++;
+        if (!can_sweep_clause (c))
+          continue;
+        sweep_clause (sweeper, depth, c);
+        if (sweeper.vars.size () >= sweeper.limit.vars) {
+          LOG ("environment variable limit reached");
+          limit_reached = true;
+          break;
+        }
+      }
+      if (limit_reached)
+        break;
+    }
+    expand++;
+  }
+  stats.sweep_depth += depth;
+  stats.sweep_clauses += sweeper.encoded;
+  stats.sweep_environment += sweeper.vars.size ();
+  VERBOSE (3,
+           "sweeping variable %d environment of "
+           "%zu variables %u clauses depth %u",
+           externalize (idx), sweeper.vars.size (), sweeper.encoded, depth);
+
+  int res;
+  if (sweeper.vars.size () == 1) {
+    LOG ("not sweeping literal %d with environment size 1", idx);
+    goto DONE;
+  }
+  res = sweep_solve ();
+  LOG ("sub-solver returns '%d'", res);
+  if (res == 10) {
+    init_backbone_and_partition (sweeper);
+#ifndef CADICAL_QUIET
+    uint64_t units = stats.sweep_units;
+    uint64_t solved = stats.sweep_solved;
+#endif
+    START (sweepbackbone);
+    while (sweeper.backbone.size ()) {
+      if (unsat || terminated_asynchronously () ||
+          cadical_kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
+        limit_reached = true;
+      STOP_SWEEP_BACKBONE:
+        STOP (sweepbackbone);
+        goto DONE;
+      }
+      flip_backbone_literals (sweeper);
+      if (terminated_asynchronously () ||
+          cadical_kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
+        limit_reached = true;
+        goto STOP_SWEEP_BACKBONE;
+      }
+      if (sweeper.backbone.empty ())
+        break;
+      const int lit = sweeper.backbone.back ();
+      sweeper.backbone.pop_back ();
+      if (!active (lit))
+        continue;
+      if (sweep_backbone_candidate (sweeper, lit))
+        success = true;
+    }
+    STOP (sweepbackbone);
+#ifndef CADICAL_QUIET
+    units = stats.sweep_units - units;
+    solved = stats.sweep_solved - solved;
+#endif
+    VERBOSE (3,
+             "complete swept variable %d backbone with %" PRIu64
+             " units in %" PRIu64 " solver calls",
+             externalize (idx), units, solved);
+    CADICAL_assert (sweeper.backbone.empty ());
+#ifndef CADICAL_QUIET
+    uint64_t equivalences = stats.sweep_equivalences;
+    solved = stats.sweep_solved;
+#endif
+    START (sweepequivalences);
+    while (sweeper.partition.size ()) {
+      if (unsat || terminated_asynchronously () ||
+          cadical_kitten_ticks_limit_hit (sweeper, "partition refinement")) {
+        limit_reached = true;
+      STOP_SWEEP_EQUIVALENCES:
+        STOP (sweepequivalences);
+        goto DONE;
+      }
+      flip_partition_literals (sweeper);
+      if (terminated_asynchronously () ||
+          cadical_kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
+        limit_reached = true;
+        goto STOP_SWEEP_EQUIVALENCES;
+      }
+      if (sweeper.partition.empty ())
+        break;
+      if (sweeper.partition.size () > 2) {
+        const auto end = sweeper.partition.end ();
+        CADICAL_assert (end[-1] == 0);
+        int lit = end[-3];
+        int other = end[-2];
+        if (sweep_equivalence_candidates (sweeper, lit, other))
+          success = true;
+      } else
+        sweeper.partition.clear ();
+    }
+    STOP (sweepequivalences);
+#ifndef CADICAL_QUIET
+    equivalences = stats.sweep_equivalences - equivalences;
+    solved = stats.sweep_solved - solved;
+    if (equivalences)
+      VERBOSE (3,
+               "complete swept variable %d partition with %" PRIu64
+               " equivalences in %" PRIu64 " solver calls",
+               externalize (idx), equivalences, solved);
+#endif
+  } else if (res == 20)
+    sweep_empty_clause (sweeper);
+
+DONE:
+  clear_sweeper (sweeper);
+
+  if (!unsat)
+    sweep_substitute_new_equivalences (sweeper);
+  if (!unsat)
+    sweep_dense_propagate (sweeper);
+
+  if (success && limit_reached)
+    return "successfully despite reaching limit";
+  if (!success && !limit_reached)
+    return "unsuccessfully without reaching limit";
+  else if (success && !limit_reached)
+    return "successfully without reaching limit";
+  CADICAL_assert (!success && limit_reached);
+  return "unsuccessfully and reached limit";
+}
+
+struct sweep_candidate {
+  unsigned rank;
+  int idx;
+};
+
+struct rank_sweep_candidate {
+  bool operator() (sweep_candidate a, sweep_candidate b) const {
+    CADICAL_assert (a.rank && b.rank);
+    CADICAL_assert (a.idx > 0 && b.idx > 0);
+    if (a.rank < b.rank)
+      return true;
+    if (b.rank < a.rank)
+      return false;
+    return a.idx < b.idx;
+  }
+};
+
+bool Internal::scheduable_variable (Sweeper &sweeper, int idx,
+                                    size_t *occ_ptr) {
+  const int lit = idx;
+  const size_t pos = noccs (lit);
+  if (!pos)
+    return false;
+  const unsigned max_occurrences = sweeper.limit.clauses;
+  if (pos > max_occurrences)
+    return false;
+  const int not_lit = -lit;
+  const size_t neg = noccs (not_lit);
+  if (!neg)
+    return false;
+  if (neg > max_occurrences)
+    return false;
+  *occ_ptr = pos + neg;
+  return true;
+}
+
+unsigned Internal::schedule_all_other_not_scheduled_yet (Sweeper &sweeper) {
+  vector<sweep_candidate> fresh;
+  for (const auto &idx : vars) {
+    Flags &f = flags (idx);
+    if (!f.active ())
+      continue;
+    if (sweep_incomplete && !f.sweep)
+      continue;
+    if (scheduled_variable (sweeper, idx))
+      continue;
+    size_t occ;
+    if (!scheduable_variable (sweeper, idx, &occ)) {
+      f.sweep = false;
+      continue;
+    }
+    sweep_candidate cand;
+    cand.rank = occ;
+    cand.idx = idx;
+    fresh.push_back (cand);
+  }
+  const size_t size = fresh.size ();
+  CADICAL_assert (size <= UINT_MAX);
+  sort (fresh.begin (), fresh.end (), rank_sweep_candidate ());
+  for (auto &cand : fresh)
+    schedule_outer (sweeper, cand.idx);
+  return size;
+}
+
+unsigned Internal::reschedule_previously_remaining (Sweeper &sweeper) {
+  unsigned rescheduled = 0;
+  for (const auto &idx : sweep_schedule) {
+    Flags &f = flags (idx);
+    if (!f.active ())
+      continue;
+    if (scheduled_variable (sweeper, idx))
+      continue;
+    size_t occ;
+    if (!scheduable_variable (sweeper, idx, &occ)) {
+      f.sweep = false;
+      continue;
+    }
+    schedule_inner (sweeper, idx);
+    rescheduled++;
+  }
+  sweep_schedule.clear ();
+  return rescheduled;
+}
+
+unsigned Internal::incomplete_variables () {
+  unsigned res = 0;
+  for (const auto &idx : vars) {
+    Flags &f = flags (idx);
+    if (!f.active ())
+      continue;
+    if (f.sweep)
+      res++;
+  }
+  return res;
+}
+
+void Internal::mark_incomplete (Sweeper &sweeper) {
+  unsigned marked = 0;
+  for (all_scheduled (idx)) {
+    if (!flags (idx).sweep) {
+      flags (idx).sweep = true;
+      marked++;
+    }
+  }
+  sweep_incomplete = true;
+#ifndef CADICAL_QUIET
+  VERBOSE (2, "marked %u scheduled sweeping variables as incomplete",
+           marked);
+#else
+  (void) marked;
+#endif
+}
+
+unsigned Internal::schedule_sweeping (Sweeper &sweeper) {
+  const unsigned rescheduled = reschedule_previously_remaining (sweeper);
+  const unsigned fresh = schedule_all_other_not_scheduled_yet (sweeper);
+  const unsigned scheduled = fresh + rescheduled;
+  const unsigned incomplete = incomplete_variables ();
+#ifndef CADICAL_QUIET
+  PHASE ("sweep", stats.sweep,
+         "scheduled %u variables %.0f%% "
+         "(%u rescheduled %.0f%%, %u incomplete %.0f%%)",
+         scheduled, percent (scheduled, active ()), rescheduled,
+         percent (rescheduled, scheduled), incomplete,
+         percent (incomplete, scheduled));
+#endif
+  if (incomplete)
+    CADICAL_assert (sweep_incomplete);
+  else {
+    if (sweep_incomplete)
+      stats.sweep_completed++;
+    mark_incomplete (sweeper);
+  }
+  return scheduled;
+}
+
+void Internal::unschedule_sweeping (Sweeper &sweeper, unsigned swept,
+                                    unsigned scheduled) {
+#ifdef CADICAL_QUIET
+  (void) scheduled, (void) swept;
+#endif
+  CADICAL_assert (sweep_schedule.empty ());
+  CADICAL_assert (sweep_incomplete);
+  for (all_scheduled (idx))
+    if (active (idx)) {
+      sweep_schedule.push_back (idx);
+      LOG ("untried scheduled %d", idx);
+    }
+#ifndef CADICAL_QUIET
+  const unsigned retained = sweep_schedule.size ();
+#endif
+  VERBOSE (3, "retained %u variables %.0f%% to be swept next time",
+           retained, percent (retained, active ()));
+  const unsigned incomplete = incomplete_variables ();
+  if (incomplete)
+    VERBOSE (3, "need to sweep %u more variables %.0f%% for completion",
+             incomplete, percent (incomplete, active ()));
+  else {
+    VERBOSE (3, "no more variables needed to complete sweep");
+    sweep_incomplete = false;
+    stats.sweep_completed++;
+  }
+  PHASE ("sweep", stats.sweep, "swept %u variables (%u remain %.0f%%)",
+         swept, incomplete, percent (incomplete, scheduled));
+}
+
+bool Internal::sweep () {
+  if (!opts.sweep)
+    return false;
+  if (unsat)
+    return false;
+  if (terminated_asynchronously ())
+    return false;
+  if (delaying_sweep.bumpreasons.delay ()) { // TODO need to fix Delay
+    last.sweep.ticks = stats.ticks.search[0] + stats.ticks.search[1];
+    return false;
+  }
+  delaying_sweep.bumpreasons.bypass_delay ();
+  SET_EFFORT_LIMIT (tickslimit, sweep, !opts.sweepcomplete);
+  delaying_sweep.bumpreasons.unbypass_delay ();
+
+  CADICAL_assert (!level);
+  START_SIMPLIFIER (sweep, SWEEP);
+  stats.sweep++;
+  uint64_t equivalences = stats.sweep_equivalences;
+  uint64_t units = stats.sweep_units;
+  Sweeper sweeper = Sweeper (this);
+  if (opts.sweepcomplete)
+    sweeper.limit.ticks = INT64_MAX;
+  else
+    sweeper.limit.ticks = tickslimit - stats.ticks.sweep;
+  sweep_set_cadical_kitten_ticks_limit (sweeper);
+  const unsigned scheduled = schedule_sweeping (sweeper);
+  uint64_t swept = 0, limit = 10;
+  for (;;) {
+    if (unsat)
+      break;
+    if (terminated_asynchronously ())
+      break;
+    if (cadical_kitten_ticks_limit_hit (sweeper, "sweeping loop"))
+      break;
+    int idx = next_scheduled (sweeper);
+    if (idx == 0)
+      break;
+    flags (idx).sweep = false;
+#ifndef CADICAL_QUIET
+    const char *res =
+#endif
+        sweep_variable (sweeper, idx);
+    VERBOSE (2, "swept[%" PRIu64 "] external variable %d %s", swept,
+             externalize (idx), res);
+    if (++swept == limit) {
+      VERBOSE (2,
+               "found %" PRIu64 " equivalences and %" PRIu64
+               " units after sweeping %" PRIu64 " variables ",
+               stats.sweep_equivalences - equivalences,
+               stats.sweep_units - units, swept);
+      limit *= 10;
+    }
+  }
+  VERBOSE (2, "swept %" PRIu64 " variables", swept);
+  equivalences = stats.sweep_equivalences - equivalences,
+  units = stats.sweep_units - units;
+  PHASE ("sweep", stats.sweep,
+         "found %" PRIu64 " equivalences and %" PRIu64 " units",
+         equivalences, units);
+  unschedule_sweeping (sweeper, swept, scheduled);
+  release_sweeper (sweeper);
+
+  if (!unsat) {
+    propagated = 0;
+    if (!propagate ()) {
+      learn_empty_clause ();
+    }
+  }
+
+  uint64_t eliminated = equivalences + units;
+  report ('=', !eliminated);
+
+  if (relative (eliminated, swept) < 0.001) {
+    delaying_sweep.bumpreasons.bump_delay ();
+  } else {
+    delaying_sweep.bumpreasons.reduce_delay ();
+  }
+  STOP_SIMPLIFIER (sweep, SWEEP);
+  return eliminated;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_terminal.cpp b/src/sat/cadical/cadical_terminal.cpp
new file mode 100644
index 000000000..c8aeea2ab
--- /dev/null
+++ b/src/sat/cadical/cadical_terminal.cpp
@@ -0,0 +1,49 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+#ifdef WIN32
+#include <io.h>
+#define isatty _isatty
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+Terminal::Terminal (FILE *f) : file (f), reset_on_exit (false) {
+  CADICAL_assert (file);
+  int fd = fileno (f);
+  CADICAL_assert (fd == 1 || fd == 2);
+  use_colors = connected = isatty (fd);
+}
+
+void Terminal::force_colors () { use_colors = connected = true; }
+void Terminal::force_no_colors () { use_colors = false; }
+void Terminal::force_reset_on_exit () { reset_on_exit = true; }
+
+void Terminal::reset () {
+  if (!connected)
+    return;
+  erase_until_end_of_line ();
+  cursor (true);
+  normal ();
+  fflush (file);
+}
+
+void Terminal::disable () {
+  reset ();
+  connected = use_colors = false;
+}
+
+Terminal::~Terminal () {
+  if (reset_on_exit)
+    reset ();
+}
+
+Terminal tout (stdout);
+Terminal terr (stderr);
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_ternary.cpp b/src/sat/cadical/cadical_ternary.cpp
new file mode 100644
index 000000000..9f99e2279
--- /dev/null
+++ b/src/sat/cadical/cadical_ternary.cpp
@@ -0,0 +1,456 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This procedure can be used to produce all possible hyper ternary
+// resolvents from ternary clauses.  In contrast to hyper binary resolution
+// we would only try to produce ternary clauses from ternary clauses, i.e.,
+// do not consider quaternary clauses as antecedents.  Of course if a binary
+// clause is generated we keep it too.  In any case we have to make sure
+// though that we do not add clauses which are already in the formula or are
+// subsumed by a binary clause in the formula.  This procedure simulates
+// structural hashing for multiplexer (if-then-else) and binary XOR gates in
+// combination with equivalent literal substitution ('decompose') if run
+// until to completion (which in the current implementation is too costly
+// though and would need to be interleaved more eagerly with equivalent
+// literal substitution).  For more information see our CPAIOR'13 paper.
+
+/*------------------------------------------------------------------------*/
+
+// Check whether a binary clause consisting of the permutation of the given
+// literals already exists.
+
+bool Internal::ternary_find_binary_clause (int a, int b) {
+  CADICAL_assert (occurring ());
+  CADICAL_assert (active (a));
+  CADICAL_assert (active (b));
+  size_t s = occs (a).size ();
+  size_t t = occs (b).size ();
+  int lit = s < t ? a : b;
+  if (opts.ternaryocclim < (int) occs (lit).size ())
+    return true;
+  for (const auto &c : occs (lit)) {
+    if (c->size != 2)
+      continue;
+    const int *lits = c->literals;
+    if (lits[0] == a && lits[1] == b)
+      return true;
+    if (lits[0] == b && lits[1] == a)
+      return true;
+  }
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether a ternary clause consisting of the permutation of the given
+// literals already exists or is subsumed by an existing binary clause.
+
+bool Internal::ternary_find_ternary_clause (int a, int b, int c) {
+  CADICAL_assert (occurring ());
+  CADICAL_assert (active (a));
+  CADICAL_assert (active (b));
+  CADICAL_assert (active (c));
+  size_t r = occs (a).size ();
+  size_t s = occs (b).size ();
+  size_t t = occs (c).size ();
+  int lit;
+  if (r < s)
+    lit = (t < r) ? c : a;
+  else
+    lit = (t < s) ? c : b;
+  if (opts.ternaryocclim < (int) occs (lit).size ())
+    return true;
+  for (const auto &d : occs (lit)) {
+    const int *lits = d->literals;
+    if (d->size == 2) {
+      if (lits[0] == a && lits[1] == b)
+        return true;
+      if (lits[0] == b && lits[1] == a)
+        return true;
+      if (lits[0] == a && lits[1] == c)
+        return true;
+      if (lits[0] == c && lits[1] == a)
+        return true;
+      if (lits[0] == b && lits[1] == c)
+        return true;
+      if (lits[0] == c && lits[1] == b)
+        return true;
+    } else {
+      CADICAL_assert (d->size == 3);
+      if (lits[0] == a && lits[1] == b && lits[2] == c)
+        return true;
+      if (lits[0] == a && lits[1] == c && lits[2] == b)
+        return true;
+      if (lits[0] == b && lits[1] == a && lits[2] == c)
+        return true;
+      if (lits[0] == b && lits[1] == c && lits[2] == a)
+        return true;
+      if (lits[0] == c && lits[1] == a && lits[2] == b)
+        return true;
+      if (lits[0] == c && lits[1] == b && lits[2] == a)
+        return true;
+    }
+  }
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Try to resolve the two ternary clauses on the given pivot (assumed to
+// occur positively in the first clause, negatively in the second).  If the
+// resolvent has four literals, is tautological, already exists or in the
+// case of a ternary resolvent is subsumed by an existing binary clause then
+// 'false' is returned.  The global 'clause' contains the resolvent and
+// needs to be cleared in any case.
+
+bool Internal::hyper_ternary_resolve (Clause *c, int pivot, Clause *d) {
+  LOG ("hyper binary resolving on pivot %d", pivot);
+  LOG (c, "1st antecedent");
+  LOG (d, "2nd antecedent");
+  stats.ternres++;
+  CADICAL_assert (c->size == 3);
+  CADICAL_assert (d->size == 3);
+  CADICAL_assert (clause.empty ());
+  for (const auto &lit : *c)
+    if (lit != pivot)
+      clause.push_back (lit);
+  for (const auto &lit : *d) {
+    if (lit == -pivot)
+      continue;
+    if (lit == clause[0])
+      continue;
+    if (lit == -clause[0])
+      return false;
+    if (lit == clause[1])
+      continue;
+    if (lit == -clause[1])
+      return false;
+    clause.push_back (lit);
+  }
+  size_t size = clause.size ();
+  if (size > 3)
+    return false;
+  if (size == 2 && ternary_find_binary_clause (clause[0], clause[1]))
+    return false;
+  if (size == 3 &&
+      ternary_find_ternary_clause (clause[0], clause[1], clause[2]))
+    return false;
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Produce all ternary resolvents on literal 'pivot' and increment the
+// 'steps' counter by the number of clauses containing 'pivot' which are
+// used during this process.  The reason for choosing this metric to measure
+// the effort spent in 'ternary' is that it should be similar to one
+// propagation step during search.
+
+void Internal::ternary_lit (int pivot, int64_t &steps, int64_t &htrs) {
+  LOG ("starting hyper ternary resolutions on pivot %d", pivot);
+  steps -= 1 + cache_lines (occs (pivot).size (), sizeof (Clause *));
+  for (const auto &c : occs (pivot)) {
+    if (steps < 0)
+      break;
+    if (htrs < 0)
+      break;
+    if (c->garbage)
+      continue;
+    if (c->size != 3) {
+      CADICAL_assert (c->size == 2);
+      continue;
+    }
+    if (--steps < 0)
+      break;
+    bool assigned = false;
+    for (const auto &lit : *c)
+      if (val (lit)) {
+        assigned = true;
+        break;
+      }
+    if (assigned)
+      continue;
+    steps -= 1 + cache_lines (occs (-pivot).size (), sizeof (Clause *));
+    for (const auto &d : occs (-pivot)) {
+      if (htrs < 0)
+        break;
+      if (--steps < 0)
+        break;
+      if (d->garbage)
+        continue;
+      if (d->size != 3) {
+        CADICAL_assert (d->size == 2);
+        continue;
+      }
+      for (const auto &lit : *d)
+        if (val (lit)) {
+          assigned = true;
+          break;
+        }
+      if (assigned)
+        continue;
+      CADICAL_assert (clause.empty ());
+      htrs--;
+      if (hyper_ternary_resolve (c, pivot, d)) {
+        size_t size = clause.size ();
+        bool red = (size == 3 || (c->redundant && d->redundant));
+        if (lrat) {
+          CADICAL_assert (lrat_chain.empty ());
+          lrat_chain.push_back (c->id);
+          lrat_chain.push_back (d->id);
+        }
+        Clause *r = new_hyper_ternary_resolved_clause (red);
+        if (red)
+          r->hyper = true;
+        lrat_chain.clear ();
+        clause.clear ();
+        LOG (r, "hyper ternary resolved");
+        stats.htrs++;
+        for (const auto &lit : *r)
+          occs (lit).push_back (r);
+        if (size == 2) {
+          LOG ("hyper ternary resolvent subsumes both antecedents");
+          mark_garbage (c);
+          mark_garbage (d);
+          stats.htrs2++;
+          break;
+        } else {
+          CADICAL_assert (r->size == 3);
+          stats.htrs3++;
+        }
+      } else {
+        LOG (clause, "ignoring size %zd resolvent", clause.size ());
+        clause.clear ();
+      }
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Same as 'ternary_lit' but pick the phase of the variable based on the
+// number of positive and negative occurrence.
+
+void Internal::ternary_idx (int idx, int64_t &steps, int64_t &htrs) {
+  CADICAL_assert (0 < idx);
+  CADICAL_assert (idx <= max_var);
+  steps -= 3;
+  if (!active (idx))
+    return;
+  if (!flags (idx).ternary)
+    return;
+  int pos = occs (idx).size ();
+  int neg = occs (-idx).size ();
+  if (pos <= opts.ternaryocclim && neg <= opts.ternaryocclim) {
+    LOG ("index %d has %zd positive and %zd negative occurrences", idx,
+         occs (idx).size (), occs (-idx).size ());
+    int pivot = (neg < pos ? -idx : idx);
+    ternary_lit (pivot, steps, htrs);
+  }
+  flags (idx).ternary = false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// One round of ternary resolution over all variables.  As in 'block' and
+// 'elim' we maintain a persistent global flag 'ternary' for each variable,
+// which records, whether a ternary clause containing it was added.  Then we
+// can focus on those variables for which we have not tried ternary
+// resolution before and nothing changed for them since then.  This works
+// across multiple calls to 'ternary' as well as 'ternary_round' since this
+// 'ternary' variable flag is updated during adding (ternary) resolvents.
+// This function goes over each variable just once.
+
+bool Internal::ternary_round (int64_t &steps_limit, int64_t &htrs_limit) {
+
+  CADICAL_assert (!unsat);
+
+#ifndef CADICAL_QUIET
+  int64_t bincon = 0;
+  int64_t terncon = 0;
+#endif
+
+  init_occs ();
+
+  steps_limit -= 1 + cache_lines (clauses.size (), sizeof (Clause *));
+  for (const auto &c : clauses) {
+    steps_limit--;
+    if (c->garbage)
+      continue;
+    if (c->size > 3)
+      continue;
+    bool assigned = false, marked = false;
+    for (const auto &lit : *c) {
+      if (val (lit)) {
+        assigned = true;
+        break;
+      }
+      if (flags (lit).ternary)
+        marked = true;
+    }
+    if (assigned)
+      continue;
+    if (c->size == 2) {
+#ifndef CADICAL_QUIET
+      bincon++;
+#endif
+    } else {
+      CADICAL_assert (c->size == 3);
+      if (!marked)
+        continue;
+#ifndef CADICAL_QUIET
+      terncon++;
+#endif
+    }
+
+    for (const auto &lit : *c)
+      occs (lit).push_back (c);
+  }
+
+  PHASE ("ternary", stats.ternary,
+         "connected %" PRId64 " ternary %.0f%% "
+         "and %" PRId64 " binary clauses %.0f%%",
+         terncon, percent (terncon, clauses.size ()), bincon,
+         percent (bincon, clauses.size ()));
+
+  // Try ternary resolution on all variables once.
+  //
+  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);
+  }
+
+  // Gather some statistics for the verbose messages below and also
+  // determine whether new variables have been marked and it would make
+  // sense to run another round of ternary resolution over those variables.
+  //
+  int remain = 0;
+  for (auto idx : vars) {
+    if (!active (idx))
+      continue;
+    if (!flags (idx).ternary)
+      continue;
+    remain++;
+  }
+  if (remain)
+    PHASE ("ternary", stats.ternary, "%d variables remain %.0f%%", remain,
+           percent (remain, max_var));
+  else
+    PHASE ("ternary", stats.ternary, "completed hyper ternary resolution");
+
+  reset_occs ();
+  CADICAL_assert (!unsat);
+
+  return remain; // Are there variables that should be tried again?
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::ternary () {
+
+  if (!opts.ternary)
+    return false;
+  if (unsat)
+    return false;
+  if (terminated_asynchronously ())
+    return false;
+
+  // No new ternary clauses added since last time?
+  //
+  if (last.ternary.marked == stats.mark.ternary)
+    return false;
+
+  SET_EFFORT_LIMIT (limit, ternary, true);
+
+  START_SIMPLIFIER (ternary, TERNARY);
+  stats.ternary++;
+
+  CADICAL_assert (!level);
+
+  CADICAL_assert (!unsat);
+  if (watching ())
+    reset_watches ();
+
+  // The number of clauses derived through ternary resolution can grow
+  // substantially, particularly for random formulas.  Thus we limit the
+  // number of added clauses too (actually the number of 'htrs').
+  //
+  int64_t htrs_limit = stats.current.redundant + stats.current.irredundant;
+  htrs_limit *= opts.ternarymaxadd;
+  htrs_limit /= 100;
+
+  // approximation of ternary ticks.
+  // TODO: count with ternary.ticks directly.
+  int64_t steps_limit = stats.ticks.ternary - limit;
+  stats.ticks.ternary = limit;
+
+  // With 'stats.ternary' we actually count the number of calls to
+  // 'ternary_round' and not the number of calls to 'ternary'. But before
+  // the first round we want to show the limit on the number of steps and
+  // thus we increase counter for the first round here and skip increasing
+  // it in the loop below.
+  //
+  PHASE ("ternary", stats.ternary,
+         "will run a maximum of %d rounds "
+         "limited to %" PRId64 " steps and %" PRId64 " clauses",
+         opts.ternaryrounds, steps_limit, htrs_limit);
+
+  bool resolved_binary_clause = false;
+  bool completed = false;
+
+  for (int round = 0;
+       !terminated_asynchronously () && round < opts.ternaryrounds;
+       round++) {
+    if (htrs_limit < 0)
+      break;
+    if (steps_limit < 0)
+      break;
+    if (round)
+      stats.ternary++;
+    int old_htrs2 = stats.htrs2;
+    int old_htrs3 = stats.htrs3;
+    completed = ternary_round (steps_limit, htrs_limit);
+    int delta_htrs2 = stats.htrs2 - old_htrs2;
+    int delta_htrs3 = stats.htrs3 - old_htrs3;
+    PHASE ("ternary", stats.ternary,
+           "derived %d ternary and %d binary resolvents", delta_htrs3,
+           delta_htrs2);
+    report ('3', !opts.reportall && !(delta_htrs2 + delta_htrs2));
+    if (delta_htrs2)
+      resolved_binary_clause = true;
+    if (!delta_htrs3)
+      break;
+  }
+
+  CADICAL_assert (!occurring ());
+  CADICAL_assert (!unsat);
+  init_watches ();
+  connect_watches ();
+  if (!propagate ()) {
+    LOG ("propagation after connecting watches results in inconsistency");
+    learn_empty_clause ();
+  }
+
+  if (completed)
+    last.ternary.marked = stats.mark.ternary;
+
+  STOP_SIMPLIFIER (ternary, TERNARY);
+
+  return resolved_binary_clause;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_tier.cpp b/src/sat/cadical/cadical_tier.cpp
new file mode 100644
index 000000000..92faf507f
--- /dev/null
+++ b/src/sat/cadical/cadical_tier.cpp
@@ -0,0 +1,59 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::recompute_tier () {
+  if (!opts.recomputetier)
+    return;
+
+  ++stats.tierecomputed;
+  const int64_t delta =
+      stats.tierecomputed >= 16 ? 1u << 16 : (1u << stats.tierecomputed);
+  lim.recompute_tier = stats.conflicts + delta;
+  LOG ("rescheduling in %zd at %zd (conflicts at %zd)", delta,
+       lim.recompute_tier, stats.conflicts);
+#ifndef CADICAL_NDEBUG
+  uint64_t total_used = 0;
+  for (auto u : stats.used[stable])
+    total_used += u;
+  CADICAL_assert (total_used == stats.bump_used[stable]);
+#endif
+
+  if (!stats.bump_used[stable]) {
+    tier1[stable] = opts.reducetier1glue;
+    tier2[stable] = opts.reducetier2glue;
+    LOG ("tier1 limit = %d", tier1[stable]);
+    LOG ("tier2 limit = %d", tier2[stable]);
+    return;
+  } else {
+    uint64_t accumulated_tier1_limit =
+        stats.bump_used[stable] * opts.tier1limit / 100;
+    uint64_t accumulated_tier2_limit =
+        stats.bump_used[stable] * opts.tier2limit / 100;
+    uint64_t accumulated_used = 0;
+    for (size_t glue = 0; glue < stats.used[stable].size (); ++glue) {
+      const uint64_t u = stats.used[stable][glue];
+      accumulated_used += u;
+      if (accumulated_used <= accumulated_tier1_limit) {
+        tier1[stable] = glue;
+      }
+      if (accumulated_used >= accumulated_tier2_limit) {
+        tier2[stable] = glue;
+        break;
+      }
+    }
+  }
+
+  LOG ("tier1 limit = %d in %s mode", tier1[stable],
+       stable ? "stable" : "focused");
+  LOG ("tier2 limit = %d in %s mode", tier2[stable],
+       stable ? "stable" : "focused");
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_transred.cpp b/src/sat/cadical/cadical_transred.cpp
new file mode 100644
index 000000000..82a961dee
--- /dev/null
+++ b/src/sat/cadical/cadical_transred.cpp
@@ -0,0 +1,259 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+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.  It will also find some failed
+// literals (in the binary implication graph).
+
+void Internal::transred () {
+  if (!opts.transred)
+    return;
+  if (unsat)
+    return;
+  if (terminated_asynchronously ())
+    return;
+  if (!stats.current.redundant && !stats.current.irredundant)
+    return;
+
+  CADICAL_assert (opts.transred);
+  CADICAL_assert (!level);
+
+  START_SIMPLIFIER (transred, TRANSRED);
+  stats.transreds++;
+
+  // Transitive reduction can not be run to completion for larger formulas
+  // with many binary clauses.  We bound it in the same way as 'probe_core'.
+  //
+  int64_t limit = stats.propagations.search;
+  limit -= last.transred.propagations;
+  limit *= 1e-3 * opts.transredeffort;
+  if (limit < opts.transredmineff)
+    limit = opts.transredmineff;
+  if (limit > opts.transredmaxeff)
+    limit = opts.transredmaxeff;
+
+  PHASE ("transred", stats.transreds,
+         "transitive reduction limit of %" PRId64 " propagations", limit);
+
+  const auto end = clauses.end ();
+  auto i = clauses.begin ();
+
+  // Find first clause not checked for being transitive yet.
+  //
+  for (; i != end; i++) {
+    Clause *c = *i;
+    if (c->garbage)
+      continue;
+    if (c->size != 2)
+      continue;
+    if (c->redundant && c->hyper)
+      continue;
+    if (!c->transred)
+      break;
+  }
+
+  // If all candidate clauses have been checked reschedule all.
+  //
+  if (i == end) {
+
+    PHASE ("transred", stats.transreds,
+           "rescheduling all clauses since no clauses to check left");
+    for (i = clauses.begin (); i != end; i++) {
+      Clause *c = *i;
+      if (c->transred)
+        c->transred = false;
+    }
+    i = clauses.begin ();
+  }
+
+  // Move watches of binary clauses to the front. Thus we can stop iterating
+  // watches as soon a long clause is found during watch traversal.
+  //
+  sort_watches ();
+
+  // This working stack plays the same role as the 'trail' during standard
+  // propagation.
+  //
+  vector<int> work;
+
+  int64_t propagations = 0, units = 0, removed = 0;
+
+  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
+    // the result of hyper binary resolution.  The reason for excluding
+    // those, is that they come in large numbers, most of them are reduced
+    // away anyhow and further are non-transitive at the point they are
+    // added (see the code in 'hyper_binary_resolve' in 'prope.cpp' and
+    // also check out our CPAIOR paper on tree-based look ahead).
+    //
+    if (c->garbage)
+      continue;
+    if (c->size != 2)
+      continue;
+    if (c->redundant && c->hyper)
+      continue;
+    if (c->transred)
+      continue;         // checked before?
+    c->transred = true; // marked as checked
+
+    LOG (c, "checking transitive reduction of");
+
+    // Find a different path from 'src' to 'dst' in the binary implication
+    // graph, not using 'c'.  Since this is the same as checking whether
+    // there is a path from '-dst' to '-src', we can do the reverse search
+    // if the number of watches of '-dst' is larger than those of 'src'.
+    //
+    int src = -c->literals[0];
+    int dst = c->literals[1];
+    if (val (src) || val (dst))
+      continue;
+    if (watches (-src).size () < watches (dst).size ()) {
+      int tmp = dst;
+      dst = -src;
+      src = -tmp;
+    }
+
+    LOG ("searching path from %d to %d", src, dst);
+
+    // If the candidate clause is irredundant then we can not use redundant
+    // binary clauses in the implication graph.  See our inprocessing rules
+    // paper, why this restriction is required.
+    //
+    const bool irredundant = !c->redundant;
+
+    CADICAL_assert (work.empty ());
+    mark (src);
+    work.push_back (src);
+    LOG ("transred assign %d", src);
+
+    bool transitive = false; // found path from 'src' to 'dst'?
+    bool failed = false;     // 'src' failed literal?
+
+    size_t j = 0; // 'propagated' in BFS
+
+    CADICAL_assert (lrat_chain.empty ());
+    CADICAL_assert (mini_chain.empty ());
+    vector<int> parents;
+
+    while (!transitive && !failed && j < work.size ()) {
+      const int lit = work[j++];
+      CADICAL_assert (marked (lit) > 0);
+      LOG ("transred propagating %d", lit);
+      propagations++;
+      const Watches &ws = watches (-lit);
+      const const_watch_iterator eow = ws.end ();
+      const_watch_iterator k;
+      for (k = ws.begin (); !transitive && !failed && k != eow; k++) {
+        const Watch &w = *k;
+        if (!w.binary ())
+          break; // since we sorted watches above
+        Clause *d = w.clause;
+        if (d == c)
+          continue;
+        if (irredundant && d->redundant)
+          continue;
+        if (d->garbage)
+          continue;
+        const int other = w.blit;
+        if (other == dst)
+          transitive = true; // 'dst' reached
+        else {
+          const int tmp = marked (other);
+          if (tmp > 0)
+            continue;
+          else if (tmp < 0) {
+            if (lrat) {
+              parents.push_back (lit);
+              mini_chain.push_back (d->id);
+              work.push_back (other);
+            }
+            LOG ("found both %d and %d reachable", -other, other);
+            failed = true;
+          } else {
+            if (lrat) {
+              parents.push_back (lit);
+              mini_chain.push_back (d->id);
+            }
+            mark (other);
+            work.push_back (other);
+            LOG ("transred assign %d", other);
+          }
+        }
+      }
+    }
+
+    int failed_lit = work.back ();
+    int next_pos = 0;
+    int next_neg = 0;
+
+    // Unassign all assigned literals (same as '[bp]acktrack').
+    //
+    while (!work.empty ()) {
+      const int lit = work.back ();
+      work.pop_back ();
+      if (lrat && failed && !work.empty ()) {
+        CADICAL_assert (!parents.empty () && !mini_chain.empty ());
+        LOG ("transred LRAT current lit %d next pos %d next neg %d", lit,
+             next_pos, next_neg);
+        if (lit == failed_lit || lit == next_pos) {
+          lrat_chain.push_back (mini_chain.back ());
+          next_pos = parents.back ();
+        } else if (lit == -failed_lit || lit == next_neg) {
+          lrat_chain.push_back (mini_chain.back ());
+          next_neg = parents.back ();
+        }
+        parents.pop_back ();
+        mini_chain.pop_back ();
+      }
+      unmark (lit);
+    }
+    mini_chain.clear ();
+    CADICAL_assert (mini_chain.empty ());
+    if (lrat && failed) {
+      reverse (lrat_chain.begin (), lrat_chain.end ());
+    }
+
+    if (transitive) {
+      removed++;
+      stats.transitive++;
+      LOG (c, "transitive redundant");
+      mark_garbage (c);
+    } else if (failed) {
+      units++;
+      LOG ("found failed literal %d during transitive reduction", src);
+      stats.failed++;
+      stats.transredunits++;
+      assign_unit (-src);
+      if (!propagate ()) {
+        VERBOSE (1, "propagating new unit results in conflict");
+        learn_empty_clause ();
+      }
+    }
+    lrat_chain.clear ();
+  }
+
+  last.transred.propagations = stats.propagations.search;
+  stats.propagations.transred += propagations;
+  erase_vector (work);
+
+  PHASE ("transred", stats.transreds,
+         "removed %" PRId64 " transitive clauses, found %" PRId64 " units",
+         removed, units);
+
+  STOP_SIMPLIFIER (transred, TRANSRED);
+  report ('t', !opts.reportall && !(removed + units));
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_unstable.cpp b/src/sat/cadical/cadical_unstable.cpp
new file mode 100644
index 000000000..c3162d70a
--- /dev/null
+++ b/src/sat/cadical/cadical_unstable.cpp
@@ -0,0 +1,38 @@
+#include "global.h"
+
+#ifdef PROFILE_MODE
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+bool Internal::propagate_unstable () {
+  CADICAL_assert (!stable);
+  START (propunstable);
+  bool res = propagate ();
+  STOP (propunstable);
+  return res;
+}
+
+void Internal::analyze_unstable () {
+  CADICAL_assert (!stable);
+  START (analyzeunstable);
+  analyze ();
+  STOP (analyzeunstable);
+}
+
+int Internal::decide_unstable () {
+  CADICAL_assert (!stable);
+  return decide ();
+}
+
+}; // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
+
+#else
+ABC_NAMESPACE_IMPL_START
+int unstable_if_no_profile_mode;
+ABC_NAMESPACE_IMPL_END
+#endif
diff --git a/src/sat/cadical/cadical_util.cpp b/src/sat/cadical/cadical_util.cpp
new file mode 100644
index 000000000..fd9b5b29d
--- /dev/null
+++ b/src/sat/cadical/cadical_util.cpp
@@ -0,0 +1,135 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+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;
+
+    CADICAL_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;
+    }
+
+    CADICAL_assert (INT_MIN <= val64);
+    CADICAL_assert (val64 <= INT_MAX);
+
+    val = val64;
+  }
+  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") ||
+         !strcmp (arg, "--colour") || !strcmp (arg, "--colours") ||
+         !strcmp (arg, "--color=1") || !strcmp (arg, "--colors=1") ||
+         !strcmp (arg, "--colour=1") || !strcmp (arg, "--colours=1") ||
+         !strcmp (arg, "--color=true") || !strcmp (arg, "--colors=true") ||
+         !strcmp (arg, "--colour=true") || !strcmp (arg, "--colours=true");
+}
+
+bool is_no_color_option (const char *arg) {
+  return !strcmp (arg, "--no-color") || !strcmp (arg, "--no-colors") ||
+         !strcmp (arg, "--no-colour") || !strcmp (arg, "--no-colours") ||
+         !strcmp (arg, "--color=0") || !strcmp (arg, "--colors=0") ||
+         !strcmp (arg, "--colour=0") || !strcmp (arg, "--colours=0") ||
+         !strcmp (arg, "--color=false") ||
+         !strcmp (arg, "--colors=false") ||
+         !strcmp (arg, "--colour=false") ||
+         !strcmp (arg, "--colours=false");
+}
+
+/*------------------------------------------------------------------------*/
+
+static uint64_t primes[] = {
+    1111111111111111111lu, 2222222222222222249lu, 3333333333333333347lu,
+    4444444444444444537lu, 5555555555555555621lu, 6666666666666666677lu,
+    7777777777777777793lu, 8888888888888888923lu, 9999999999999999961lu,
+};
+
+uint64_t hash_string (const char *str) {
+  const unsigned size = sizeof primes / sizeof *primes;
+  uint64_t res = 0;
+  unsigned char ch;
+  unsigned i = 0;
+  for (const char *p = str; (ch = *p); p++) {
+    res += ch;
+    res *= primes[i++];
+    if (i == size)
+      i = 0;
+  }
+  return res;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_var.cpp b/src/sat/cadical/cadical_var.cpp
new file mode 100644
index 000000000..e2348da7b
--- /dev/null
+++ b/src/sat/cadical/cadical_var.cpp
@@ -0,0 +1,45 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::reset_subsume_bits () {
+  LOG ("marking all variables as not subsume");
+  for (auto idx : vars)
+    flags (idx).subsume = false;
+}
+
+void Internal::check_var_stats () {
+#ifndef CADICAL_NDEBUG
+  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++;
+    if (f.eliminated ())
+      eliminated++;
+    if (f.substituted ())
+      substituted++;
+    if (f.unused ())
+      unused++;
+    if (f.pure ())
+      pure++;
+  }
+  CADICAL_assert (stats.now.fixed == fixed);
+  CADICAL_assert (stats.now.eliminated == eliminated);
+  CADICAL_assert (stats.now.substituted == substituted);
+  CADICAL_assert (stats.now.pure == pure);
+  int64_t inactive = unused + fixed + eliminated + substituted + pure;
+  CADICAL_assert (stats.inactive == inactive);
+  CADICAL_assert (max_var == stats.active + stats.inactive);
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_veripbtracer.cpp b/src/sat/cadical/cadical_veripbtracer.cpp
new file mode 100644
index 000000000..b1f7c95a7
--- /dev/null
+++ b/src/sat/cadical/cadical_veripbtracer.cpp
@@ -0,0 +1,400 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+VeripbTracer::VeripbTracer (Internal *i, File *f, bool b, bool a, bool c)
+    : internal (i), file (f), with_antecedents (a), checked_deletions (c),
+      num_clauses (0), size_clauses (0), clauses (0), last_hash (0),
+      last_id (0), last_clause (0)
+#ifndef CADICAL_QUIET
+      ,
+      added (0), deleted (0)
+#endif
+{
+  (void) internal;
+
+  // Initialize random number table for hash function.
+  //
+  Random random (42);
+  for (unsigned n = 0; n < num_nonces; n++) {
+    uint64_t nonce = random.next ();
+    if (!(nonce & 1))
+      nonce++;
+    CADICAL_assert (nonce), CADICAL_assert (nonce & 1);
+    nonces[n] = nonce;
+  }
+#ifndef CADICAL_NDEBUG
+  binary = b;
+#else
+  (void) b;
+#endif
+}
+
+void VeripbTracer::connect_internal (Internal *i) {
+  internal = i;
+  file->connect_internal (internal);
+  LOG ("VERIPB TRACER connected to internal");
+}
+
+VeripbTracer::~VeripbTracer () {
+  LOG ("VERIPB TRACER delete");
+  delete file;
+  for (size_t i = 0; i < size_clauses; i++)
+    for (HashId *c = clauses[i], *next; c; c = next)
+      next = c->next, delete_clause (c);
+  delete[] clauses;
+}
+
+/*------------------------------------------------------------------------*/
+
+void VeripbTracer::enlarge_clauses () {
+  CADICAL_assert (num_clauses == size_clauses);
+  const uint64_t new_size_clauses = size_clauses ? 2 * size_clauses : 1;
+  LOG ("VeriPB Tracer enlarging clauses from %" PRIu64 " to %" PRIu64,
+       (uint64_t) size_clauses, (uint64_t) new_size_clauses);
+  HashId **new_clauses;
+  new_clauses = new HashId *[new_size_clauses];
+  clear_n (new_clauses, new_size_clauses);
+  for (uint64_t i = 0; i < size_clauses; i++) {
+    for (HashId *c = clauses[i], *next; c; c = next) {
+      next = c->next;
+      const uint64_t h = reduce_hash (c->hash, new_size_clauses);
+      c->next = new_clauses[h];
+      new_clauses[h] = c;
+    }
+  }
+  delete[] clauses;
+  clauses = new_clauses;
+  size_clauses = new_size_clauses;
+}
+
+HashId *VeripbTracer::new_clause () {
+  HashId *res = new HashId ();
+  res->next = 0;
+  res->hash = last_hash;
+  res->id = last_id;
+  last_clause = res;
+  num_clauses++;
+  return res;
+}
+
+void VeripbTracer::delete_clause (HashId *c) {
+  CADICAL_assert (c);
+  num_clauses--;
+  delete c;
+}
+
+uint64_t VeripbTracer::reduce_hash (uint64_t hash, uint64_t size) {
+  CADICAL_assert (size > 0);
+  unsigned shift = 32;
+  uint64_t res = hash;
+  while ((((uint64_t) 1) << shift) > size) {
+    res ^= res >> shift;
+    shift >>= 1;
+  }
+  res &= size - 1;
+  CADICAL_assert (res < size);
+  return res;
+}
+
+uint64_t VeripbTracer::compute_hash (const int64_t id) {
+  CADICAL_assert (id > 0);
+  unsigned j = id % num_nonces;             // Dont know if this is a good
+  uint64_t tmp = nonces[j] * (uint64_t) id; // hash funktion or even better
+  return last_hash = tmp;                   // than just using id.
+}
+
+bool VeripbTracer::find_and_delete (const int64_t id) {
+  if (!num_clauses)
+    return false;
+  /*
+  if (last_clause && last_clause->id == id) {
+    const uint64_t h = reduce_hash (last_clause->hash, size_clauses);
+    clauses[h] = last_clause->next;
+    delete last_clause;
+    return true;
+  }
+  */
+  HashId **res = 0, *c;
+  const uint64_t hash = compute_hash (id);
+  const uint64_t h = reduce_hash (hash, size_clauses);
+  for (res = clauses + h; (c = *res); res = &c->next) {
+    if (c->hash == hash && c->id == id) {
+      break;
+    }
+    if (!c->next)
+      return false;
+  }
+  if (!c)
+    return false;
+  CADICAL_assert (c && res);
+  *res = c->next;
+  delete_clause (c);
+  return true;
+}
+
+void VeripbTracer::insert () {
+  if (num_clauses == size_clauses)
+    enlarge_clauses ();
+  const uint64_t h = reduce_hash (compute_hash (last_id), size_clauses);
+  HashId *c = new_clause ();
+  c->next = clauses[h];
+  clauses[h] = c;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline void VeripbTracer::put_binary_zero () {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  file->put ((unsigned char) 0);
+}
+
+inline void VeripbTracer::put_binary_lit (int lit) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  CADICAL_assert (lit != INT_MIN);
+  unsigned x = 2 * abs (lit) + (lit < 0);
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+inline void VeripbTracer::put_binary_id (int64_t id, bool can_be_negative) {
+  CADICAL_assert (binary);
+  CADICAL_assert (file);
+  uint64_t x = abs (id);
+  if (can_be_negative) {
+    x = 2 * x + (id < 0);
+  }
+  unsigned char ch;
+  while (x & ~0x7f) {
+    ch = (x & 0x7f) | 0x80;
+    file->put (ch);
+    x >>= 7;
+  }
+  ch = x;
+  file->put (ch);
+}
+
+/*------------------------------------------------------------------------*/
+
+void VeripbTracer::veripb_add_derived_clause (
+    int64_t id, bool redundant, const vector<int> &clause,
+    const vector<int64_t> &chain) {
+  file->put ("pol ");
+  bool first = true;
+  for (auto p = chain.rbegin (); p != chain.rend (); p++) {
+    auto cid = *p;
+    if (first) {
+      first = false;
+      file->put (cid);
+    } else {
+      file->put (' ');
+      file->put (cid);
+      file->put (" + s");
+    }
+  }
+  file->put ("\n");
+  file->put ("e ");
+  for (const auto &external_lit : clause) {
+    file->put ("1 ");
+    if (external_lit < 0)
+      file->put ('~');
+    file->put ('x');
+    file->put (abs (external_lit));
+    file->put (' ');
+  }
+  file->put (">= 1 ; ");
+  file->put (id);
+  file->put (" ;\n");
+  if (!redundant && checked_deletions) {
+    file->put ("core id ");
+    file->put (id);
+    file->put ("\n");
+  }
+}
+
+void VeripbTracer::veripb_add_derived_clause (int64_t id, bool redundant,
+                                              const vector<int> &clause) {
+  file->put ("rup ");
+  for (const auto &external_lit : clause) {
+    file->put ("1 ");
+    if (external_lit < 0)
+      file->put ('~');
+    file->put ('x');
+    file->put (abs (external_lit));
+    file->put (' ');
+  }
+  file->put (">= 1 ;\n");
+  if (!redundant && checked_deletions) {
+    file->put ("core id ");
+    file->put (id);
+    file->put ("\n");
+  }
+}
+
+void VeripbTracer::veripb_begin_proof (int64_t reserved_ids) {
+  file->put ("pseudo-Boolean proof version 2.0\n");
+  file->put ("f ");
+  file->put (reserved_ids);
+  file->put ("\n");
+}
+
+void VeripbTracer::veripb_delete_clause (int64_t id, bool redundant) {
+  if (!redundant && checked_deletions && find_and_delete (id))
+    return;
+  if (redundant || !checked_deletions)
+    file->put ("del id ");
+  else {
+    file->put ("delc ");
+  }
+  file->put (id);
+  file->put ("\n");
+}
+
+void VeripbTracer::veripb_report_status (bool unsat, int64_t conflict_id) {
+  file->put ("output NONE\n");
+  if (unsat) {
+    file->put ("conclusion UNSAT : ");
+    file->put (conflict_id);
+    file->put (" \n");
+  } else
+    file->put ("conclusion NONE\n");
+  file->put ("end pseudo-Boolean proof\n");
+}
+
+void VeripbTracer::veripb_strengthen (int64_t id) {
+  if (!checked_deletions)
+    return;
+  file->put ("core id ");
+  file->put (id);
+  file->put ("\n");
+}
+
+/*------------------------------------------------------------------------*/
+
+void VeripbTracer::begin_proof (int64_t id) {
+  if (file->closed ())
+    return;
+  LOG ("VERIPB TRACER tracing start of proof with %" PRId64
+       "original clauses",
+       id);
+  veripb_begin_proof (id);
+}
+
+void VeripbTracer::add_derived_clause (int64_t id, bool redundant,
+                                       const vector<int> &clause,
+                                       const vector<int64_t> &chain) {
+  if (file->closed ())
+    return;
+  LOG ("VERIPB TRACER tracing addition of derived clause[%" PRId64 "]", id);
+  if (with_antecedents)
+    veripb_add_derived_clause (id, redundant, clause, chain);
+  else
+    veripb_add_derived_clause (id, redundant, clause);
+#ifndef CADICAL_QUIET
+  added++;
+#endif
+}
+
+void VeripbTracer::delete_clause (int64_t id, bool redundant,
+                                  const vector<int> &) {
+  if (file->closed ())
+    return;
+  LOG ("VERIPB TRACER tracing deletion of clause[%" PRId64 "]", id);
+  veripb_delete_clause (id, redundant);
+#ifndef CADICAL_QUIET
+  deleted++;
+#endif
+}
+
+void VeripbTracer::report_status (int status, int64_t conflict_id) {
+  if (file->closed ())
+    return;
+#ifdef LOGGING
+  if (conflict_id)
+    LOG ("VERIPB TRACER tracing finalization of proof with empty "
+         "clause[%" PRId64 "]",
+         conflict_id);
+#endif
+  veripb_report_status (status == UNSATISFIABLE, conflict_id);
+}
+
+void VeripbTracer::weaken_minus (int64_t id, const vector<int> &) {
+  if (!checked_deletions)
+    return;
+  if (file->closed ())
+    return;
+  LOG ("VERIPB TRACER tracing weaken minus of clause[%" PRId64 "]", id);
+  last_id = id;
+  insert ();
+}
+
+void VeripbTracer::strengthen (int64_t id) {
+  if (file->closed ())
+    return;
+  LOG ("VERIPB TRACER tracing strengthen of clause[%" PRId64 "]", id);
+  veripb_strengthen (id);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool VeripbTracer::closed () { return file->closed (); }
+
+#ifndef CADICAL_QUIET
+
+void VeripbTracer::print_statistics () {
+  // TODO complete
+  uint64_t bytes = file->bytes ();
+  uint64_t total = added + deleted;
+  MSG ("VeriPB %" PRId64 " added clauses %.2f%%", added,
+       percent (added, total));
+  MSG ("VeriPB %" PRId64 " deleted clauses %.2f%%", deleted,
+       percent (deleted, total));
+  MSG ("VeriPB %" PRId64 " bytes (%.2f MB)", bytes,
+       bytes / (double) (1 << 20));
+}
+
+#endif
+
+void VeripbTracer::close (bool print) {
+  CADICAL_assert (!closed ());
+  file->close ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("VeriPB proof file '%s' closed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+void VeripbTracer::flush (bool print) {
+  CADICAL_assert (!closed ());
+  file->flush ();
+#ifndef CADICAL_QUIET
+  if (print) {
+    MSG ("VeriPB proof file '%s' flushed", file->name ());
+    print_statistics ();
+  }
+#else
+  (void) print;
+#endif
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_version.cpp b/src/sat/cadical/cadical_version.cpp
new file mode 100644
index 000000000..a0cceef63
--- /dev/null
+++ b/src/sat/cadical/cadical_version.cpp
@@ -0,0 +1,113 @@
+#include "global.h"
+
+/*------------------------------------------------------------------------*/
+
+// To simplify the build process without 'make', you can disable the
+// generation of 'build.hpp' through '../scripts/make-build-header.sh' by
+// defining '-DCADICAL_NBUILD'.  Then we try to guess part of the configuration.
+
+#ifndef CADICAL_NBUILD
+#if __GNUC__ > 4
+#if __has_include(<build.hpp>)
+#include "build.hpp"
+#endif // __has_include
+#else
+#include "build.hpp"
+#endif // __GNUC > 4
+#endif // CADICAL_NBUILD
+
+/*------------------------------------------------------------------------*/
+
+// We prefer short 3 character version numbers made of digits and lower case
+// letters only, which gives 36^3 = 46656 different versions.  The following
+// macro is used for the non-standard build process and only set from
+// the file '../VERSION' with '../scripts/update-version.sh'.  The standard
+// build process relies on 'VERSION' to be defined in 'build.hpp'.
+
+#ifdef CADICAL_NBUILD
+#ifndef VERSION
+#define VERSION "2.2.0-rc1"
+#endif // VERSION
+#endif // CADICAL_NBUILD
+
+    /*------------------------------------------------------------------------*/
+
+    // The copyright of the code is here.
+
+    static const char *COPYRIGHT = "Copyright (c) 2016-2024";
+static const char *AUTHORS =
+    "A. Biere, M. Fleury, N. Froleyks, K. Fazekas, F. Pollitt, T. Faller";
+static const char *AFFILIATIONS =
+    "JKU Linz, University of Freiburg, TU Wien";
+
+/*------------------------------------------------------------------------*/
+
+// Again if we do not have 'CADICAL_NBUILD' or if something during configuration is
+// broken we still want to be able to compile the solver.  In this case we
+// then try our best to figure out 'COMPILER' and 'DATE', but for
+// 'IDENTIFIER' and 'FLAGS' we can only use the '0' string, which marks
+// those as unknown.
+
+#ifndef COMPILER
+#ifdef __clang__
+#ifdef __VERSION__
+#define COMPILER "clang++-" __VERSION__
+#else
+#define COMPILER "clang++"
+#endif
+#elif defined(__GNUC__)
+#ifdef __VERSION__
+#define COMPILER "g++-" __VERSION__
+#else
+#define COMPILER "g++"
+#endif
+#else
+#define COMPILER 0
+#endif
+#endif
+
+// GIT SHA2 identifier.
+//
+#ifndef IDENTIFIER
+#define IDENTIFIER 0
+#endif
+#ifdef SHORTID
+#define SHORTIDSTR "-" SHORTID
+#else
+#define SHORTIDSTR ""
+#define SHORTID 0
+#endif
+
+// Compilation flags.
+//
+#ifndef FLAGS
+#define FLAGS 0
+#endif
+
+// Build Time and operating system.
+//
+#ifndef DATE
+#define DATE __DATE__ " " __TIME__
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#include "version.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+const char *version () { return VERSION; }
+const char *copyright () { return COPYRIGHT; }
+const char *authors () { return AUTHORS; }
+const char *affiliations () { return AFFILIATIONS; }
+const char *signature () { return "cadical-" VERSION SHORTIDSTR; }
+const char *identifier () { return IDENTIFIER; }
+const char *compiler () { return COMPILER; }
+const char *date () { return DATE; }
+const char *flags () { return FLAGS; }
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_vivify.cpp b/src/sat/cadical/cadical_vivify.cpp
new file mode 100644
index 000000000..8d99c2932
--- /dev/null
+++ b/src/sat/cadical/cadical_vivify.cpp
@@ -0,0 +1,1962 @@
+#include "global.h"
+
+#include "vivify.hpp"
+#include "internal.hpp"
+#include "util.hpp"
+#include <algorithm>
+#include <limits>
+#include <utility>
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Vivification is a special case of asymmetric tautology elimination (ATE)
+// and asymmetric literal elimination (ALE).  It strengthens and removes
+// clauses proven redundant through unit propagation.
+//
+// The original algorithm is due to a paper by Piette, Hamadi and Sais
+// published at ECAI'08.  We have an inprocessing version, e.g., it does not
+// necessarily run-to-completion.  Our version also performs conflict
+// analysis and uses a new heuristic for selecting clauses to vivify.
+
+// Our idea is to focus on clauses with many occurrences of its literals in
+// other clauses first.  This both complements nicely our implementation of
+// subsume, which is bounded, e.g., subsumption attempts are skipped for
+// very long clauses with literals with many occurrences and also is
+// stronger in the sense that it enables to remove more clauses due to unit
+// propagation (AT checks).
+
+// While first focusing on irredundant clause we then added a separate phase
+// upfront which focuses on strengthening also redundant clauses in spirit
+// of the ideas presented in the IJCAI'17 paper by M. Luo, C.-M. Li, F.
+// Xiao, F. Manya, and Z. Lu.
+
+// There is another very similar approach called 'distilliation' published
+// by Han and Somenzi in DAC'07, which reorganizes the CNF in a trie data
+// structure to reuse decisions and propagations along the trie.  We used
+// that as an inspiration but instead of building a trie we simple sort
+// clauses and literals in such a way that we get the same effect.  If a new
+// clause is 'distilled' or 'vivified' we first check how many of the
+// decisions (which are only lazily undone) can be reused for that clause.
+// Reusing can be improved by picking a global literal order and sorting the
+// literals in all clauses with respect to that order.  We favor literals
+// with more occurrences first.  Then we sort clauses lexicographically with
+// respect to that literal order.
+
+/*------------------------------------------------------------------------*/
+
+// Candidate clause 'subsumed' is subsumed by 'subsuming'.
+
+inline void Internal::vivify_subsume_clause (Clause *subsuming,
+                                             Clause *subsumed) {
+  stats.subsumed++;
+  stats.vivifysubs++;
+#ifndef CADICAL_NDEBUG
+  CADICAL_assert (subsuming);
+  CADICAL_assert (subsumed);
+  CADICAL_assert (subsuming != subsumed);
+  CADICAL_assert (!subsumed->garbage);
+  // size after removeing units;
+  int real_size_subsuming = 0, real_size_subsumed = 0;
+  for (auto lit : *subsuming) {
+    if (!val (lit) || var (lit).level)
+      ++real_size_subsuming;
+    else
+      CADICAL_assert (val (lit) < 0);
+  }
+  for (auto lit : *subsumed) {
+    if (!val (lit) || var (lit).level)
+      ++real_size_subsumed;
+    else
+      CADICAL_assert (val (lit) < 0);
+  }
+  CADICAL_assert (real_size_subsuming <= real_size_subsumed);
+#endif
+  LOG (subsumed, "subsumed");
+  if (subsumed->redundant) {
+    stats.subred++;
+    ++stats.vivifysubred;
+  } else {
+    stats.subirr++;
+    ++stats.vivifysubirr;
+  }
+  if (subsuming->garbage) {
+    CADICAL_assert (subsuming->size == 2);
+    LOG (subsuming,
+         "binary subsuming clause was already deleted, so undeleting");
+    subsuming->garbage = false;
+    subsuming->glue = 1;
+    ++stats.current.total;
+    if (subsuming->redundant)
+      stats.current.redundant++;
+    else
+      stats.current.irredundant++, stats.irrlits += subsuming->size;
+  }
+  if (subsumed->redundant || !subsuming->redundant) {
+    mark_garbage (subsumed);
+    return;
+  }
+  LOG ("turning redundant subsuming clause into irredundant clause");
+  subsuming->redundant = false;
+  if (proof)
+    proof->strengthen (subsuming->id);
+  mark_garbage (subsumed);
+  mark_added (subsuming);
+  stats.current.irredundant++;
+  stats.added.irredundant++;
+  stats.irrlits += subsuming->size;
+  CADICAL_assert (stats.current.redundant > 0);
+  stats.current.redundant--;
+  CADICAL_assert (stats.added.redundant > 0);
+  stats.added.redundant--;
+  // ... and keep 'stats.added.total'.
+}
+
+// demoting a clause (opposite is promote from subsume.cpp)
+
+inline void Internal::demote_clause (Clause *c) {
+  stats.subsumed++;
+  stats.vivifydemote++;
+  LOG (c, "demoting");
+  CADICAL_assert (!c->redundant);
+  mark_removed (c);
+  c->redundant = true;
+  CADICAL_assert (stats.current.irredundant > 0);
+  stats.current.irredundant--;
+  CADICAL_assert (stats.added.irredundant > 0);
+  stats.added.irredundant--;
+  stats.irrlits -= c->size;
+  stats.current.redundant++;
+  stats.added.redundant++;
+  c->glue = c->size - 1;
+  // ... and keep 'stats.added.total'.
+}
+
+/*------------------------------------------------------------------------*/
+// For vivification we have a separate dedicated propagation routine, which
+// prefers to propagate binary clauses first.  It also uses its own
+// assignment procedure 'vivify_assign', which does not mess with phase
+// saving during search nor the conflict and other statistics and further
+// can be inlined separately here.  The propagation routine needs to ignore
+// (large) clauses which are currently vivified.
+
+inline void Internal::vivify_assign (int lit, Clause *reason) {
+  require_mode (VIVIFY);
+  const int idx = vidx (lit);
+  CADICAL_assert (!vals[idx]);
+  CADICAL_assert (!flags (idx).eliminated () || !reason);
+  Var &v = var (idx);
+  v.level = level;               // required to reuse decisions
+  v.trail = (int) trail.size (); // used in 'vivify_better_watch'
+  CADICAL_assert ((int) num_assigned < max_var);
+  num_assigned++;
+  v.reason = level ? reason : 0; // for conflict analysis
+  if (!level)
+    learn_unit_clause (lit);
+  const signed char tmp = sign (lit);
+  vals[idx] = tmp;
+  vals[-idx] = -tmp;
+  CADICAL_assert (val (lit) > 0);
+  CADICAL_assert (val (-lit) < 0);
+  trail.push_back (lit);
+  LOG (reason, "vivify assign %d", lit);
+}
+
+// Assume negated literals in candidate clause.
+
+void Internal::vivify_assume (int lit) {
+  require_mode (VIVIFY);
+  level++;
+  control.push_back (Level (lit, trail.size ()));
+  LOG ("vivify decide %d", lit);
+  CADICAL_assert (level > 0);
+  CADICAL_assert (propagated == trail.size ());
+  vivify_assign (lit, 0);
+}
+
+// Dedicated routine similar to 'propagate' in 'propagate.cpp' and
+// 'probe_propagate' with 'probe_propagate2' in 'probe.cpp'.  Please refer
+// to that code for more explanation on how propagation is implemented.
+
+bool Internal::vivify_propagate (int64_t &ticks) {
+  require_mode (VIVIFY);
+  CADICAL_assert (!unsat);
+  START (propagate);
+  int64_t before = propagated2 = propagated;
+  for (;;) {
+    if (propagated2 != trail.size ()) {
+      const int lit = -trail[propagated2++];
+      LOG ("vivify propagating %d over binary clauses", -lit);
+      Watches &ws = watches (lit);
+      ticks +=
+          1 + cache_lines (ws.size (), sizeof (const_watch_iterator *));
+      for (const auto &w : ws) {
+        if (!w.binary ())
+          continue;
+        const signed char b = val (w.blit);
+        if (b > 0)
+          continue;
+        if (b < 0)
+          conflict = w.clause; // but continue
+        else {
+          ticks++;
+          build_chain_for_units (w.blit, w.clause, 0);
+          vivify_assign (w.blit, w.clause);
+          lrat_chain.clear ();
+        }
+      }
+    } else if (!conflict && propagated != trail.size ()) {
+      const int lit = -trail[propagated++];
+      LOG ("vivify propagating %d over large clauses", -lit);
+      Watches &ws = watches (lit);
+      const const_watch_iterator eow = ws.end ();
+      const_watch_iterator i = ws.begin ();
+      ticks += 1 + cache_lines (ws.size (), sizeof (*i));
+      watch_iterator j = ws.begin ();
+      while (i != eow) {
+        const Watch w = *j++ = *i++;
+        if (w.binary ())
+          continue;
+        if (val (w.blit) > 0)
+          continue;
+        ticks++;
+        if (w.clause->garbage) {
+          j--;
+          continue;
+        }
+        literal_iterator lits = w.clause->begin ();
+        const int other = lits[0] ^ lits[1] ^ lit;
+        const signed char u = val (other);
+        if (u > 0)
+          j[-1].blit = other;
+        else {
+          const int size = w.clause->size;
+          const const_literal_iterator end = lits + size;
+          const literal_iterator middle = lits + w.clause->pos;
+          literal_iterator k = middle;
+          signed char v = -1;
+          int r = 0;
+          while (k != end && (v = val (r = *k)) < 0)
+            k++;
+          if (v < 0) {
+            k = lits + 2;
+            CADICAL_assert (w.clause->pos <= size);
+            while (k != middle && (v = val (r = *k)) < 0)
+              k++;
+          }
+          w.clause->pos = k - lits;
+          CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
+          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;
+            ticks++;
+            watch_literal (r, lit, w.clause);
+            j--;
+          } else if (!u) {
+            if (w.clause == ignore) {
+              LOG ("ignoring propagation due to clause to vivify");
+              continue;
+            }
+            ticks++;
+            CADICAL_assert (v < 0);
+            vivify_chain_for_units (other, w.clause);
+            vivify_assign (other, w.clause);
+            lrat_chain.clear ();
+          } else {
+            if (w.clause == ignore) {
+              LOG ("ignoring conflict due to clause to vivify");
+              continue;
+            }
+            CADICAL_assert (u < 0);
+            CADICAL_assert (v < 0);
+            conflict = w.clause;
+            break;
+          }
+        }
+      }
+      if (j != i) {
+        while (i != eow)
+          *j++ = *i++;
+        ws.resize (j - ws.begin ());
+      }
+    } else
+      break;
+  }
+  int64_t delta = propagated2 - before;
+  stats.propagations.vivify += delta;
+  if (conflict)
+    LOG (conflict, "conflict");
+  STOP (propagate);
+  return !conflict;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether a literal occurs less often.  In the implementation below
+// (search for 'int64_t score = ...' or '@4') we actually compute a
+// weighted occurrence count similar to the Jeroslow Wang heuristic.
+
+struct vivify_more_noccs {
+
+  Internal *internal;
+
+  vivify_more_noccs (Internal *i) : internal (i) {}
+
+  bool operator() (int a, int b) {
+    int64_t n = internal->noccs (a);
+    int64_t m = internal->noccs (b);
+    if (n > m)
+      return true; // larger occurrences / score first
+    if (n < m)
+      return false; // smaller occurrences / score last
+    if (a == -b)
+      return a > 0;           // positive literal first
+    return abs (a) < abs (b); // smaller index first
+  }
+};
+
+struct vivify_more_noccs_kissat {
+
+  Internal *internal;
+
+  vivify_more_noccs_kissat (Internal *i) : internal (i) {}
+
+  bool operator() (int a, int b) {
+    unsigned t = internal->noccs (a);
+    unsigned s = internal->noccs (b);
+    return ((t - s) | ((b - a) & ~(s - t))) >> 31;
+  }
+};
+
+// Sort candidate clauses by the number of occurrences (actually by their
+// score) of their literals, with clauses to be vivified first last.   We
+// assume that clauses are sorted w.r.t. more occurring (higher score)
+// literals first (with respect to 'vivify_more_noccs').
+//
+// For example if there are the following (long irredundant) clauses
+//
+//   1 -3 -4      (A)
+//  -1 -2  3 4    (B)
+//   2 -3  4      (C)
+//
+// then we have the following literal scores using Jeroslow Wang scores and
+// normalizing it with 2^12 (which is the same as 1<<12):
+//
+//  nocc ( 1) = 2^12 * (2^-3       ) =  512  3.
+//  nocc (-1) = 2^12 * (2^-4       ) =  256  6.
+//  nocc ( 2) = 2^12 * (2^-3       ) =  512  4.
+//  nocc (-2) = 2^12 * (2^-4       ) =  256  7.                 @1
+//  nocc ( 3) = 2^12 * (2^-4       ) =  256  8.
+//  nocc (-3) = 2^12 * (2^-3 + 2^-3) = 1024  1.
+//  nocc ( 4) = 2^12 * (2^-3 + 2^-4) =  768  2.
+//  nocc (-4) = 2^12 * (2^-3       ) =  512  5.
+//
+// which gives the literal order (according to 'vivify_more_noccs')
+//
+//  -3, 4, 1, 2, -4, -1, -2, 3
+//
+// Then sorting the literals in each clause gives
+//
+//  -3  1 -4     (A')
+//   4 -1 -2  3  (B')                                           @2
+//  -3  4  2     (C')
+//
+// and finally sorting those clauses lexicographically w.r.t. scores is
+//
+//  -3  4  2     (C')
+//  -3  1 -4     (A')                                           @3
+//   4 -1 -2  3  (B')
+//
+// This order is defined by 'vivify_clause_later' which returns 'true' if
+// the first clause should be vivified later than the second.
+
+struct vivify_clause_later {
+
+  Internal *internal;
+
+  vivify_clause_later (Internal *i) : internal (i) {}
+
+  bool operator() (Clause *a, Clause *b) const {
+
+    if (a == b)
+      return false;
+
+    // First focus on clauses scheduled in the last vivify round but not
+    // checked yet since then.
+    //
+    if (!a->vivify && b->vivify)
+      return true;
+    if (a->vivify && !b->vivify)
+      return false;
+
+    // Among redundant clauses (in redundant mode) prefer small glue.
+    //
+    if (a->redundant) {
+      CADICAL_assert (b->redundant);
+      if (a->glue > b->glue)
+        return true;
+      if (a->glue < b->glue)
+        return false;
+    }
+
+    // Then prefer shorter size.
+    //
+    if (a->size > b->size)
+      return true;
+    if (a->size < b->size)
+      return false;
+
+    // Now compare literals in the clauses lexicographically with respect to
+    // the literal order 'vivify_more_noccs' assuming literals are sorted
+    // decreasingly with respect to that order.
+    //
+    const auto eoa = a->end (), eob = b->end ();
+    auto j = b->begin ();
+    for (auto i = a->begin (); i != eoa && j != eob; i++, j++)
+      if (*i != *j)
+        return vivify_more_noccs (internal) (*j, *i);
+
+    return j == eob; // Prefer shorter clauses to be vivified first.
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Attempting on-the-fly subsumption during sorting when the last line is
+// reached in 'vivify_clause_later' above turned out to be trouble some for
+// identical clauses.  This is the single point where 'vivify_clause_later'
+// is not asymmetric and would require 'stable' sorting for determinism.  It
+// can also not be made 'complete' on-the-fly.  Instead of on-the-fly
+// subsumption we thus go over the sorted scheduled in a linear scan
+// again and remove certain subsumed clauses (the subsuming clause is
+// syntactically a prefix of the subsumed clause), which includes
+// those troublesome syntactically identical clauses.
+
+struct vivify_flush_smaller {
+
+  bool operator() (Clause *a, Clause *b) const {
+
+    const auto eoa = a->end (), eob = b->end ();
+    auto i = a->begin (), j = b->begin ();
+    for (; i != eoa && j != eob; i++, j++)
+      if (*i != *j)
+        return *i < *j;
+
+    return j == eob && i != eoa;
+  }
+};
+
+void Internal::flush_vivification_schedule (std::vector<Clause *> &schedule,
+                                            int64_t &ticks) {
+  ticks += 1 + 3 * cache_lines (schedule.size (), sizeof (Clause *));
+  stable_sort (schedule.begin (), schedule.end (), vivify_flush_smaller ());
+
+  const auto end = schedule.end ();
+  auto j = schedule.begin (), i = j;
+
+  Clause *prev = 0;
+  int64_t subsumed = 0;
+  for (; i != end; i++) {
+    ticks++;
+    Clause *c = *j++ = *i;
+    if (!prev || c->size < prev->size) {
+      prev = c;
+      continue;
+    }
+    const auto eop = prev->end ();
+    auto k = prev->begin ();
+    for (auto l = c->begin (); k != eop; k++, l++)
+      if (*k != *l)
+        break;
+    if (k == eop) {
+      LOG (c, "found subsumed");
+      LOG (prev, "subsuming");
+      CADICAL_assert (!c->garbage);
+      CADICAL_assert (!prev->garbage);
+      CADICAL_assert (c->redundant || !prev->redundant);
+      mark_garbage (c);
+      subsumed++;
+      j--;
+    } else
+      prev = c;
+  }
+
+  if (subsumed)
+    PHASE ("vivify", stats.vivifications,
+           "flushed %" PRId64 " subsumed scheduled clauses", subsumed);
+
+  stats.vivifysubs += subsumed;
+
+  if (subsumed) {
+    schedule.resize (j - schedule.begin ());
+    shrink_vector (schedule);
+  } else
+    CADICAL_assert (j == end);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Depending on whether we try to vivify redundant or irredundant clauses,
+// we schedule a clause to be vivified.  For redundant clauses we initially
+// only try to vivify them if they are likely to survive the next 'reduce'
+// operation, but this left the last schedule empty most of the time.
+
+bool Internal::consider_to_vivify_clause (Clause *c) {
+  if (c->garbage)
+    return false;
+  if (opts.vivifyonce >= 1 && c->redundant && c->vivified)
+    return false;
+  if (opts.vivifyonce >= 2 && !c->redundant && c->vivified)
+    return false;
+  if (!c->redundant)
+    return true;
+  CADICAL_assert (c->redundant);
+
+  // likely_to_be_kept_clause is too aggressive at removing tier-3 clauses
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+// In a strengthened clause the idea is to move non-false literals to the
+// front, followed by false literals.  Literals are further sorted by
+// reverse assignment order.  The goal is to use watches which require to
+// backtrack as few as possible decision levels.
+
+struct vivify_better_watch {
+
+  Internal *internal;
+
+  vivify_better_watch (Internal *i) : internal (i) {}
+
+  bool operator() (int a, int b) {
+
+    const signed char av = internal->val (a), bv = internal->val (b);
+
+    if (av >= 0 && bv < 0)
+      return true;
+    if (av < 0 && bv >= 0)
+      return false;
+
+    return internal->var (a).trail > internal->var (b).trail;
+  }
+};
+
+// Common code to actually strengthen a candidate clause.  The resulting
+// strengthened clause is communicated through the global 'clause'.
+
+void Internal::vivify_strengthen (Clause *c) {
+
+  CADICAL_assert (!clause.empty ());
+
+  if (clause.size () == 1) {
+
+    backtrack_without_updating_phases ();
+    const int unit = clause[0];
+    LOG (c, "vivification shrunken to unit %d", unit);
+    CADICAL_assert (!val (unit));
+    assign_unit (unit);
+    // lrat_chain.clear ();   done in search_assign
+    stats.vivifyunits++;
+
+    bool ok = propagate ();
+    if (!ok)
+      learn_empty_clause ();
+
+  } else {
+
+    // See explanation before 'vivify_better_watch' above.
+    //
+    sort (clause.begin (), clause.end (), vivify_better_watch (this));
+
+    int new_level = level;
+
+    const int lit0 = clause[0];
+    signed char val0 = val (lit0);
+    if (val0 < 0) {
+      const int level0 = var (lit0).level;
+      LOG ("1st watch %d negative at level %d", lit0, level0);
+      new_level = level0 - 1;
+    }
+
+    const int lit1 = clause[1];
+    const signed char val1 = val (lit1);
+    if (val1 < 0 && !(val0 > 0 && var (lit0).level <= var (lit1).level)) {
+      const int level1 = var (lit1).level;
+      LOG ("2nd watch %d negative at level %d", lit1, level1);
+      new_level = level1 - 1;
+    }
+
+    CADICAL_assert (new_level >= 0);
+    if (new_level < level)
+      backtrack (new_level);
+
+    CADICAL_assert (val (lit0) >= 0);
+    CADICAL_assert (val (lit1) >= 0 || (val (lit0) > 0 && val (lit1) < 0 &&
+                                var (lit0).level <= var (lit1).level));
+
+    Clause *d = new_clause_as (c);
+    LOG (c, "before vivification");
+    LOG (d, "after vivification");
+    (void) d;
+  }
+  clause.clear ();
+  mark_garbage (c);
+  lrat_chain.clear ();
+  ++stats.vivifystrs;
+}
+
+void Internal::vivify_sort_watched (Clause *c) {
+
+  sort (c->begin (), c->end (), vivify_better_watch (this));
+
+  int new_level = level;
+
+  const int lit0 = c->literals[0];
+  signed char val0 = val (lit0);
+  if (val0 < 0) {
+    const int level0 = var (lit0).level;
+    LOG ("1st watch %d negative at level %d", lit0, level0);
+    new_level = level0 - 1;
+  }
+
+  const int lit1 = c->literals[1];
+  const signed char val1 = val (lit1);
+  if (val1 < 0 && !(val0 > 0 && var (lit0).level <= var (lit1).level)) {
+    const int level1 = var (lit1).level;
+    LOG ("2nd watch %d negative at level %d", lit1, level1);
+    new_level = level1 - 1;
+  }
+
+  CADICAL_assert (new_level >= 0);
+  if (new_level < level)
+    backtrack (new_level);
+
+  CADICAL_assert (val (lit0) >= 0);
+  CADICAL_assert (val (lit1) >= 0 || (val (lit0) > 0 && val (lit1) < 0 &&
+                              var (lit0).level <= var (lit1).level));
+}
+// Conflict analysis from 'start' which learns a decision only clause.
+//
+// We cannot use the stack-based implementation of Kissat, because we need
+// to iterate over the conflict in topological ordering to produce a valid
+// LRAT proof
+
+void Internal::vivify_analyze (Clause *start, bool &subsumes,
+                               Clause **subsuming,
+                               const Clause *const candidate, int implied,
+                               bool &redundant) {
+  const auto &t = &trail; // normal trail, so next_trail is wrong
+  int i = t->size ();     // Start at end-of-trail.
+  Clause *reason = start;
+  CADICAL_assert (reason);
+  CADICAL_assert (!trail.empty ());
+  int uip = trail.back ();
+  bool mark_implied = (implied);
+
+  while (i >= 0) {
+    if (reason) {
+      redundant = (redundant || reason->redundant);
+      subsumes = (start != reason && reason->size <= start->size);
+      LOG (reason, "resolving on %d with", uip);
+      for (auto other : *reason) {
+        const Var v = var (other);
+        Flags &f = flags (other);
+        if (!marked2 (other) && v.level) {
+          LOG ("not subsuming due to lit %d", other);
+          subsumes = false;
+        }
+        if (!val (other)) {
+          LOG ("skipping unset lit %d", other);
+          continue;
+        }
+        if (other == uip) {
+          continue;
+        }
+        if (!v.level) {
+          if (f.seen || !lrat || reason == start)
+            continue;
+          LOG ("unit reason for %d", other);
+          int64_t id = unit_id (-other);
+          LOG ("adding unit reason %zd for %d", id, other);
+          unit_chain.push_back (id);
+          f.seen = true;
+          analyzed.push_back (other);
+          continue;
+        }
+        if (mark_implied && other != implied) {
+          LOG ("skipping non-implied literal %d on current level", other);
+          continue;
+        }
+
+        CADICAL_assert (val (other));
+        if (f.seen)
+          continue;
+        LOG ("pushing lit %d", other);
+        analyzed.push_back (other);
+        f.seen = true;
+      }
+      if (start->redundant) {
+        const int new_glue = recompute_glue (start);
+        promote_clause (start, new_glue);
+      }
+      if (subsumes) {
+        CADICAL_assert (reason);
+        LOG (reason, "clause found subsuming");
+        LOG (candidate, "clause found subsumed");
+        *subsuming = reason;
+        return;
+      }
+    } else {
+      LOG ("vivify analyzed decision %d", uip);
+      clause.push_back (-uip);
+    }
+    mark_implied = false;
+
+    uip = 0;
+    while (!uip && i > 0) {
+      CADICAL_assert (i > 0);
+      const int lit = (*t)[--i];
+      if (!var (lit).level)
+        continue;
+      if (flags (lit).seen)
+        uip = lit;
+    }
+    if (!uip)
+      break;
+    LOG ("uip is %d", uip);
+    Var &w = var (uip);
+    reason = w.reason;
+    if (lrat && reason)
+      lrat_chain.push_back (reason->id);
+  }
+  (void) candidate;
+}
+
+void Internal::vivify_deduce (Clause *candidate, Clause *conflict,
+                              int implied, Clause **subsuming,
+                              bool &redundant) {
+  CADICAL_assert (lrat_chain.empty ());
+  bool subsumes;
+  Clause *reason;
+
+  CADICAL_assert (clause.empty ());
+  if (implied) {
+    reason = candidate;
+    mark2 (candidate);
+    const int not_implied = -implied;
+    CADICAL_assert (var (not_implied).level);
+    Flags &f = flags (not_implied);
+    f.seen = true;
+    LOG ("pushing implied lit %d", not_implied);
+    analyzed.push_back (not_implied);
+    clause.push_back (implied);
+  } else {
+    reason = (conflict ? conflict : candidate);
+    CADICAL_assert (reason);
+    CADICAL_assert (!reason->garbage);
+    mark2 (candidate);
+    subsumes = (candidate != reason);
+    redundant = reason->redundant;
+    LOG (reason, "resolving with");
+    if (lrat)
+      lrat_chain.push_back (reason->id);
+    for (auto lit : *reason) {
+      const Var &v = var (lit);
+      Flags &f = flags (lit);
+      CADICAL_assert (val (lit) < 0);
+      if (!v.level) {
+        if (!lrat)
+          continue;
+        LOG ("adding unit %d", lit);
+        if (!f.seen) {
+          // nevertheless we can use var (l) as if l was still assigned
+          // because var is updated lazily
+          int64_t id = unit_id (-lit);
+          LOG ("adding unit reason %zd for %d", id, lit);
+          unit_chain.push_back (id);
+        }
+        f.seen = true;
+        analyzed.push_back (lit);
+        continue;
+      }
+      CADICAL_assert (v.level);
+      if (!marked2 (lit)) {
+        LOG ("lit %d is not marked", lit);
+        subsumes = false;
+      }
+      LOG ("analyzing lit %d", lit);
+      LOG ("pushing lit %d", lit);
+      analyzed.push_back (lit);
+      f.seen = true;
+    }
+    if (reason != candidate && reason->redundant) {
+      const int new_glue = recompute_glue (reason);
+      promote_clause (reason, new_glue);
+    }
+    if (subsumes) {
+      CADICAL_assert (candidate != reason);
+#ifndef CADICAL_NDEBUG
+      int nonfalse_reason = 0;
+      for (auto lit : *reason)
+        if (!fixed (lit))
+          ++nonfalse_reason;
+
+      int nonfalse_candidate = 0;
+      for (auto lit : *candidate)
+        if (!fixed (lit))
+          ++nonfalse_candidate;
+
+      CADICAL_assert (nonfalse_reason <= nonfalse_candidate);
+#endif
+      LOG (candidate, "vivify subsumed 0");
+      LOG (reason, "vivify subsuming 0");
+      *subsuming = reason;
+      unmark (candidate);
+      if (lrat)
+        lrat_chain.clear ();
+      return;
+    }
+  }
+
+  vivify_analyze (reason, subsumes, subsuming, candidate, implied,
+                  redundant);
+  unmark (candidate);
+  if (subsumes) {
+    CADICAL_assert (*subsuming);
+    LOG (candidate, "vivify subsumed");
+    LOG (*subsuming, "vivify subsuming");
+    if (lrat)
+      lrat_chain.clear ();
+  }
+}
+/*------------------------------------------------------------------------*/
+
+bool Internal::vivify_shrinkable (const std::vector<int> &sorted,
+                                  Clause *conflict) {
+
+  unsigned count_implied = 0;
+  for (auto lit : sorted) {
+    const signed char value = val (lit);
+    if (!value) {
+      LOG ("vivification unassigned %d", lit);
+      return true;
+    }
+    if (value > 0) {
+      LOG ("vivification implied satisfied %d", lit);
+      if (conflict)
+        return true;
+      if (count_implied++) {
+        LOG ("at least one implied literal with conflict thus shrinking");
+        return true;
+      }
+    } else {
+      CADICAL_assert (value < 0);
+      const Var &v = var (lit);
+      const Flags &f = flags (lit);
+      if (!v.level)
+        continue;
+      if (!f.seen) {
+        LOG ("vivification non-analyzed %d", lit);
+        return true;
+      }
+      if (v.reason) {
+        LOG ("vivification implied falsified %d", lit);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+/*------------------------------------------------------------------------*/
+
+inline void Internal::vivify_increment_stats (const Vivifier &vivifier) {
+  switch (vivifier.tier) {
+  case Vivify_Mode::TIER1:
+    ++stats.vivifystred1;
+    break;
+  case Vivify_Mode::TIER2:
+    ++stats.vivifystred2;
+    break;
+  case Vivify_Mode::TIER3:
+    ++stats.vivifystred3;
+    break;
+  default:
+    CADICAL_assert (vivifier.tier == Vivify_Mode::IRREDUNDANT);
+    ++stats.vivifystrirr;
+    break;
+  }
+}
+/*------------------------------------------------------------------------*/
+// instantiate last literal (see the description of the hack track 2023),
+// fix the watches and
+//  backtrack two level back
+bool Internal::vivify_instantiate (
+    const std::vector<int> &sorted, Clause *c,
+    std::vector<std::tuple<int, Clause *, bool>> &lrat_stack,
+    int64_t &ticks) {
+  LOG ("now trying instantiation");
+  conflict = nullptr;
+  const int lit = sorted.back ();
+  LOG ("vivify instantiation");
+  CADICAL_assert (!var (lit).reason);
+  CADICAL_assert (var (lit).level);
+  CADICAL_assert (val (lit));
+  backtrack (level - 1);
+  CADICAL_assert (val (lit) == 0);
+  stats.vivifydecs++;
+  vivify_assume (lit);
+  bool ok = vivify_propagate (ticks);
+  if (!ok) {
+    LOG (c, "instantiate success with literal %d in", lit);
+    stats.vivifyinst++;
+    // strengthen clause
+    if (lrat) {
+      clear_analyzed_literals ();
+      CADICAL_assert (lrat_chain.empty ());
+      vivify_build_lrat (0, c, lrat_stack);
+      vivify_build_lrat (0, conflict, lrat_stack);
+      clear_analyzed_literals ();
+    }
+    int remove = lit;
+    conflict = nullptr;
+    unwatch_clause (c);
+    backtrack_without_updating_phases (level - 2);
+    strengthen_clause (c, remove);
+    vivify_sort_watched (c);
+    watch_clause (c);
+    CADICAL_assert (!conflict);
+    return true;
+  } else {
+    LOG ("vivify instantiation failed");
+    return false;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Main function: try to vivify this candidate clause in the given mode.
+
+bool Internal::vivify_clause (Vivifier &vivifier, Clause *c) {
+
+  CADICAL_assert (c->size > 2); // see (NO-BINARY) below
+  CADICAL_assert (analyzed.empty ());
+
+  c->vivify = false;  // mark as checked / tried
+  c->vivified = true; // and globally remember
+
+  CADICAL_assert (!c->garbage);
+
+  auto &lrat_stack = vivifier.lrat_stack;
+  auto &ticks = vivifier.ticks;
+  ticks++;
+
+  // First check whether the candidate clause is already satisfied and at
+  // the same time copy its non fixed literals to 'sorted'.  The literals
+  // in the candidate clause might not be sorted anymore due to replacing
+  // watches during propagation, even though we sorted them initially
+  // while pushing the clause onto the schedule and sorting the schedule.
+  //
+  auto &sorted = vivifier.sorted;
+  sorted.clear ();
+
+  for (const auto &lit : *c) {
+    const int tmp = fixed (lit);
+    if (tmp > 0) {
+      LOG (c, "satisfied by propagated unit %d", lit);
+      mark_garbage (c);
+      return false;
+    } else if (!tmp)
+      sorted.push_back (lit);
+  }
+
+  CADICAL_assert (sorted.size () > 1);
+  if (sorted.size () == 2) {
+    LOG ("skipping actual binary");
+    return false;
+  }
+
+  sort (sorted.begin (), sorted.end (), vivify_more_noccs_kissat (this));
+
+  // The actual vivification checking is performed here, by assuming the
+  // negation of each of the remaining literals of the clause in turn and
+  // propagating it.  If a conflict occurs or another literal in the
+  // clause becomes assigned during propagation, we can stop.
+  //
+  LOG (c, "vivification checking");
+  stats.vivifychecks++;
+
+  // If the decision 'level' is non-zero, then we can reuse decisions for
+  // the previous candidate, and avoid re-propagating them.  In preliminary
+  // experiments this saved between 30%-50% decisions (and thus
+  // propagations), which in turn lets us also vivify more clauses within
+  // the same propagation bounds, or terminate earlier if vivify runs to
+  // completion.
+  //
+  if (level) {
+#ifdef LOGGING
+    int orig_level = level;
+#endif
+    // First check whether this clause is actually a reason for forcing
+    // one of its literals to true and then backtrack one level before
+    // that happened.  Otherwise this clause might be incorrectly
+    // considered to be redundant or if this situation is checked then
+    // redundancy by other clauses using this forced literal becomes
+    // impossible.
+    //
+    int forced = 0;
+
+    // This search could be avoided if we would eagerly set the 'reason'
+    // boolean flag of clauses, which however we do not want to do for
+    // binary clauses (during propagation) and thus would still require
+    // a version of 'protect_reason' for binary clauses during 'reduce'
+    // (well binary clauses are not collected during 'reduce', but again
+    // this exception from the exception is pretty complex and thus a
+    // simply search here is probably easier to understand).
+
+    for (const auto &lit : *c) {
+      const signed char tmp = val (lit);
+      if (tmp < 0)
+        continue;
+      if (tmp > 0 && var (lit).reason == c)
+        forced = lit;
+      break;
+    }
+    if (forced) {
+      LOG ("clause is reason forcing %d", forced);
+      CADICAL_assert (var (forced).level);
+      backtrack_without_updating_phases (var (forced).level - 1);
+    }
+
+    // As long the (remaining) literals of the sorted clause match
+    // decisions on the trail we just reuse them.
+    //
+    if (level) {
+
+      int l = 1; // This is the decision level we want to reuse.
+
+      for (const auto &lit : sorted) {
+        CADICAL_assert (!fixed (lit));
+        const int decision = control[l].decision;
+        if (-lit == decision) {
+          LOG ("reusing decision %d at decision level %d", decision, l);
+          stats.vivifyreused++;
+          if (++l > level)
+            break;
+        } else {
+          LOG ("literal %d does not match decision %d at decision level %d",
+               lit, decision, l);
+          backtrack_without_updating_phases (l - 1);
+          break;
+        }
+      }
+    }
+
+    LOG ("reused %d decision levels from %d", level, orig_level);
+  }
+
+  LOG (sorted, "sorted size %zd probing schedule", sorted.size ());
+
+  // Make sure to ignore this clause during propagation.  This is not that
+  // easy for binary clauses (NO-BINARY), e.g., ignoring binary clauses,
+  // without changing 'propagate'. Actually, we do not want to remove binary
+  // clauses which are subsumed.  Those are hyper binary resolvents and
+  // should be kept as learned clauses instead, unless they are transitive
+  // in the binary implication graph, which in turn is detected during
+  // transitive reduction in 'transred'.
+  //
+  ignore = c;
+
+  int subsume = 0; // determined to be redundant / subsumed
+
+  // If the candidate is redundant, i.e., we are in redundant mode, the
+  // clause is subsumed (in one of the two cases below where 'subsume' is
+  // assigned) and further all reasons involved are only binary clauses,
+  // then this redundant clause is what we once called a hidden tautology,
+  // and even for redundant clauses it makes sense to remove the candidate.
+  // It does not add anything to propagation power of the formula.  This is
+  // the same argument as removing transitive clauses in the binary
+  // implication graph during transitive reduction.
+  //
+
+  // Go over the literals in the candidate clause in sorted order.
+  //
+  for (const auto &lit : sorted) {
+
+    // Exit loop as soon a literal is positively implied (case '@5' below)
+    // or propagation of the negation of a literal fails ('@6').
+    //
+    if (subsume)
+      break;
+
+    // We keep on assigning literals, even though we know already that we
+    // can remove one (was negatively implied), since we either might run
+    // into the 'subsume' case above or more false literals become implied.
+    // In any case this might result in stronger vivified clauses.  As a
+    // consequence continue with this loop even if 'remove' is non-zero.
+
+    const signed char tmp = val (lit);
+
+    if (tmp) { // literal already assigned
+
+      const Var &v = var (lit);
+      CADICAL_assert (v.level);
+      if (!v.reason) {
+        LOG ("skipping decision %d", lit);
+        continue;
+      }
+
+      if (tmp < 0) {
+        CADICAL_assert (v.level);
+        LOG ("literal %d is already false and can be removed", lit);
+        continue;
+      }
+
+      CADICAL_assert (tmp > 0);
+      LOG ("subsumed since literal %d already true", lit);
+      subsume = lit; // will be able to subsume candidate '@5'
+      break;
+    }
+
+    CADICAL_assert (!tmp);
+
+    stats.vivifydecs++;
+    vivify_assume (-lit);
+    LOG ("negated decision %d score %" PRId64 "", lit, noccs (lit));
+
+    if (!vivify_propagate (ticks)) {
+      break; // hot-spot
+    }
+  }
+
+  if (subsume) {
+    int better_subsume_trail = var (subsume).trail;
+    for (auto lit : sorted) {
+      if (val (lit) <= 0)
+        continue;
+      const Var v = var (lit);
+      if (v.trail < better_subsume_trail) {
+        LOG ("improving subsume from %d at %d to %d at %d", subsume,
+             better_subsume_trail, lit, v.trail);
+        better_subsume_trail = v.trail;
+        subsume = lit;
+      }
+    }
+  }
+
+  Clause *subsuming = nullptr;
+  bool redundant = false;
+  const int level_after_assumptions = level;
+  CADICAL_assert (level_after_assumptions);
+  vivify_deduce (c, conflict, subsume, &subsuming, redundant);
+
+  bool res;
+
+  // reverse lrat_chain. We could probably work with reversed iterators
+  // (views) to be more efficient but we would have to distinguish in proof
+  //
+  if (lrat) {
+    for (auto id : unit_chain)
+      lrat_chain.push_back (id);
+    unit_chain.clear ();
+    reverse (lrat_chain.begin (), lrat_chain.end ());
+  }
+
+  if (subsuming) {
+    CADICAL_assert (c != subsuming);
+    LOG (c, "deleting subsumed clause");
+    if (c->redundant && subsuming->redundant && c->glue < subsuming->glue) {
+      promote_clause (c, c->glue);
+    }
+    vivify_subsume_clause (subsuming, c);
+    res = false;
+    // stats.vivifysubs++;  // already done in vivify_subsume_clause
+  } else if (vivify_shrinkable (sorted, conflict)) {
+    vivify_increment_stats (vivifier);
+    LOG ("vivify succeeded, learning new clause");
+    clear_analyzed_literals ();
+    LOG (lrat_chain, "lrat");
+    LOG (clause, "learning clause");
+    conflict = nullptr; // TODO dup from below
+    vivify_strengthen (c);
+    res = true;
+  } else if (subsume && c->redundant) {
+    LOG (c, "vivification implied");
+    mark_garbage (c);
+    ++stats.vivifyimplied;
+    res = true;
+  } else if ((conflict || subsume) && !c->redundant && !redundant) {
+    LOG ("demote clause from irredundant to redundant");
+    if (opts.vivifydemote) {
+      demote_clause (c);
+      const int new_glue = recompute_glue (c);
+      promote_clause (c, new_glue);
+      res = false;
+    } else {
+      mark_garbage (c);
+      ++stats.vivifyimplied;
+      res = true;
+    }
+  } else if (subsume) {
+    LOG (c, "no vivification instantiation with implied literal %d",
+         subsume);
+    CADICAL_assert (!c->redundant);
+    CADICAL_assert (redundant);
+    res = false;
+    ++stats.vivifyimplied;
+  } else {
+    CADICAL_assert (level > 2);
+    CADICAL_assert ((size_t) level == sorted.size ());
+    LOG (c, "vivification failed on");
+    lrat_chain.clear ();
+    CADICAL_assert (!subsume);
+    if (!subsume && opts.vivifyinst) {
+      res = vivify_instantiate (sorted, c, lrat_stack, ticks);
+      CADICAL_assert (!conflict);
+    } else {
+      LOG ("cannot apply instantiation");
+      res = false;
+    }
+  }
+
+  if (conflict && level == level_after_assumptions) {
+    LOG ("forcing backtracking at least one level after conflict");
+    backtrack_without_updating_phases (level - 1);
+  }
+
+  clause.clear ();
+  clear_analyzed_literals (); // TODO why needed?
+  lrat_chain.clear ();
+  conflict = nullptr;
+  return res;
+}
+
+// when we can strengthen clause c we have to build lrat.
+// uses f.seen so do not forget to clear flags afterwards.
+// this can happen in three cases. (1), (2) are only sound in redundant mode
+// (1) literal l in c is positively implied. in this case we call the
+// function with (l, l.reason). This justifies the reduction because the new
+// clause c' will include l and all decisions so l.reason is a conflict
+// assuming -c' (2) conflict during vivify propagation. function is called
+// with (0, conflict) similar to (1) but more direct. (3) some literals in c
+// are negatively implied and can therefore be removed. in this case we call
+// the function with (0, c). originally we justified each literal in c on
+// its own but this is not actually necessary.
+//
+
+// Non-recursive version, as some bugs have been found.  DFS over the
+// reasons with preordering (aka we explore the entire reason before
+// exploring deeper)
+void Internal::vivify_build_lrat (
+    int lit, Clause *reason,
+    std::vector<std::tuple<int, Clause *, bool>> &stack) {
+  CADICAL_assert (stack.empty ());
+  stack.push_back ({lit, reason, false});
+  while (!stack.empty ()) {
+    int lit;
+    Clause *reason;
+    bool finished;
+    std::tie (lit, reason, finished) = stack.back ();
+    LOG ("VIVIFY LRAT justifying %d", lit);
+    stack.pop_back ();
+    if (lit && flags (lit).seen) {
+      LOG ("skipping already justified");
+      continue;
+    }
+    if (finished) {
+      lrat_chain.push_back (reason->id);
+      if (lit && reason) {
+        Flags &f = flags (lit);
+        f.seen = true;
+        analyzed.push_back (lit); // CADICAL_assert (val (other) < 0);
+        CADICAL_assert (flags (lit).seen);
+      }
+      continue;
+    } else
+      stack.push_back ({lit, reason, true});
+    for (const auto &other : *reason) {
+      if (other == lit)
+        continue;
+      Var &v = var (other);
+      Flags &f = flags (other);
+      if (f.seen)
+        continue;
+      if (!v.level) {
+        const int64_t id = unit_id (-other);
+        lrat_chain.push_back (id);
+        f.seen = true;
+        analyzed.push_back (other);
+        continue;
+      }
+      if (v.reason) { // recursive justification
+        LOG ("VIVIFY LRAT pushing %d", other);
+        stack.push_back ({other, v.reason, false});
+      }
+    }
+  }
+  stack.clear ();
+}
+
+// calculate lrat_chain
+//
+inline void Internal::vivify_chain_for_units (int lit, Clause *reason) {
+  if (!lrat)
+    return;
+  // LOG ("building chain for units");        bad line for debugging
+  // equivalence if (opts.chrono && assignment_level (lit, reason)) return;
+  if (level)
+    return; // not decision level 0
+  CADICAL_assert (lrat_chain.empty ());
+  for (auto &reason_lit : *reason) {
+    if (lit == reason_lit)
+      continue;
+    CADICAL_assert (val (reason_lit));
+    const int signed_reason_lit = val (reason_lit) * reason_lit;
+    int64_t id = unit_id (signed_reason_lit);
+    lrat_chain.push_back (id);
+  }
+  lrat_chain.push_back (reason->id);
+}
+
+vivify_ref create_ref (Internal *internal, Clause *c) {
+  LOG (c, "creating vivify_refs of clause");
+  vivify_ref ref;
+  ref.clause = c;
+  ref.size = c->size;
+  for (int i = 0; i < COUNTREF_COUNTS; ++i)
+    ref.count[i] = 0;
+  ref.vivify = c->vivify;
+  int lits[COUNTREF_COUNTS] = {0};
+  for (int i = 0; i != std::min (COUNTREF_COUNTS, c->size); ++i) {
+    int best = 0;
+    unsigned best_count = 0;
+    for (auto lit : *c) {
+      LOG ("to find best number of occurrences for literal %d, looking at "
+           "literal %d",
+           i, lit);
+      for (int j = 0; j != i; ++j) {
+        LOG ("comparing %d with literal %d", lit, lits[j]);
+        if (lits[j] == lit)
+          goto CONTINUE_WITH_NEXT_LITERAL;
+      }
+      {
+        const int64_t lit_count = internal->noccs (lit);
+        CADICAL_assert (lit_count);
+        LOG ("checking literal %d with %zd occurrences", lit, lit_count);
+        if (lit_count <= best_count)
+          continue;
+        best_count = lit_count;
+        best = lit;
+      }
+    CONTINUE_WITH_NEXT_LITERAL:;
+    }
+    CADICAL_assert (best);
+    CADICAL_assert (best_count);
+    CADICAL_assert (best_count < UINT32_MAX);
+    ref.count[i] =
+        ((uint64_t) best_count << 32) + (uint64_t) internal->vlit (best);
+    LOG ("final count at position %d is %d - %d: %lu", i, best, best_count,
+         ref.count[i]);
+    lits[i] = best;
+  }
+  return ref;
+}
+/*------------------------------------------------------------------------*/
+inline void
+Internal::vivify_prioritize_leftovers ([[maybe_unused]] char tag,
+                                       size_t prioritized,
+                                       std::vector<Clause *> &schedule) {
+  if (prioritized) {
+    PHASE ("vivify", stats.vivifications,
+           "[phase %c] leftovers of %" PRId64 " clause", tag, prioritized);
+  } else {
+    PHASE ("vivify", stats.vivifications,
+           "[phase %c] prioritizing all clause", tag);
+    for (auto c : schedule)
+      c->vivify = true;
+  }
+  const size_t max = opts.vivifyschedmax;
+  if (schedule.size () > max) {
+    if (prioritized) {
+      std::partition (begin (schedule), end (schedule),
+                      [] (Clause *c) { return c->vivify; });
+    }
+    schedule.resize (max);
+  }
+  // let's try to save a bit of memory
+  shrink_vector (schedule);
+}
+
+void Internal::vivify_initialize (Vivifier &vivifier, int64_t &ticks) {
+
+  const int tier1 = vivifier.tier1_limit;
+  const int tier2 = vivifier.tier2_limit;
+  // Count the number of occurrences of literals in all clauses,
+  // particularly binary clauses, which are usually responsible
+  // for most of the propagations.
+  //
+  init_noccs ();
+
+  // Disconnect all watches since we sort literals within clauses.
+  //
+  CADICAL_assert (watching ());
+#if 0
+  clear_watches ();
+#endif
+
+  size_t prioritized_irred = 0, prioritized_tier1 = 0,
+         prioritized_tier2 = 0, prioritized_tier3 = 0;
+  for (const auto &c : clauses) {
+    ++ticks;
+    if (c->size == 2)
+      continue; // see also (NO-BINARY) above
+    if (!consider_to_vivify_clause (c))
+      continue;
+
+    // This computes an approximation of the Jeroslow Wang heuristic
+    // score
+    //
+    //       nocc (L) =     sum       2^(12-|C|)
+    //                   L in C in F
+    //
+    // but we cap the size at 12, that is all clauses of size 12 and
+    // larger contribute '1' to the score, which allows us to use 'long'
+    // numbers. See the example above (search for '@1').
+    //
+    const int shift = 12 - c->size;
+    const int64_t score = shift < 1 ? 1 : (1l << shift); // @4
+    for (const auto lit : *c) {
+      noccs (lit) += score;
+    }
+    LOG (c, "putting clause in candidates");
+    if (!c->redundant)
+      vivifier.schedule_irred.push_back (c),
+          prioritized_irred += (c->vivify);
+    else if (c->glue <= tier1)
+      vivifier.schedule_tier1.push_back (c),
+          prioritized_tier1 += (c->vivify);
+    else if (c->glue <= tier2)
+      vivifier.schedule_tier2.push_back (c),
+          prioritized_tier2 += (c->vivify);
+    else
+      vivifier.schedule_tier3.push_back (c),
+          prioritized_tier3 += (c->vivify);
+    ++ticks;
+  }
+
+  vivify_prioritize_leftovers ('x', prioritized_irred,
+                               vivifier.schedule_irred);
+  vivify_prioritize_leftovers ('u', prioritized_tier1,
+                               vivifier.schedule_tier1);
+  vivify_prioritize_leftovers ('v', prioritized_tier2,
+                               vivifier.schedule_tier2);
+  vivify_prioritize_leftovers ('w', prioritized_tier3,
+                               vivifier.schedule_tier3);
+
+  if (opts.vivifyflush) {
+    clear_watches ();
+    for (auto &sched : vivifier.schedules) {
+      for (const auto &c : sched) {
+        // Literals in scheduled clauses are sorted with their highest score
+        // literals first (as explained above in the example at '@2').  This
+        // is also needed in the prefix subsumption checking below. We do an
+        // approximation below that is done only in the vivify_ref structure
+        // below.
+        //
+        sort (c->begin (), c->end (), vivify_more_noccs (this));
+      }
+      // Flush clauses subsumed by another clause with the same prefix,
+      // which also includes flushing syntactically identical clauses.
+      //
+      flush_vivification_schedule (sched, ticks);
+    }
+    connect_watches (); // watch all relevant clauses
+  }
+#if 0
+  connect_watches (); // watch all relevant clauses
+  vivify_propagate (ticks);
+#endif
+  vivify_propagate (ticks);
+}
+
+inline std::vector<vivify_ref> &current_refs_schedule (Vivifier &vivifier) {
+  switch (vivifier.tier) {
+  case Vivify_Mode::TIER1:
+    return vivifier.refs_schedule_tier1;
+    break;
+  case Vivify_Mode::TIER2:
+    return vivifier.refs_schedule_tier2;
+    break;
+  case Vivify_Mode::TIER3:
+    return vivifier.refs_schedule_tier3;
+    break;
+  default:
+    return vivifier.refs_schedule_irred;
+    break;
+  }
+#ifdef WIN32
+  __assume(false);
+#else
+  __builtin_unreachable ();
+#endif
+}
+
+inline std::vector<Clause *> &current_schedule (Vivifier &vivifier) {
+  switch (vivifier.tier) {
+  case Vivify_Mode::TIER1:
+    return vivifier.schedule_tier1;
+    break;
+  case Vivify_Mode::TIER2:
+    return vivifier.schedule_tier2;
+    break;
+  case Vivify_Mode::TIER3:
+    return vivifier.schedule_tier3;
+    break;
+  default:
+    return vivifier.schedule_irred;
+    break;
+  }
+#ifdef WIN32
+  __assume(false);
+#else
+  __builtin_unreachable ();
+#endif
+}
+
+struct vivify_refcount_rank {
+  int offset;
+  vivify_refcount_rank (int j) : offset (j) {
+    CADICAL_assert (offset < COUNTREF_COUNTS);
+  }
+  typedef uint64_t Type;
+  Type operator() (const vivify_ref &a) const { return a.count[offset]; }
+};
+
+struct vivify_refcount_smaller {
+  int offset;
+  vivify_refcount_smaller (int j) : offset (j) {
+    CADICAL_assert (offset < COUNTREF_COUNTS);
+  }
+  bool operator() (const vivify_ref &a, const vivify_ref &b) const {
+    const auto s = vivify_refcount_rank (offset) (a);
+    const auto t = vivify_refcount_rank (offset) (b);
+    return s < t;
+  }
+};
+
+struct vivify_inversesize_rank {
+  vivify_inversesize_rank () {}
+  typedef uint64_t Type;
+  Type operator() (const vivify_ref &a) const { return ~a.size; }
+};
+
+struct vivify_inversesize_smaller {
+  vivify_inversesize_smaller () {}
+  bool operator() (const vivify_ref &a, const vivify_ref &b) const {
+    const auto s = vivify_inversesize_rank () (a);
+    const auto t = vivify_inversesize_rank () (b);
+    return s < t;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+// There are two modes of vivification, one using all clauses and one
+// focusing on irredundant clauses only.  The latter variant working on
+// irredundant clauses only can also remove irredundant asymmetric
+// tautologies (clauses subsumed through unit propagation), which in
+// redundant mode is incorrect (due to propagating over redundant clauses).
+
+void Internal::vivify_round (Vivifier &vivifier, int64_t ticks_limit) {
+
+  if (unsat)
+    return;
+  if (terminated_asynchronously ())
+    return;
+
+  PHASE ("vivify", stats.vivifications,
+         "starting %c vivification round ticks limit %" PRId64 "",
+         vivifier.tag, ticks_limit);
+
+  PHASE ("vivify", stats.vivifications,
+         "starting %c vivification round ticks limit %" PRId64 "",
+         vivifier.tag, ticks_limit);
+
+  CADICAL_assert (watching ());
+
+  auto &refs_schedule = current_refs_schedule (vivifier);
+  auto &schedule = current_schedule (vivifier);
+
+  int64_t ticks = 1 + schedule.size ();
+
+  // Sort candidates, with first to be tried candidate clause last, i.e.,
+  // many occurrences and high score literals) as in the example explained
+  // above (search for '@3').
+  //
+  if (vivifier.tier != Vivify_Mode::IRREDUNDANT ||
+      irredundant () / 10 < redundant ()) {
+    // Literals in scheduled clauses are sorted with their highest score
+    // literals first (as explained above in the example at '@2').  This is
+    // also needed in the prefix subsumption checking below. We do an
+    // approximation below that is done only in the vivify_ref structure
+    // below.
+    //
+
+    // first build the schedule with vivifier_refs
+    auto end_schedule = end (schedule);
+    refs_schedule.resize (schedule.size ());
+    std::transform (begin (schedule), end_schedule, begin (refs_schedule),
+                    [&] (Clause *c) { return create_ref (this, c); });
+    // now sort by size
+    MSORT (opts.radixsortlim, refs_schedule.begin (), refs_schedule.end (),
+           vivify_inversesize_rank (), vivify_inversesize_smaller ());
+    // now (stable) sort by number of occurrences
+    for (int i = 0; i < COUNTREF_COUNTS; ++i) {
+      const int offset = COUNTREF_COUNTS - 1 - i;
+      MSORT (opts.radixsortlim, refs_schedule.begin (),
+             refs_schedule.end (), vivify_refcount_rank (offset),
+             vivify_refcount_smaller (offset));
+    }
+    // force left-overs at the end
+    std::stable_partition (begin (refs_schedule), end (refs_schedule),
+                           [] (vivify_ref c) { return !c.vivify; });
+    std::transform (begin (refs_schedule), end (refs_schedule),
+                    begin (schedule),
+                    [] (vivify_ref c) { return c.clause; });
+    erase_vector (refs_schedule);
+    LOG ("clause after sorting final:");
+  } else {
+    // skip sorting but still put clauses with the vivify tag at the end to
+    // be done first Kissat does this implicitely by going twice over all
+    // clauses
+    std::stable_partition (begin (schedule), end (schedule),
+                           [] (Clause *c) { return !c->vivify; });
+  }
+
+  // Remember old values of counters to summarize after each round with
+  // verbose messages what happened in that round.
+  //
+  int64_t checked = stats.vivifychecks;
+  int64_t subsumed = stats.vivifysubs;
+  int64_t strengthened = stats.vivifystrs;
+  int64_t units = stats.vivifyunits;
+
+  int64_t scheduled = schedule.size ();
+  stats.vivifysched += scheduled;
+
+  PHASE ("vivify", stats.vivifications,
+         "scheduled %" PRId64 " clauses to be vivified %.0f%%", scheduled,
+         percent (scheduled, stats.current.irredundant));
+
+  // Limit the number of propagations during vivification as in 'probe'.
+  //
+  const int64_t limit = ticks_limit - stats.ticks.vivify;
+  CADICAL_assert (limit >= 0);
+
+  // the clauses might still contain set literals, so propagation since the
+  // beginning
+  propagated2 = propagated = 0;
+
+  if (!unsat && !propagate ()) {
+    LOG ("propagation after connecting watches in inconsistency");
+    learn_empty_clause ();
+  }
+
+  vivifier.ticks = ticks;
+  int retry = 0;
+  while (!unsat && !terminated_asynchronously () && !schedule.empty () &&
+         vivifier.ticks < limit) {
+    Clause *c = schedule.back (); // Next candidate.
+    schedule.pop_back ();
+    if (vivify_clause (vivifier, c) && !c->garbage && c->size > 2 &&
+        retry < opts.vivifyretry) {
+      ++retry;
+      schedule.push_back (c);
+    } else
+      retry = 0;
+  }
+
+  if (level)
+    backtrack_without_updating_phases ();
+
+  if (!unsat) {
+    int64_t still_need_to_be_vivified = schedule.size ();
+#if 0
+    // in the current round we have new_clauses_to_vivify @ leftovers from previous round There are
+    // now two possibilities: (i) we consider all clauses as leftovers, or (ii) only the leftovers
+    // from previous round are considered leftovers.
+    //
+    // CaDiCaL had the first version before. If
+    // commented out we go to the second version.
+    for (auto c : schedule)
+      c->vivify = true;
+#elif 1
+    // if we have gone through all the leftovers, the current clauses are
+    // leftovers for the next round
+    if (!schedule.empty () && !schedule.front ()->vivify &&
+        schedule.back ()->vivify)
+      for (auto c : schedule)
+        c->vivify = true;
+#else
+    // do nothing like in kissat and use the candidates for next time.
+#endif
+    // Preference clauses scheduled but not vivified yet next time.
+    //
+    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,
+             percent (still_need_to_be_vivified, scheduled), scheduled);
+    else {
+      PHASE ("vivify", stats.vivifications,
+             "no previously not yet vivified clause left");
+    }
+
+    erase_vector (schedule); // Reclaim  memory early.
+  }
+
+  if (!unsat) {
+
+    // Since redundant clause were disconnected during propagating vivified
+    // units in redundant mode, and further irredundant clauses are
+    // arbitrarily sorted, we have to propagate all literals again after
+    // connecting the first two literals in the clauses, in order to
+    // reestablish the watching invariant.
+    //
+    propagated2 = propagated = 0;
+
+    if (!propagate ()) {
+      LOG ("propagating vivified units leads to conflict");
+      learn_empty_clause ();
+    }
+  }
+
+  checked = stats.vivifychecks - checked;
+  subsumed = stats.vivifysubs - subsumed;
+  strengthened = stats.vivifystrs - strengthened;
+  units = stats.vivifyunits - units;
+
+  PHASE ("vivify", stats.vivifications,
+         "checked %" PRId64 " clauses %.02f%% of %" PRId64
+         " scheduled using %" PRIu64 " ticks",
+         checked, percent (checked, scheduled), scheduled, vivifier.ticks);
+  if (units)
+    PHASE ("vivify", stats.vivifications,
+           "found %" PRId64 " units %.02f%% of %" PRId64 " checked", units,
+           percent (units, checked), checked);
+  if (subsumed)
+    PHASE ("vivify", stats.vivifications,
+           "subsumed %" PRId64 " clauses %.02f%% of %" PRId64 " checked",
+           subsumed, percent (subsumed, checked), checked);
+  if (strengthened)
+    PHASE ("vivify", stats.vivifications,
+           "strengthened %" PRId64 " clauses %.02f%% of %" PRId64
+           " checked",
+           strengthened, percent (strengthened, checked), checked);
+
+  stats.subsumed += subsumed;
+  stats.strengthened += strengthened;
+  stats.ticks.vivify += vivifier.ticks;
+
+  bool unsuccessful = !(subsumed + strengthened + units);
+  report (vivifier.tag, unsuccessful);
+}
+
+void set_vivifier_mode (Vivifier &vivifier, Vivify_Mode tier) {
+  vivifier.tier = tier;
+  switch (tier) {
+  case Vivify_Mode::TIER1:
+    vivifier.tag = 'u';
+    break;
+  case Vivify_Mode::TIER2:
+    vivifier.tag = 'v';
+    break;
+  case Vivify_Mode::TIER3:
+    vivifier.tag = 'w';
+    break;
+  default:
+    CADICAL_assert (tier == Vivify_Mode::IRREDUNDANT);
+    vivifier.tag = 'x';
+    break;
+  }
+}
+/*------------------------------------------------------------------------*/
+
+void Internal::compute_tier_limits (Vivifier &vivifier) {
+  if (!opts.vivifycalctier) {
+    vivifier.tier1_limit = 2;
+    vivifier.tier2_limit = 6;
+    return;
+  }
+  vivifier.tier1_limit = tier1[false];
+  vivifier.tier2_limit = tier2[false];
+}
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::vivify () {
+
+  if (unsat)
+    return false;
+  if (terminated_asynchronously ())
+    return false;
+  if (!opts.vivify)
+    return false;
+  if (!stats.current.irredundant)
+    return false;
+  if (level)
+    backtrack ();
+  CADICAL_assert (opts.vivify);
+  CADICAL_assert (!level);
+
+  SET_EFFORT_LIMIT (totallimit, vivify, true);
+
+  private_steps = true;
+
+  START_SIMPLIFIER (vivify, VIVIFY);
+  stats.vivifications++;
+
+  // the effort is normalized by dividing by sumeffort below, hence no need
+  // to multiply by 1e-3 (also making the precision better)
+  double tier1effort = !opts.vivifytier1 ? 0 : (double) opts.vivifytier1eff;
+  double tier2effort = !opts.vivifytier2 ? 0 : (double) opts.vivifytier2eff;
+  double tier3effort = !opts.vivifytier3 ? 0 : (double) opts.vivifytier3eff;
+  double irreffort =
+      delaying_vivify_irredundant.bumpreasons.delay () || !opts.vivifyirred
+          ? 0
+          : (double) opts.vivifyirredeff;
+  double sumeffort = tier1effort + tier2effort + tier3effort + irreffort;
+  if (!stats.current.redundant)
+    tier1effort = tier2effort = tier3effort = 0;
+  if (!sumeffort)
+    sumeffort = irreffort = 1;
+  int64_t total = totallimit - stats.ticks.vivify;
+
+  PHASE ("vivify", stats.vivifications,
+         "vivification limit of %" PRId64 " ticks", total);
+  Vivifier vivifier (Vivify_Mode::TIER1);
+  compute_tier_limits (vivifier);
+
+  if (vivifier.tier1_limit == vivifier.tier2_limit) {
+    tier1effort += tier2effort;
+    tier2effort = 0;
+    LOG ("vivification tier1 matches tier2 "
+         "thus using tier2 budget for tier1");
+  }
+  int64_t init_ticks = 0;
+
+  // Refill the schedule every time.  Unchecked clauses are 'saved' by
+  // setting their 'vivify' bit, such that they can be tried next time.
+  //
+  // TODO: count against ticks.vivify directly instead of this unholy
+  // shifting.
+  vivify_initialize (vivifier, init_ticks);
+  stats.ticks.vivify += init_ticks;
+  int64_t limit = stats.ticks.vivify;
+  const double shared_effort = (double) init_ticks / 4.0;
+  if (opts.vivifytier1) {
+    set_vivifier_mode (vivifier, Vivify_Mode::TIER1);
+    if (limit < stats.ticks.vivify)
+      limit = stats.ticks.vivify;
+    const double effort = (total * tier1effort) / sumeffort;
+    CADICAL_assert (std::numeric_limits<int64_t>::max () - (int64_t) effort >=
+            limit);
+    limit += effort;
+    if (limit - shared_effort > stats.ticks.vivify) {
+      limit -= shared_effort;
+      CADICAL_assert (limit >= 0);
+      vivify_round (vivifier, limit);
+    } else {
+      LOG ("building the schedule already used our entire ticks budget for "
+           "tier1");
+    }
+  }
+
+  if (!unsat && tier2effort) {
+    erase_vector (
+        vivifier.schedule_tier1); // save memory (well, not really as we
+                                  // already reached the peak memory)
+    if (limit < stats.ticks.vivify)
+      limit = stats.ticks.vivify;
+    const double effort = (total * tier2effort) / sumeffort;
+    CADICAL_assert (std::numeric_limits<int64_t>::max () - (int64_t) effort >=
+            limit);
+    limit += effort;
+    if (limit - shared_effort > stats.ticks.vivify) {
+      limit -= shared_effort;
+      CADICAL_assert (limit >= 0);
+      set_vivifier_mode (vivifier, Vivify_Mode::TIER2);
+      vivify_round (vivifier, limit);
+    } else {
+      LOG ("building the schedule already used our entire ticks budget for "
+           "tier2");
+    }
+  }
+
+  if (!unsat && tier3effort) {
+    erase_vector (vivifier.schedule_tier2);
+    if (limit < stats.ticks.vivify)
+      limit = stats.ticks.vivify;
+    const double effort = (total * tier3effort) / sumeffort;
+    CADICAL_assert (std::numeric_limits<int64_t>::max () - (int64_t) effort >=
+            limit);
+    limit += effort;
+    if (limit - shared_effort > stats.ticks.vivify) {
+      limit -= shared_effort;
+      CADICAL_assert (limit >= 0);
+      set_vivifier_mode (vivifier, Vivify_Mode::TIER3);
+      vivify_round (vivifier, limit);
+    } else {
+      LOG ("building the schedule already used our entire ticks budget for "
+           "tier3");
+    }
+  }
+
+  if (!unsat && irreffort) {
+    erase_vector (vivifier.schedule_tier3);
+    if (limit < stats.ticks.vivify)
+      limit = stats.ticks.vivify;
+    const double effort = (total * irreffort) / sumeffort;
+    CADICAL_assert (std::numeric_limits<int64_t>::max () - (int64_t) effort >=
+            limit);
+    limit += effort;
+    if (limit - shared_effort > stats.ticks.vivify) {
+      limit -= shared_effort;
+      CADICAL_assert (limit >= 0);
+      set_vivifier_mode (vivifier, Vivify_Mode::IRREDUNDANT);
+      const int old = stats.vivifystrirr;
+      const int old_tried = stats.vivifychecks;
+      vivify_round (vivifier, limit);
+      if (stats.vivifychecks - old_tried == 0 ||
+          (float) (stats.vivifystrirr - old) /
+                  (float) (stats.vivifychecks - old_tried) <
+              0.01) {
+        delaying_vivify_irredundant.bumpreasons.bump_delay ();
+      } else {
+        delaying_vivify_irredundant.bumpreasons.reduce_delay ();
+      }
+    } else {
+      delaying_vivify_irredundant.bumpreasons.bump_delay ();
+      LOG ("building the schedule already used our entire ticks budget for "
+           "irredundant");
+    }
+  }
+
+  reset_noccs ();
+  STOP_SIMPLIFIER (vivify, VIVIFY);
+
+  private_steps = false;
+
+  return true;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_walk.cpp b/src/sat/cadical/cadical_walk.cpp
new file mode 100644
index 000000000..13b1bf9f4
--- /dev/null
+++ b/src/sat/cadical/cadical_walk.cpp
@@ -0,0 +1,710 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Random walk local search based on 'ProbSAT' ideas.
+
+struct Walker {
+
+  Internal *internal;
+
+  Random random;           // local random number generator
+  int64_t propagations;    // number of propagations
+  int64_t limit;           // limit on number of propagations
+  vector<Clause *> broken; // currently unsatisfied clauses
+  double epsilon;          // smallest considered score
+  vector<double> table;    // break value to score table
+  vector<double> scores;   // scores of candidate literals
+
+  double score (unsigned); // compute score from break count
+
+  Walker (Internal *, double size, int64_t limit);
+};
+
+// These are in essence the CB values from Adrian Balint's thesis.  They
+// denote the inverse 'cb' of the base 'b' of the (probability) weight
+// 'b^-i' for picking a literal with the break value 'i' (first column is
+// the 'size', second the 'CB' value).
+
+static double cbvals[][2] = {
+    {0.0, 2.00}, {3.0, 2.50}, {4.0, 2.85}, {5.0, 3.70},
+    {6.0, 5.10}, {7.0, 7.40}, // Adrian has '5.4', but '7.4' looks better.
+};
+
+static const int ncbvals = sizeof cbvals / sizeof cbvals[0];
+
+// We interpolate the CB values for uniform random SAT formula to the non
+// integer situation of average clause size by piecewise linear functions.
+//
+//   y2 - y1
+//   ------- * (x - x1) + y1
+//   x2 - x1
+//
+// where 'x' is the average size of clauses and 'y' the CB value.
+
+inline static double fitcbval (double size) {
+  int i = 0;
+  while (i + 2 < ncbvals &&
+         (cbvals[i][0] > size || cbvals[i + 1][0] < size))
+    i++;
+  const double x2 = cbvals[i + 1][0], x1 = cbvals[i][0];
+  const double y2 = cbvals[i + 1][1], y1 = cbvals[i][1];
+  const double dx = x2 - x1, dy = y2 - y1;
+  CADICAL_assert (dx);
+  const double res = dy * (size - x1) / dx + y1;
+  CADICAL_assert (res > 0);
+  return res;
+}
+
+// Initialize the data structures for one local search round.
+
+Walker::Walker (Internal *i, double size, int64_t l)
+    : internal (i), random (internal->opts.seed), // global random seed
+      propagations (0), limit (l) {
+  random += internal->stats.walk.count; // different seed every time
+
+  // This is the magic constant in ProbSAT (also called 'CB'), which we pick
+  // according to the average size every second invocation and otherwise
+  // just the default '2.0', which turns into the base '0.5'.
+  //
+  const bool use_size_based_cb = (internal->stats.walk.count & 1);
+  const double cb = use_size_based_cb ? fitcbval (size) : 2.0;
+  CADICAL_assert (cb);
+  const double base = 1 / cb; // scores are 'base^0,base^1,base^2,...
+
+  double next = 1;
+  for (epsilon = next; next; next = epsilon * base)
+    table.push_back (epsilon = next);
+
+  PHASE ("walk", internal->stats.walk.count,
+         "CB %.2f with inverse %.2f as base and table size %zd", cb, base,
+         table.size ());
+}
+
+// The scores are tabulated for faster computation (to avoid 'pow').
+
+inline double Walker::score (unsigned i) {
+  const double res = (i < table.size () ? table[i] : epsilon);
+  LOG ("break %u mapped to score %g", i, res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+Clause *Internal::walk_pick_clause (Walker &walker) {
+  require_mode (WALK);
+  CADICAL_assert (!walker.broken.empty ());
+  int64_t size = walker.broken.size ();
+  if (size > INT_MAX)
+    size = INT_MAX;
+  int pos = walker.random.pick_int (0, size - 1);
+  Clause *res = walker.broken[pos];
+  LOG (res, "picking random position %d", pos);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Compute the number of clauses which would be become unsatisfied if 'lit'
+// is flipped and set to false.  This is called the 'break-count' of 'lit'.
+
+unsigned Internal::walk_break_value (int lit) {
+
+  require_mode (WALK);
+  CADICAL_assert (val (lit) > 0);
+
+  unsigned res = 0; // The computed break-count of 'lit'.
+
+  for (auto &w : watches (lit)) {
+    CADICAL_assert (w.blit != lit);
+    if (val (w.blit) > 0)
+      continue;
+    if (w.binary ()) {
+      res++;
+      continue;
+    }
+
+    Clause *c = w.clause;
+    CADICAL_assert (lit == c->literals[0]);
+
+    // Now try to find a second satisfied literal starting at 'literals[1]'
+    // shifting all the traversed literals to right by one position in order
+    // to move such a second satisfying literal to 'literals[1]'.  This move
+    // to front strategy improves the chances to find the second satisfying
+    // literal earlier in subsequent break-count computations.
+    //
+    auto begin = c->begin () + 1;
+    const auto end = c->end ();
+    auto i = begin;
+    int prev = 0;
+    while (i != end) {
+      const int other = *i;
+      *i++ = prev;
+      prev = other;
+      if (val (other) < 0)
+        continue;
+
+      // Found 'other' as second satisfying literal.
+
+      w.blit = other; // Update 'blit'
+      *begin = other; // and move to front.
+
+      break;
+    }
+
+    if (i != end)
+      continue; // Double satisfied!
+
+    // Otherwise restore literals (undo shift to the right).
+    //
+    while (i != begin) {
+      const int other = *--i;
+      *i = prev;
+      prev = other;
+    }
+
+    res++; // Literal 'lit' single satisfies clause 'c'.
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Given an unsatisfied clause 'c', in which we want to flip a literal, we
+// first determine the exponential score based on the break-count of its
+// literals and then sample the literals based on these scores.  The CB
+// value is smaller than one and thus the score is exponentially decreasing
+// with the break-count increasing.  The sampling works as in 'ProbSAT' and
+// 'YalSAT' by summing up the scores and then picking a random limit in the
+// range of zero to the sum, then summing up the scores again and picking
+// the first literal which reaches the limit.  Note, that during incremental
+// SAT solving we can not flip assumed variables.  Those are assigned at
+// decision level one, while the other variables are assigned at two.
+
+int Internal::walk_pick_lit (Walker &walker, Clause *c) {
+  LOG ("picking literal by break-count");
+  CADICAL_assert (walker.scores.empty ());
+  double sum = 0;
+  int64_t propagations = 0;
+  for (const auto lit : *c) {
+    CADICAL_assert (active (lit));
+    if (var (lit).level == 1) {
+      LOG ("skipping assumption %d for scoring", -lit);
+      continue;
+    }
+    CADICAL_assert (active (lit));
+    propagations++;
+    unsigned tmp = walk_break_value (-lit);
+    double score = walker.score (tmp);
+    LOG ("literal %d break-count %u score %g", lit, tmp, score);
+    walker.scores.push_back (score);
+    sum += score;
+  }
+  LOG ("scored %zd literals", walker.scores.size ());
+  CADICAL_assert (!walker.scores.empty ());
+  walker.propagations += propagations;
+  stats.propagations.walk += propagations;
+  CADICAL_assert (walker.scores.size () <= (size_t) c->size);
+  const double lim = sum * walker.random.generate_double ();
+  LOG ("score sum %g limit %g", sum, lim);
+  const auto end = c->end ();
+  auto i = c->begin ();
+  auto j = walker.scores.begin ();
+  int res;
+  for (;;) {
+    CADICAL_assert (i != end);
+    res = *i++;
+    if (var (res).level > 1)
+      break;
+    LOG ("skipping assumption %d without score", -res);
+  }
+  sum = *j++;
+  while (sum <= lim && i != end) {
+    res = *i++;
+    if (var (res).level == 1) {
+      LOG ("skipping assumption %d without score", -res);
+      continue;
+    }
+    sum += *j++;
+  }
+  walker.scores.clear ();
+  LOG ("picking literal %d by break-count", res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::walk_flip_lit (Walker &walker, int lit) {
+
+  require_mode (WALK);
+  LOG ("flipping assign %d", lit);
+  CADICAL_assert (val (lit) < 0);
+
+  // First flip the literal value.
+  //
+  const int tmp = sign (lit);
+  const int idx = abs (lit);
+  set_val (idx, tmp);
+  CADICAL_assert (val (lit) > 0);
+
+  // Then remove 'c' and all other now satisfied (made) clauses.
+  {
+    // Simply go over all unsatisfied (broken) clauses.
+
+    LOG ("trying to make %zd broken clauses", walker.broken.size ());
+
+    // We need to measure (and bound) the memory accesses during traversing
+    // broken clauses in terms of 'propagations'. This is tricky since we
+    // are not actually propagating literals.  Instead we use the clause
+    // variable 'ratio' as an approximation to the number of clauses used
+    // during propagating a literal.  Note that we use a one-watch scheme.
+    // Accordingly the number of broken clauses traversed divided by that
+    // ratio is an approximation of the number of propagation this would
+    // correspond to (in terms of memory access).  To eagerly update these
+    // statistics we simply increment the propagation counter after every
+    // 'ratio' traversed clause.  These propagations are particularly
+    // expensive if the number of broken clauses is large which usually
+    // happens initially.
+    //
+    const double ratio = clause_variable_ratio ();
+    const auto eou = walker.broken.end ();
+    auto j = walker.broken.begin (), i = j;
+#ifdef LOGGING
+    int64_t made = 0;
+#endif
+    int64_t count = 0;
+
+    while (i != eou) {
+
+      Clause *d = *j++ = *i++;
+
+      int *literals = d->literals, prev = 0;
+
+      // Find 'lit' in 'd'.
+      //
+      const int size = d->size;
+      for (int i = 0; i < size; i++) {
+        const int other = literals[i];
+        CADICAL_assert (active (other));
+        literals[i] = prev;
+        prev = other;
+        if (other == lit)
+          break;
+        CADICAL_assert (val (other) < 0);
+      }
+
+      // If 'lit' is in 'd' then move it to the front to watch it.
+      //
+      if (prev == lit) {
+        literals[0] = lit;
+        LOG (d, "made");
+        watch_literal (literals[0], literals[1], d);
+#ifdef LOGGING
+        made++;
+#endif
+        j--;
+
+      } else { // Otherwise the clause is not satisfied, undo shift.
+
+        for (int i = size - 1; i >= 0; i--) {
+          int other = literals[i];
+          literals[i] = prev;
+          prev = other;
+        }
+      }
+
+      if (count--)
+        continue;
+
+      // Update these counters eagerly.  Otherwise if we delay the update
+      // until all clauses are traversed, interrupting the solver has a high
+      // chance of giving bogus statistics on the number of 'propagations'
+      // in 'walk', if it is interrupted in this loop.
+
+      count = ratio; // Starting counting down again.
+      walker.propagations++;
+      stats.propagations.walk++;
+    }
+    LOG ("made %" PRId64 " clauses by flipping %d", made, lit);
+    walker.broken.resize (j - walker.broken.begin ());
+  }
+
+  // Finally add all new unsatisfied (broken) clauses.
+  {
+    walker.propagations++;     // This really corresponds now to one
+    stats.propagations.walk++; // propagation (in a one-watch scheme).
+
+#ifdef LOGGING
+    int64_t broken = 0;
+#endif
+    Watches &ws = watches (-lit);
+
+    LOG ("trying to break %zd watched clauses", ws.size ());
+
+    for (const auto &w : ws) {
+      Clause *d = w.clause;
+      LOG (d, "unwatch %d in", -lit);
+      int *literals = d->literals, replacement = 0, prev = -lit;
+      CADICAL_assert (literals[0] == -lit);
+      const int size = d->size;
+      for (int i = 1; i < size; i++) {
+        const int other = literals[i];
+        CADICAL_assert (active (other));
+        literals[i] = prev; // shift all to right
+        prev = other;
+        const signed char tmp = val (other);
+        if (tmp < 0)
+          continue;
+        replacement = other; // satisfying literal
+        break;
+      }
+      if (replacement) {
+        literals[1] = -lit;
+        literals[0] = replacement;
+        CADICAL_assert (-lit != replacement);
+        watch_literal (replacement, -lit, d);
+      } else {
+        for (int i = size - 1; i > 0; i--) { // undo shift
+          const int other = literals[i];
+          literals[i] = prev;
+          prev = other;
+        }
+        CADICAL_assert (literals[0] == -lit);
+        LOG (d, "broken");
+        walker.broken.push_back (d);
+#ifdef LOGGING
+        broken++;
+#endif
+      }
+    }
+    LOG ("broken %" PRId64 " clauses by flipping %d", broken, lit);
+    ws.clear ();
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Check whether to save the current phases as new global minimum.
+
+inline void Internal::walk_save_minimum (Walker &walker) {
+  int64_t broken = walker.broken.size ();
+  if (broken >= stats.walk.minimum)
+    return;
+  VERBOSE (3, "new global minimum %" PRId64 "", broken);
+  stats.walk.minimum = broken;
+  for (auto i : vars) {
+    const signed char tmp = vals[i];
+    if (tmp)
+      phases.min[i] = phases.saved[i] = tmp;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+int Internal::walk_round (int64_t limit, bool prev) {
+
+  backtrack ();
+  if (propagated < trail.size () && !propagate ()) {
+    LOG ("empty clause after root level propagation");
+    learn_empty_clause ();
+    return 20;
+  }
+
+  stats.walk.count++;
+
+  clear_watches ();
+
+  // Remove all fixed variables first (assigned at decision level zero).
+  //
+  if (last.collect.fixed < stats.all.fixed)
+    garbage_collection ();
+
+#ifndef CADICAL_QUIET
+  // We want to see more messages during initial local search.
+  //
+  if (localsearching) {
+    CADICAL_assert (!force_phase_messages);
+    force_phase_messages = true;
+  }
+#endif
+
+  PHASE ("walk", stats.walk.count,
+         "random walk limit of %" PRId64 " propagations", limit);
+
+  // First compute the average clause size for picking the CB constant.
+  //
+  double size = 0;
+  int64_t n = 0;
+  for (const auto c : clauses) {
+    if (c->garbage)
+      continue;
+    if (c->redundant) {
+      if (!opts.walkredundant)
+        continue;
+      if (!likely_to_be_kept_clause (c))
+        continue;
+    }
+    size += c->size;
+    n++;
+  }
+  double average_size = relative (size, n);
+
+  PHASE ("walk", stats.walk.count,
+         "%" PRId64 " clauses average size %.2f over %d variables", n,
+         average_size, active ());
+
+  // Instantiate data structures for this local search round.
+  //
+  Walker walker (internal, average_size, limit);
+
+  bool failed = false; // Inconsistent assumptions?
+
+  level = 1; // Assumed variables assigned at level 1.
+
+  if (assumptions.empty ()) {
+    LOG ("no assumptions so assigning all variables to decision phase");
+  } else {
+    LOG ("assigning assumptions to their forced phase first");
+    for (const auto lit : assumptions) {
+      signed char tmp = val (lit);
+      if (tmp > 0)
+        continue;
+      if (tmp < 0) {
+        LOG ("inconsistent assumption %d", lit);
+        failed = true;
+        break;
+      }
+      if (!active (lit))
+        continue;
+      tmp = sign (lit);
+      const int idx = abs (lit);
+      LOG ("initial assign %d to assumption phase", tmp < 0 ? -idx : idx);
+      set_val (idx, tmp);
+      CADICAL_assert (level == 1);
+      var (idx).level = 1;
+    }
+    if (!failed)
+      LOG ("now assigning remaining variables to their decision phase");
+  }
+
+  level = 2; // All other non assumed variables assigned at level 2.
+
+  if (!failed) {
+
+    for (auto idx : vars) {
+      if (!active (idx)) {
+        LOG ("skipping inactive variable %d", idx);
+        continue;
+      }
+      if (vals[idx]) {
+        CADICAL_assert (var (idx).level == 1);
+        LOG ("skipping assumed variable %d", idx);
+        continue;
+      }
+      int tmp = 0;
+      if (prev)
+        tmp = phases.prev[idx];
+      if (!tmp)
+        tmp = sign (decide_phase (idx, true));
+      CADICAL_assert (tmp == 1 || tmp == -1);
+      set_val (idx, tmp);
+      CADICAL_assert (level == 2);
+      var (idx).level = 2;
+      LOG ("initial assign %d to decision phase", tmp < 0 ? -idx : idx);
+    }
+
+    LOG ("watching satisfied and registering broken clauses");
+#ifdef LOGGING
+    int64_t watched = 0;
+#endif
+    for (const auto c : clauses) {
+
+      if (c->garbage)
+        continue;
+      if (c->redundant) {
+        if (!opts.walkredundant)
+          continue;
+        if (!likely_to_be_kept_clause (c))
+          continue;
+      }
+
+      bool satisfiable = false; // contains not only assumptions
+      int satisfied = 0;        // clause satisfied?
+
+      int *lits = c->literals;
+      const int size = c->size;
+
+      // Move to front satisfied literals and determine whether there
+      // is at least one (non-assumed) literal that can be flipped.
+      //
+      for (int i = 0; satisfied < 2 && i < size; i++) {
+        const int lit = lits[i];
+        CADICAL_assert (active (lit)); // Due to garbage collection.
+        if (val (lit) > 0) {
+          swap (lits[satisfied], lits[i]);
+          if (!satisfied++)
+            LOG ("first satisfying literal %d", lit);
+        } else if (!satisfiable && var (lit).level > 1) {
+          LOG ("non-assumption potentially satisfying literal %d", lit);
+          satisfiable = true;
+        }
+      }
+
+      if (!satisfied && !satisfiable) {
+        LOG (c, "due to assumptions unsatisfiable");
+        LOG ("stopping local search since assumptions falsify a clause");
+        failed = true;
+        break;
+      }
+
+      if (satisfied) {
+        watch_literal (lits[0], lits[1], c);
+#ifdef LOGGING
+        watched++;
+#endif
+      } else {
+        CADICAL_assert (satisfiable); // at least one non-assumed variable ...
+        LOG (c, "broken");
+        walker.broken.push_back (c);
+      }
+    }
+#ifdef LOGGING
+    if (!failed) {
+      int64_t broken = walker.broken.size ();
+      int64_t total = watched + broken;
+      LOG ("watching %" PRId64 " clauses %.0f%% "
+           "out of %" PRId64 " (watched and broken)",
+           watched, percent (watched, total), total);
+    }
+#endif
+  }
+
+  int64_t old_global_minimum = stats.walk.minimum;
+
+  int res; // Tells caller to continue with local search.
+
+  if (!failed) {
+
+    int64_t broken = walker.broken.size ();
+
+    PHASE ("walk", stats.walk.count,
+           "starting with %" PRId64 " unsatisfied clauses "
+           "(%.0f%% out of %" PRId64 ")",
+           broken, percent (broken, stats.current.irredundant),
+           stats.current.irredundant);
+
+    walk_save_minimum (walker);
+
+    int64_t minimum = broken;
+#ifndef CADICAL_QUIET
+    int64_t flips = 0;
+#endif
+    while (!terminated_asynchronously () && !walker.broken.empty () &&
+           walker.propagations < walker.limit) {
+#ifndef CADICAL_QUIET
+      flips++;
+#endif
+      stats.walk.flips++;
+      stats.walk.broken += broken;
+      Clause *c = walk_pick_clause (walker);
+      const int lit = walk_pick_lit (walker, c);
+      walk_flip_lit (walker, lit);
+      broken = walker.broken.size ();
+      LOG ("now have %" PRId64 " broken clauses in total", broken);
+      if (broken >= minimum)
+        continue;
+      minimum = broken;
+      VERBOSE (3, "new phase minimum %" PRId64 " after %" PRId64 " flips",
+               minimum, flips);
+      walk_save_minimum (walker);
+    }
+
+    if (minimum < old_global_minimum)
+      PHASE ("walk", stats.walk.count,
+             "%snew global minimum %" PRId64 "%s in %" PRId64 " flips and "
+             "%" PRId64 " propagations",
+             tout.bright_yellow_code (), minimum, tout.normal_code (),
+             flips, walker.propagations);
+    else
+      PHASE ("walk", stats.walk.count,
+             "best phase minimum %" PRId64 " in %" PRId64 " flips and "
+             "%" PRId64 " propagations",
+             minimum, flips, walker.propagations);
+
+    if (opts.profile >= 2) {
+      PHASE ("walk", stats.walk.count,
+             "%.2f million propagations per second",
+             relative (1e-6 * walker.propagations,
+                       time () - profiles.walk.started));
+
+      PHASE ("walk", stats.walk.count, "%.2f thousand flips per second",
+             relative (1e-3 * flips, time () - profiles.walk.started));
+
+    } else {
+      PHASE ("walk", stats.walk.count, "%.2f million propagations",
+             1e-6 * walker.propagations);
+
+      PHASE ("walk", stats.walk.count, "%.2f thousand flips", 1e-3 * flips);
+    }
+
+    if (minimum > 0) {
+      LOG ("minimum %" PRId64 " non-zero thus potentially continue",
+           minimum);
+      res = 0;
+    } else {
+      LOG ("minimum is zero thus stop local search");
+      res = 10;
+    }
+
+  } else {
+
+    res = 20;
+
+    PHASE ("walk", stats.walk.count,
+           "aborted due to inconsistent assumptions");
+  }
+
+  copy_phases (phases.prev);
+
+  for (auto idx : vars)
+    if (active (idx))
+      set_val (idx, 0);
+
+  CADICAL_assert (level == 2);
+  level = 0;
+
+  clear_watches ();
+  connect_watches ();
+
+#ifndef CADICAL_QUIET
+  if (localsearching) {
+    CADICAL_assert (force_phase_messages);
+    force_phase_messages = false;
+  }
+#endif
+
+  return res;
+}
+
+void Internal::walk () {
+  START_INNER_WALK ();
+  int64_t limit = stats.propagations.search;
+  limit *= 1e-3 * opts.walkeffort;
+  if (limit < opts.walkmineff)
+    limit = opts.walkmineff;
+  if (limit > opts.walkmaxeff)
+    limit = opts.walkmaxeff;
+  (void) walk_round (limit, false);
+  STOP_INNER_WALK ();
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/cadical_watch.cpp b/src/sat/cadical/cadical_watch.cpp
new file mode 100644
index 000000000..84c51ef2c
--- /dev/null
+++ b/src/sat/cadical/cadical_watch.cpp
@@ -0,0 +1,132 @@
+#include "global.h"
+
+#include "internal.hpp"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace CaDiCaL {
+
+void Internal::init_watches () {
+  CADICAL_assert (wtab.empty ());
+  if (wtab.size () < 2 * vsize)
+    wtab.resize (2 * vsize, Watches ());
+  LOG ("initialized watcher tables");
+}
+
+void Internal::clear_watches () {
+  for (auto lit : lits)
+    watches (lit).clear ();
+}
+
+void Internal::reset_watches () {
+  CADICAL_assert (!wtab.empty ());
+  erase_vector (wtab);
+  LOG ("reset watcher tables");
+}
+
+// This can be quite costly since lots of memory is accessed in a rather
+// random fashion, and thus we optionally profile it.
+
+void Internal::connect_watches (bool irredundant_only) {
+  START (connect);
+  CADICAL_assert (watching ());
+
+  LOG ("watching all %sclauses", irredundant_only ? "irredundant " : "");
+
+  // First connect binary clauses.
+  //
+  for (const auto &c : clauses) {
+    if (irredundant_only && c->redundant)
+      continue;
+    if (c->garbage || c->size > 2)
+      continue;
+    watch_clause (c);
+  }
+
+  // Then connect non-binary clauses.
+  //
+  for (const auto &c : clauses) {
+    if (irredundant_only && c->redundant)
+      continue;
+    if (c->garbage || c->size == 2)
+      continue;
+    watch_clause (c);
+    if (!level) {
+      const int lit0 = c->literals[0];
+      const int lit1 = c->literals[1];
+      const signed char tmp0 = val (lit0);
+      const signed char tmp1 = val (lit1);
+      if (tmp0 > 0)
+        continue;
+      if (tmp1 > 0)
+        continue;
+      if (tmp0 < 0) {
+        const size_t pos0 = var (lit0).trail;
+        if (pos0 < propagated) {
+          propagated = pos0;
+          LOG ("literal %d resets propagated to %zd", lit0, pos0);
+        }
+      }
+      if (tmp1 < 0) {
+        const size_t pos1 = var (lit1).trail;
+        if (pos1 < propagated) {
+          propagated = pos1;
+          LOG ("literal %d resets propagated to %zd", lit1, pos1);
+        }
+      }
+    }
+  }
+
+  STOP (connect);
+}
+
+// This can be quite costly since lots of memory is accessed in a rather
+// random fashion, and thus we optionally profile it.
+
+void Internal::connect_binary_watches () {
+  START (connect);
+  CADICAL_assert (watching ());
+
+  LOG ("watching binary clauses");
+
+  // First connect binary clauses.
+  //
+  for (const auto &c : clauses) {
+    if (c->garbage || c->size > 2)
+      continue;
+    watch_clause (c);
+  }
+
+  STOP (connect);
+}
+
+void Internal::sort_watches () {
+  CADICAL_assert (watching ());
+  LOG ("sorting watches");
+  Watches saved;
+  for (auto lit : lits) {
+    Watches &ws = watches (lit);
+
+    const const_watch_iterator end = ws.end ();
+    watch_iterator j = ws.begin ();
+    const_watch_iterator i;
+
+    CADICAL_assert (saved.empty ());
+
+    for (i = j; i != end; i++) {
+      const Watch w = *i;
+      if (w.binary ())
+        *j++ = w;
+      else
+        saved.push_back (w);
+    }
+
+    std::copy (saved.cbegin (), saved.cend (), j);
+
+    saved.clear ();
+  }
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/cadical/ccadical.h b/src/sat/cadical/ccadical.h
new file mode 100644
index 000000000..ec5292a79
--- /dev/null
+++ b/src/sat/cadical/ccadical.h
@@ -0,0 +1,74 @@
+#ifndef _ccadical_h_INCLUDED
+#define _ccadical_h_INCLUDED
+
+#include "global.h"
+
+/*------------------------------------------------------------------------*/
+ABC_NAMESPACE_HEADER_START
+/*------------------------------------------------------------------------*/
+
+#include <stdint.h>
+#include <stdio.h>
+
+// C wrapper for CaDiCaL's C++ API following IPASIR.
+
+typedef struct CCaDiCaL CCaDiCaL;
+
+const char *ccadical_signature (void);
+CCaDiCaL *ccadical_init (void);
+void ccadical_release (CCaDiCaL *);
+
+void ccadical_add (CCaDiCaL *, int lit);
+void ccadical_assume (CCaDiCaL *, int lit);
+int ccadical_solve (CCaDiCaL *);
+int ccadical_val (CCaDiCaL *, int lit);
+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.
+
+void ccadical_constrain (CCaDiCaL *, int lit);
+int ccadical_constraint_failed (CCaDiCaL *);
+void ccadical_set_option (CCaDiCaL *, const char *name, int val);
+void ccadical_limit (CCaDiCaL *, const char *name, int limit);
+int ccadical_get_option (CCaDiCaL *, const char *name);
+void ccadical_print_statistics (CCaDiCaL *);
+int64_t ccadical_active (CCaDiCaL *);
+int64_t ccadical_irredundant (CCaDiCaL *);
+int ccadical_fixed (CCaDiCaL *, int lit);
+int ccadical_trace_proof (CCaDiCaL *, FILE *, const char *);
+void ccadical_close_proof (CCaDiCaL *);
+void ccadical_conclude (CCaDiCaL *);
+void ccadical_terminate (CCaDiCaL *);
+void ccadical_freeze (CCaDiCaL *, int lit);
+int ccadical_frozen (CCaDiCaL *, int lit);
+void ccadical_melt (CCaDiCaL *, int lit);
+int ccadical_simplify (CCaDiCaL *);
+int ccadical_vars (CCaDiCaL *);
+int ccadical_reserve_difference (CCaDiCaL *, int number_of_vars);
+
+// Extra
+
+void ccadical_reserve(CCaDiCaL *, int min_max_var);
+int ccadical_is_inconsistent(CCaDiCaL *);
+
+/*------------------------------------------------------------------------*/
+
+// Support legacy names used before moving to more IPASIR conforming names.
+
+#define ccadical_reset ccadical_release
+#define ccadical_sat ccadical_solve
+#define ccadical_deref ccadical_val
+
+/*------------------------------------------------------------------------*/
+ABC_NAMESPACE_HEADER_END
+/*------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/sat/cadical/checker.hpp b/src/sat/cadical/checker.hpp
new file mode 100644
index 000000000..8c351e326
--- /dev/null
+++ b/src/sat/cadical/checker.hpp
@@ -0,0 +1,178 @@
+#ifndef _checker_hpp_INCLUDED
+#define _checker_hpp_INCLUDED
+
+#include "global.h"
+
+#include "tracer.hpp" // Alphabetically after 'checker'.
+
+#include <cstdint>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This checker implements an online forward DRUP proof checker enabled by
+// 'opts.checkproof' (requires 'opts.check' also to be enabled).  This is
+// useful for model basted testing (and delta-debugging), where we can not
+// rely on an external proof checker such as 'drat-trim'.  We also do not
+// have yet  a flow for offline incremental proof checking, while this
+// checker here can also be used in an incremental setting.
+//
+// In essence the checker implements is a simple propagation online SAT
+// solver with an additional hash table to find clauses fast for
+// 'delete_clause'.  It requires its own data structure for clauses
+// ('CheckerClause') and watches ('CheckerWatch').
+//
+// In our experiments the checker slows down overall SAT solving time by a
+// factor of 3, which we contribute to its slightly less efficient
+// implementation.
+
+/*------------------------------------------------------------------------*/
+
+struct CheckerClause {
+  CheckerClause *next; // collision chain link for hash table
+  uint64_t hash;       // previously computed full 64-bit hash
+  unsigned size;       // zero if this is a garbage clause
+  int literals[2];     // otherwise 'literals' of length 'size'
+};
+
+struct CheckerWatch {
+  int blit;
+  unsigned size;
+  CheckerClause *clause;
+  CheckerWatch () {}
+  CheckerWatch (int b, CheckerClause *c)
+      : blit (b), size (c->size), clause (c) {}
+};
+
+typedef vector<CheckerWatch> CheckerWatcher;
+
+/*------------------------------------------------------------------------*/
+
+class Checker : public StatTracer {
+
+  Internal *internal;
+
+  // Capacity of variable values.
+  //
+  int64_t size_vars;
+
+  // For the assignment we want to have an as fast access as possible and
+  // thus we use an array which can also be indexed by negative literals and
+  // is actually valid in the range [-size_vars+1, ..., size_vars-1].
+  //
+  signed char *vals;
+
+  // The 'watchers' and 'marks' data structures are not that time critical
+  // and thus we access them by first mapping a literal to 'unsigned'.
+  //
+  static unsigned l2u (int lit);
+  vector<CheckerWatcher> watchers; // watchers of literals
+  vector<signed char> marks;       // mark bits of literals
+
+  signed char &mark (int lit);
+  CheckerWatcher &watcher (int lit);
+
+  bool inconsistent; // found or added empty clause
+
+  uint64_t num_clauses;    // number of clauses in hash table
+  uint64_t num_garbage;    // number of garbage clauses
+  uint64_t size_clauses;   // size of clause hash table
+  CheckerClause **clauses; // hash table of clauses
+  CheckerClause *garbage;  // linked list of garbage clauses
+
+  vector<int> unsimplified; // original clause for reporting
+  vector<int> simplified;   // clause for sorting
+
+  vector<int> trail; // for propagation
+
+  unsigned next_to_propagate; // next to propagate on trail
+
+  void enlarge_vars (int64_t idx);
+  void import_literal (int lit);
+  void import_clause (const vector<int> &);
+  bool tautological ();
+
+  static const unsigned num_nonces = 4;
+
+  uint64_t nonces[num_nonces]; // random numbers for hashing
+  uint64_t last_hash;          // last computed hash value of clause
+  int64_t last_id;
+  uint64_t compute_hash (); // compute and save hash value of clause
+
+  // Reduce hash value to the actual size.
+  //
+  static uint64_t reduce_hash (uint64_t hash, uint64_t size);
+
+  void enlarge_clauses (); // enlarge hash table for clauses
+  void insert ();          // insert clause in hash table
+  CheckerClause **find (); // find clause position in hash table
+
+  void add_clause (const char *type);
+
+  void collect_garbage_clauses ();
+
+  CheckerClause *new_clause ();
+  void delete_clause (CheckerClause *);
+
+  signed char val (int lit); // returns '-1', '0' or '1'
+
+  bool clause_satisfied (CheckerClause *);
+
+  void assign (int lit);     // assign a literal to true
+  void assume (int lit);     // assume a literal
+  bool propagate ();         // propagate and check for conflicts
+  void backtrack (unsigned); // prepare for next clause
+  bool check ();             // check simplified clause is implied
+  bool check_blocked ();     // check if clause is blocked
+
+  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 deleted; // number of deleted clauses
+
+    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 checks; // number of implication checks
+
+    int64_t collections; // garbage collections
+    int64_t units;
+
+  } stats;
+
+public:
+  Checker (Internal *);
+  virtual ~Checker ();
+
+  void connect_internal (Internal *i) override;
+
+  void add_original_clause (int64_t, bool, const vector<int> &,
+                            bool = false) override;
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &) override;
+  void delete_clause (int64_t, bool, const vector<int> &) override;
+
+  void finalize_clause (int64_t, const vector<int> &) override {} // skip
+  void report_status (int, int64_t) override {}                   // skip
+  void begin_proof (int64_t) override {}                          // skip
+  void add_assumption_clause (int64_t, const vector<int> &,
+                              const vector<int64_t> &) override;
+  void print_stats () override;
+  void dump (); // for debugging purposes only
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/clause.hpp b/src/sat/cadical/clause.hpp
new file mode 100644
index 000000000..e5d0290f6
--- /dev/null
+++ b/src/sat/cadical/clause.hpp
@@ -0,0 +1,194 @@
+#ifndef _clause_hpp_INCLUDED
+#define _clause_hpp_INCLUDED
+
+#include "global.h"
+
+#include "util.hpp"
+#include <climits>
+#include <cstdint>
+#include <cstdlib>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+typedef int *literal_iterator;
+typedef const int *const_literal_iterator;
+
+/*------------------------------------------------------------------------*/
+
+// The 'Clause' data structure is very important. There are usually many
+// clauses and accessing them is a hot-spot.  Thus we use common
+// optimizations to reduce memory and improve cache usage, even though this
+// induces some complexity in understanding the code.
+//
+// The most important optimization is to 'embed' the actual literals in the
+// clause.  This requires a variadic size structure and thus strictly is not
+// 'C' conform, but supported by all compilers we used.  The alternative is
+// to store the actual literals somewhere else, which not only needs more
+// memory but more importantly also requires another memory access and thus
+// is very costly.
+
+struct Clause {
+  union {
+    int64_t id;   // Used to create LRAT-style proofs
+    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, so almost all of
+    // the time, 'id' is valid.  See 'collect.cpp' for details.
+  };
+  bool conditioned : 1; // Tried for globally blocked clause elimination.
+  bool covered : 1;  // Already considered for covered clause elimination.
+  bool enqueued : 1; // Enqueued on backward queue.
+  bool frozen : 1;   // Temporarily frozen (in covered clause elimination).
+  bool garbage : 1;  // can be garbage collected unless it is a 'reason'
+  bool gate : 1;     // Clause part of a gate (function definition).
+  bool hyper : 1;    // redundant hyper binary or ternary resolved
+  bool instantiated : 1; // tried to instantiate
+  bool moved : 1;        // moved during garbage collector ('copy' valid)
+  bool reason : 1;       // reason / antecedent clause can not be collected
+  bool redundant : 1;    // aka 'learned' so not 'irredundant' (original)
+  bool transred : 1;     // already checked for transitive reduction
+  bool subsume : 1;      // not checked in last subsumption round
+  bool swept : 1;        // clause used to sweep equivalences
+  bool flushed : 1;      // garbage in proof deleted binaries
+  unsigned used : 8; // resolved in conflict analysis since last 'reduce'
+  bool vivified : 1; // clause already vivified
+  bool vivify : 1;   // clause scheduled to be vivified
+
+  // The glucose level ('LBD' or short 'glue') is a heuristic value for the
+  // expected usefulness of a learned clause, where smaller glue is consider
+  // more useful.  During learning the 'glue' is determined as the number of
+  // decisions in the learned clause.  Thus the glue of a clause is a strict
+  // upper limit on the smallest number of decisions needed to make it
+  // propagate.  For instance a binary clause will propagate if one of its
+  // literals is set to false.  Similarly a learned clause with glue 1 can
+  // propagate after one decision, one with glue 2 after 2 decisions etc.
+  // In some sense the glue is an abstraction of the size of the clause.
+  //
+  // See the IJCAI'09 paper by Audemard & Simon for more details.  We
+  // switched back and forth between keeping the glue stored in a clause and
+  // using it only initially to determine whether it is kept, that is
+  // survives clause reduction.  The latter strategy is not bad but also
+  // does not allow to use glue values for instance in 'reduce'.
+  //
+  // More recently we also update the glue and promote clauses to lower
+  // level tiers during conflict analysis.  The idea of using three tiers is
+  // also due to Chanseok Oh and thus used in all recent 'Maple...' solvers.
+  // Tier one are the always kept clauses with low glue at most
+  // 'opts.reducetier1glue' (default '2'). The second tier contains all
+  // clauses with glue larger than 'opts.reducetier1glue' but smaller or
+  // equal than 'opts.reducetier2glue' (default '6').  The third tier
+  // consists of clauses with glue larger than 'opts.reducetier2glue'.
+  //
+  // Clauses in tier one are not deleted in 'reduce'. Clauses in tier
+  // two require to be unused in two consecutive 'reduce' intervals before
+  // being collected while for clauses in tier three not being used since
+  // the last 'reduce' call makes them deletion candidates.  Clauses derived
+  // by hyper binary or ternary resolution (even though small and thus with
+  // low glue) are always removed if they remain unused during one interval.
+  // See 'mark_useless_redundant_clauses_as_garbage' in 'reduce.cpp' and
+  // 'bump_clause' in 'analyze.cpp'.
+  //
+  int glue;
+
+  int size; // Actual size of 'literals' (at least 2).
+  int pos;  // Position of last watch replacement [Gent'13].
+
+  // This 'flexible array member' is of variadic 'size' (and actually
+  // shrunken if strengthened) and keeps the literals close to the header of
+  // the clause to avoid another pointer dereference, which would be costly.
+
+  // In earlier versions we used 'literals[2]' to fake it (in order to
+  // support older Microsoft compilers even though this feature is in C99)
+  // and at the same time being able to overlay the first two literals with
+  // the 'copy' field above, as having a flexible array member inside a
+  // union is not allowed.  Now compilers start to figure out that those
+  // literals can be accessed with indices larger than 1 and produce
+  // warnings.  After having the 'id' field mandatory we now overlay that
+  // one with the copy field.
+
+  // However, it turns out that even though flexible array members are in
+  // C99 they are not in C11++, and therefore pedantic compilation with
+  // '--pedantic' fails completely. Therefore we still support as
+  // alternative faked flexible array members, which unfortunately need
+  // then again more care when accessing the literals outside the faked
+  // virtual sizes and the compiler can somehow figure that out, because
+  // that would in turn produce a warning.
+
+#ifndef NFLEXIBLE
+  int literals[];
+#else
+  int literals[2];
+#endif
+
+  // Supports simple range based for loops over clauses.
+
+  literal_iterator begin () { return literals; }
+  literal_iterator end () { return literals + size; }
+
+  const_literal_iterator begin () const { return literals; }
+  const_literal_iterator end () const { return literals + size; }
+
+  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).
+    //
+    CADICAL_assert (size > 1);
+    const size_t header_bytes = sizeof (Clause);
+    const size_t actual_literal_bytes = size * sizeof (int);
+    size_t combined_bytes = header_bytes + actual_literal_bytes;
+#ifdef NFLEXIBLE
+    const size_t faked_literals_bytes = sizeof ((Clause *) 0)->literals;
+    combined_bytes -= faked_literals_bytes;
+#endif
+    size_t aligned_bytes = align (combined_bytes, 8);
+    return aligned_bytes;
+  }
+
+  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',
+  // which does not backtrack to the root level.  If garbage collection is
+  // triggered from a preprocessor, which backtracks to the root level, then
+  // 'reason' is false for sure. We want to use the same garbage collection
+  // code though for both situations and thus hide here this variance.
+  //
+  bool collect () const { return !reason && garbage; }
+};
+
+struct clause_smaller_size {
+  bool operator() (const Clause *a, const Clause *b) {
+    return a->size < b->size;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// Place literals over the same variable close to each other.  This would
+// allow eager removal of identical literals and detection of tautological
+// clauses but is only currently used for better logging (see also
+// 'opts.logsort' in 'logging.cpp').
+
+struct clause_lit_less_than {
+  bool operator() (int a, int b) const {
+    using namespace std;
+    int s = abs (a), t = abs (b);
+    return s < t || (s == t && a < b);
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/config.hpp b/src/sat/cadical/config.hpp
new file mode 100644
index 000000000..d49b05c84
--- /dev/null
+++ b/src/sat/cadical/config.hpp
@@ -0,0 +1,26 @@
+#ifndef _config_hpp_INCLUDED
+#define _config_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+class Options;
+
+struct Config {
+
+  static bool has (const char *);
+  static bool set (Options &, const char *);
+  static void usage ();
+
+  static const char **begin ();
+  static const char **end ();
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/congruence.hpp b/src/sat/cadical/congruence.hpp
new file mode 100644
index 000000000..e0acf9b00
--- /dev/null
+++ b/src/sat/cadical/congruence.hpp
@@ -0,0 +1,720 @@
+#ifndef _congruenc_hpp_INCLUDED
+#define _congruenc_hpp_INCLUDED
+
+#include "global.h"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <queue>
+#include <string>
+#include <sys/types.h>
+#include <unordered_set>
+#include <vector>
+
+#include "clause.hpp"
+#include "inttypes.hpp"
+#include "util.hpp"
+#include "watch.hpp"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+typedef int64_t LRAT_ID;
+
+// This implements the algorithm algorithm from SAT 2024.
+//
+// The idea is to:
+//   0. handle binary clauses
+//   1. detect gates and merge gates with same inputs ('lazy')
+//   2. eagerly replace the equivalent literals and merge gates with same
+//   inputs
+//   3. forward subsume
+//
+// In step 0 the normalization is fully lazy but we do not care about a
+// normal form. Therefore we actually eagerly merge literals.
+//
+// In step 2 there is a subtility: we only replace with the equivalence
+// chain as far as we propagated so far. This is the eager part. For LRAT we
+// produce the equivalence up to the point we have propagated, no the full
+// chain. This is important for merging literals.  To merge literals we use
+// union-find but we only compress paths when rewriting the literal, not
+// before. The compression was not considered important in Kissat, but we do
+// it aggressively as a mirror of the equivalences we have generated.
+//
+// We have two structures for merging:
+//   - the lazy ones contains alls merges, with functions like
+//   find_representative
+//
+//   - the eager version that gets the merges one by one, with functions
+//   like find_eager_representatives
+//
+//  The two structures are nicely separated and we only working on one of
+//  them except for:
+//
+//    1. When propagating one equivalence, we first important the
+//    equivalence from the lazy to the eager version, producing the full
+//    chain.
+//
+//    2. When merging the literals, we merge the literals given by the lazy
+//    structure, then we merge their representative in the eager version,
+//    updating only the lazy structure. We do not update the eager version.
+//
+// An important point: We cannot use internal->lrat_chain and
+// internal->clause because in most places we can interrupt the
+// transformation to learn a new clause representing an equivalence.
+// However, we can only have 2 layers so we use this->lrat_chain and
+// internal->lrat_chain when we really produce the proof.
+struct Internal;
+
+#define LD_MAX_ARITY 26
+#define MAX_ARITY ((1 << LD_MAX_ARITY) - 1)
+
+enum class Gate_Type { And_Gate, XOr_Gate, ITE_Gate };
+
+// Wrapper when we are looking for implication in if-then-else gates
+struct lit_implication {
+  int first;
+  int second;
+  Clause *clause;
+  lit_implication (int f, int s, Clause *_id)
+      : first (f), second (s), clause (_id) {}
+  lit_implication (int f, int s) : first (f), second (s), clause (0) {}
+  lit_implication () : first (0), second (0), clause (nullptr) {}
+  void swap () { std::swap (first, second); }
+};
+
+// Wrapper when we are looking for equivalence for if-then-else-gate. They
+// are produced by merging implication
+struct lit_equivalence {
+  int first;
+  int second;
+  Clause *first_clause;
+  Clause *second_clause;
+  void check_invariant () {
+    CADICAL_assert (second_clause);
+    CADICAL_assert (first_clause);
+    CADICAL_assert (std::find (begin (*first_clause), end (*first_clause), first) !=
+            end (*first_clause));
+    CADICAL_assert (std::find (begin (*second_clause), end (*second_clause),
+                       second) != end (*second_clause));
+    CADICAL_assert (std::find (begin (*first_clause), end (*first_clause),
+                       -second) != end (*first_clause));
+    CADICAL_assert (std::find (begin (*second_clause), end (*second_clause),
+                       -first) != end (*second_clause));
+  }
+  lit_equivalence (int f, Clause *f_id, int s, Clause *s_id)
+      : first (f), second (s), first_clause (f_id), second_clause (s_id) {}
+  lit_equivalence (int f, int s)
+      : first (f), second (s), first_clause (nullptr),
+        second_clause (nullptr) {}
+  lit_equivalence ()
+      : first (0), second (0), first_clause (nullptr),
+        second_clause (nullptr) {}
+  lit_equivalence swap () {
+    std::swap (first, second);
+    std::swap (first_clause, second_clause);
+    return *this;
+  }
+  lit_equivalence negate_both () {
+    first = -first;
+    second = -second;
+    std::swap (first_clause, second_clause);
+    return *this;
+  }
+};
+
+typedef std::vector<lit_implication> lit_implications;
+typedef std::vector<lit_equivalence> lit_equivalences;
+
+std::string string_of_gate (Gate_Type t);
+
+struct LitClausePair {
+  int current_lit; // current literal from the gate
+  Clause *clause;
+  LitClausePair (int lit, Clause *cl) : current_lit (lit), clause (cl) {}
+  LitClausePair () : current_lit (0), clause (nullptr) {}
+};
+struct LitIdPair {
+  int lit; // current literal from the gate
+  LRAT_ID id;
+  LitIdPair (int l, LRAT_ID i) : lit (l), id (i) {}
+  LitIdPair () : lit (0), id (0) {}
+};
+
+/*------------------------------------------------------------------------*/
+
+// Sorting the scheduled clauses is way faster if we compute and save the
+// clause size in the schedule to avoid pointer access to clauses during
+// sorting.  This slightly increases the schedule size though.
+
+struct ClauseSize {
+  size_t size;
+  Clause *clause;
+  ClauseSize (int s, Clause *c) : size (s), clause (c) {}
+  ClauseSize (Clause *c): size (c->size), clause (c) {}
+  ClauseSize () {}
+};
+
+struct smaller_clause_size_rank {
+  typedef size_t Type;
+  Type operator() (const ClauseSize &a) { return a.size; }
+};
+
+/*------------------------------------------------------------------------*/
+// There are many special cases for ITE gates and we have to keep track of
+// them as it is a gate property (rewriting might not make it obvious
+// anymore).
+// a = (a ? t : e) results in no -t and no +e gate (a --> a = t  == (-a v -a v t) & (-a v a v -t))
+// a = (-a ? t : e) results in no +t and no -e gate
+// a = (c ? a : e) results in no t gate (none of them)
+// a = (c ? t : a) results in no e gate (none of them)
+
+enum Special_ITE_GATE {
+  NORMAL = 0,
+  NO_PLUS_THEN = (1 << 0),
+  NO_NEG_THEN = (1 << 1),
+  NO_THEN = NO_PLUS_THEN + NO_NEG_THEN,
+  NO_PLUS_ELSE = (1 << 2),
+  NO_NEG_ELSE = (1 << 3),
+  NO_ELSE = NO_PLUS_ELSE + NO_NEG_ELSE,
+  COND_LHS = NO_NEG_THEN + NO_PLUS_ELSE,
+  UCOND_LHS = NO_PLUS_THEN + NO_NEG_ELSE,
+};
+
+inline bool ite_flags_no_then_clauses (int8_t flag) {
+  return (flag & NO_THEN) == NO_THEN;
+}
+
+inline bool ite_flags_no_else_clauses (int8_t flag) {
+  return (flag & NO_ELSE) == NO_ELSE;
+}
+
+inline bool ite_flags_neg_cond_lhs (int8_t flag) {
+  return (flag & UCOND_LHS) == UCOND_LHS;
+}
+
+inline bool ite_flags_cond_lhs (int8_t flag) {
+  return (flag & COND_LHS) == COND_LHS;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The core structure of this algorithm: the gate. It is composed of a
+// left-hand side and an array of right-hand side.
+//
+// There are a few tags to help remembering the status of the gate (like
+// deleted)
+//
+// To keep track of the proof we use two extra arrays:
+//  - `neg_lhs_ids' contains the long clause for AND gates. Otherwise, it is
+//  empty. TODO: change to std::option as it contains at most one element
+//  - `pos_lhs_ids' contains all the remaining gates.
+//
+// We keep the reasons with an index. This index depends on the gates:
+
+//   - AND-Gates and ITE-Gates: the index is the literal from the RHS
+//
+//   - XOR-Gates: if you order the clauses by the order of the literals,
+//   each literal is either positive (bit '1') or negative (bit '0'). This
+//   gives a number that we can use.
+//
+// TODO Florian: I do not think that you have to changed anything, look at
+// the 'Look at this first' in the CPP file.
+//
+// Important for the proofs: the LHS is not updated.
+//
+// TODO: we currently use a vector for the rhs, but we could also use FMA
+// and inline the structure to avoid any indirection.
+//
+// One warning for degenerated gate: it is a monotone property on the
+// defining clauses, but not on the LHS/RHS as the LHS is not rewritten:
+// take 4 = AND 3 4 (degenerated with only the clause -4 3) with a rewriting
+// 4 -> 1 (unchanged clause) and later 1 -> 3 (unchanged clause) but you do
+// not know anymore from the gate that it is degenerated
+struct Gate {
+#ifdef LOGGING
+  uint64_t id;
+#endif
+  int lhs;
+  Gate_Type tag;
+  bool garbage : 1;
+  bool indexed : 1;
+  bool marked : 1;
+  bool shrunken : 1;
+  size_t hash; // TODO remove this field (the C++ implementation is caching
+               // it anyway)
+  vector<LitClausePair> pos_lhs_ids;
+  vector<LitClausePair> neg_lhs_ids;
+  bool degenerated_and_neg = false; // LRAT only relevant for AND Gates, neg lhs in RHS
+  bool degenerated_and_pos = false; // LRAT only relevant for AND Gates, pos lhs in RHS
+  int8_t degenerated_ite = Special_ITE_GATE::NORMAL;
+  vector<int> rhs;
+
+  size_t arity () const { return rhs.size (); }
+
+  bool operator== (Gate const &lhs) {
+    return tag == lhs.tag && hash == lhs.hash && rhs == lhs.rhs;
+  }
+};
+
+typedef vector<Gate *> GOccs;
+
+struct GateEqualTo {
+  bool operator() (const Gate *const lhs, const Gate *const rhs) const {
+    return lhs->rhs == rhs->rhs && lhs->tag == rhs->tag;
+  }
+};
+
+struct CompactBinary {
+  Clause *clause;
+  LRAT_ID id;
+  int lit1, lit2;
+  CompactBinary (Clause *c, LRAT_ID i, int l1, int l2)
+      : clause (c), id (i), lit1 (l1), lit2 (l2) {}
+  CompactBinary () : clause (nullptr), id (0), lit1 (0), lit2 (0) {}
+};
+
+struct Hash {
+  Hash (std::array<int, 16> &ncs) : nonces (ncs) {}
+  std::array<int, 16> &nonces;
+  size_t operator() (const Gate *const g) const;
+};
+
+struct Rewrite {
+  int src, dst;
+  LRAT_ID id1;
+  LRAT_ID id2;
+
+  Rewrite (int _src, int _dst, LRAT_ID _id1, LRAT_ID _id2)
+      : src (_src), dst (_dst), id1 (_id1), id2 (_id2) {}
+  Rewrite () : src (0), dst (0), id1 (0), id2 (0) {}
+};
+
+struct Closure {
+
+  Closure (Internal *i);
+
+  Internal *const internal;
+  vector<Clause*> extra_clauses;
+  vector<CompactBinary> binaries;
+  std::vector<std::pair<size_t, size_t>> offsetsize;
+  bool full_watching = false;
+  std::array<int, 16> nonces;
+  typedef unordered_set<Gate *, Hash, GateEqualTo> GatesTable;
+
+  vector<bool> scheduled;
+  vector<signed char> marks;
+  vector<LitClausePair> mu1_ids, mu2_ids,
+      mu4_ids; // remember the ids and the literal. 2 and 4 are
+               // only used for lrat proofs, but we need 1 to
+               // promote binary clauses to irredundant
+
+  vector<int> lits;         // result of definitions
+  vector<int> rhs;          // stack for storing RHS
+  vector<int> unsimplified; // stack for storing unsimplified version (XOR,
+                            // ITEs) for DRAT proof
+  vector<int> chain;  // store clauses to be able to delete them properly
+  vector<int> clause; // storing partial clauses
+  vector<uint64_t>
+      glargecounts; // count for large clauses to complement internal->noccs
+  vector<uint64_t> gnew_largecounts; // count for large clauses to
+                                     // complement internal->noccs
+  GatesTable table;
+  std::array<lit_implications, 2> condbin;
+  std::array<lit_equivalences, 2> condeq;
+
+  std::vector<Clause *> new_unwatched_binary_clauses;
+  // LRAT proofs
+  vector<int> resolvent_analyzed;
+  mutable vector<LRAT_ID> lrat_chain; // storing LRAT chain
+
+#ifdef LOGGING
+  uint64_t fresh_id;
+#endif
+
+  uint64_t &new_largecounts (int lit);
+  uint64_t &largecounts (int lit);
+
+  void unmark_all ();
+  vector<int> representant;              // union-find
+  vector<int> eager_representant;        // union-find
+  vector<LRAT_ID> representant_id;       // lrat version of union-find
+  vector<LRAT_ID> eager_representant_id; // lrat version of union-find
+  int &representative (int lit);
+  int representative (int lit) const;
+  LRAT_ID &representative_id (int lit);
+  LRAT_ID representative_id (int lit) const;
+  int &eager_representative (int lit);
+  int eager_representative (int lit) const;
+  LRAT_ID &eager_representative_id (int lit);
+  LRAT_ID eager_representative_id (int lit) const;
+  std::vector<char> lazy_propagated_idx;
+  char &lazy_propagated (int lit);
+
+  int find_lrat_representative_with_marks (int lit);
+  // representative in the union-find structure in the lazy equivalences
+  int find_representative (int lit);
+  // find the representative and produce the binary clause representing the
+  // normalization from the literal to the result.
+  int find_representative_and_compress (int, bool update_eager = true);
+  // find the lazy representative for the `lit' and `-lit'
+  void find_representative_and_compress_both (int);
+  // find the eager representative
+  int find_eager_representative (int);
+
+  // compreses the path from lit to the representative with a new clause if
+  // needed. Save internal->lrat_chain to avoid any issue.
+  int find_eager_representative_and_compress (int);
+  // Import the path from the literal and its negation to the representative
+  // in the lazy graph to the eager part, producing the binary clauses.
+  void import_lazy_and_find_eager_representative_and_compress_both (
+      int); // generates clauses for -lit and lit
+
+  // returns the ID of the LRAT clause for the normalization from the
+  // literal lit to its argument, assuming that the representative was
+  // already compressed.
+  LRAT_ID find_representative_lrat (int lit);
+  // returns the ID of the LRAT clause for the eager normalization from the
+  // literal lit to its argument assuming that the representative was
+  // already compressed.
+  LRAT_ID find_eager_representative_lrat (int lit);
+
+  // Writes the LRAT chain required for the eager normalization to
+  // `lrat_chain`.
+  void produce_eager_representative_lrat (int lit);
+  // Writes the LRAT chain required for the lazy normalization to
+  // `lrat_chain`.
+  void produce_representative_lrat (int lit);
+
+  // learns a binary clause if not unit
+  Clause *maybe_add_binary_clause (int a, int b);
+  // add binary clause
+  Clause *add_binary_clause (int a, int b);
+  // add tmp clause
+  Clause *add_tmp_binary_clause (int a, int b);
+  // add clause taking core of tmp or full
+  Clause *learn_binary_tmp_or_full_clause (int a, int b);
+
+  // promotes a clause from redundant to irredundant. We do this for all
+  // clauses involved in gates to make sure that we produce correct result.
+  void promote_clause (Clause *);
+
+  // Merge functions. We actually need different several versions for LRAT
+  // in order to simplify the proof production.
+  //
+  // When merging binary clauses, we can simply produce the LRAT chain by
+  // (1) using the two binary clauses and (2) the reason clause from the
+  // literals to the representatives.
+  //
+  // The same approach does not work for merging gates because the
+  // representative might be also a representative of another literal
+  // (because of eager rewriting), requiring to resolve more than once on
+  // the same literal. An example of this are the two gates 4=-2&7 and
+  // 6=-2&1, the rewriting 7=1 and the equivalence 4=1. The simple road of
+  // merging 6 and 4 (requires resolving away 1) + adding the rewrite 4 to 1
+  // (requires adding 1) does not work.
+  //
+  // Therefore, we actually go for the more regular road and produce two
+  // equivalence: the merge from the LHS, followed by the actual equivalence
+  // (by combining it with the rewrite).  In DRAT this is less important
+  // because the checker finds a chain and is less restricted than our LRAT
+  // chain.
+  bool merge_literals_equivalence (int lit, int other, Clause *c1,
+                                   Clause *c2);
+  bool merge_literals_lrat (Gate *g, Gate *h, int lit, int other,
+                            const std::vector<LRAT_ID> & = {},
+                            const std::vector<LRAT_ID> & = {});
+  bool merge_literals_lrat (int lit, int other,
+                            const std::vector<LRAT_ID> & = {},
+                            const std::vector<LRAT_ID> & = {});
+
+  // proof production
+  vector<LitClausePair> lrat_chain_and_gate;
+  void push_lrat_id (const Clause *const c, int lit);
+  void push_lrat_unit (int lit);
+
+  // pushes the clause with the reasons to rewrite clause
+  // unless:
+  //   - the rewriting is not necessary (resolvent_marked == 1)
+  //   - it is overwritten by one of the arguments
+  void push_id_and_rewriting_lrat_unit (Clause *c, Rewrite rewrite1,
+                                        std::vector<LRAT_ID> &chain,
+                                        bool = true,
+                                        Rewrite rewrite2 = Rewrite (),
+                                        int execept_lhs = 0,
+                                        int except_lhs2 = 0);
+  void push_id_and_rewriting_lrat_full (Clause *c, Rewrite rewrite1,
+                                        std::vector<LRAT_ID> &chain,
+                                        bool = true,
+                                        Rewrite rewrite2 = Rewrite (),
+                                        int execept_lhs = 0,
+                                        int except_lhs2 = 0);
+  // TODO: does nothing except pushing on the stack, remove!
+  void push_id_on_chain (std::vector<LRAT_ID> &chain, Clause *c);
+  // TODO: does nothing except pushing on the stack, remove!
+  void push_id_on_chain (std::vector<LRAT_ID> &chain,
+                         const std::vector<LitClausePair> &c);
+  // TODO: does nothing except pushing on the stack, remove!
+  void push_id_on_chain (std::vector<LRAT_ID> &chain, Rewrite rewrite, int);
+  void update_and_gate_build_lrat_chain (
+      Gate *g, Gate *h, std::vector<LRAT_ID> &extra_reasons_lit,
+					 std::vector<LRAT_ID> &extra_reasons_ulit, bool remove_units = true);
+  void update_and_gate_unit_build_lrat_chain (
+      Gate *g, int src, LRAT_ID id1, LRAT_ID id2, int dst,
+      std::vector<LRAT_ID> &extra_reasons_lit,
+      std::vector<LRAT_ID> &extra_reasons_ulit);
+  // occs
+  vector<GOccs> gtab;
+  GOccs &goccs (int lit);
+  void connect_goccs (Gate *g, int lit);
+  vector<Gate *> garbage;
+  void mark_garbage (Gate *);
+  // remove the gate from the table
+  bool remove_gate (Gate *);
+  bool remove_gate (GatesTable::iterator git);
+  void index_gate (Gate *);
+
+  // second counter for size, complements noccs
+  uint64_t &largecount (int lit);
+
+  // simplification
+  bool skip_and_gate (Gate *g);
+  bool skip_xor_gate (Gate *g);
+  void update_and_gate (Gate *g, GatesTable::iterator, int src, int dst,
+                        LRAT_ID id1, LRAT_ID id2, int falsified = 0,
+                        int clashing = 0);
+  void update_xor_gate (Gate *g, GatesTable::iterator);
+  void shrink_and_gate (Gate *g, int falsified = 0, int clashing = 0);
+  bool simplify_gate (Gate *g);
+  void simplify_and_gate (Gate *g);
+  void simplify_ite_gate (Gate *g);
+  Clause *simplify_xor_clause (int lhs, Clause *);
+  void simplify_xor_gate (Gate *g);
+  bool simplify_gates (int lit);
+  void simplify_and_sort_xor_lrat_clauses (const vector<LitClausePair> &,
+                                           vector<LitClausePair> &, int,
+                                           int except2 = 0, bool flip = 0);
+  void simplify_unit_xor_lrat_clauses (const vector<LitClausePair> &, int);
+
+  // rewriting
+  bool rewriting_lhs (Gate *g, int dst);
+  bool rewrite_gates (int dst, int src, LRAT_ID id1, LRAT_ID id2);
+  bool rewrite_gate (Gate *g, int dst, int src, LRAT_ID id1, LRAT_ID id2);
+  void rewrite_xor_gate (Gate *g, int dst, int src);
+  void rewrite_and_gate (Gate *g, int dst, int src, LRAT_ID id1,
+                         LRAT_ID id2);
+  void rewrite_ite_gate (Gate *g, int dst, int src);
+
+  size_t units; // next trail position to propagate
+  bool propagate_unit (int lit);
+  bool propagate_units ();
+  size_t propagate_units_and_equivalences ();
+  bool propagate_equivalence (int lit);
+
+  // gates
+  void init_closure ();
+  void reset_closure ();
+  void reset_extraction ();
+  void reset_and_gate_extraction ();
+  void extract_and_gates (Closure &);
+  void extract_gates ();
+  void extract_and_gates_with_base_clause (Clause *c);
+  void init_and_gate_extraction ();
+  Gate *find_first_and_gate (Clause *base_clause, int lhs);
+  Gate *find_remaining_and_gate (Clause *base_clause, int lhs);
+  void extract_and_gates ();
+
+  Gate *find_and_lits (const vector<int> &rhs, Gate *except = nullptr);
+  // rhs is sorted, so passing by copy
+  Gate *find_gate_lits (const vector<int> &rhs, Gate_Type typ,
+                        Gate *except = nullptr);
+  Gate *find_xor_lits (const vector<int> &rhs);
+  // not const to normalize negations, also fixes the order of the LRAT
+  Gate *find_ite_gate (Gate *, bool &);
+  Gate *find_xor_gate (Gate *);
+
+  void reset_xor_gate_extraction ();
+  void init_xor_gate_extraction (std::vector<Clause*> &candidates);
+  LRAT_ID check_and_add_to_proof_chain (vector<int> &clause);
+  void add_xor_matching_proof_chain (Gate *g, int lhs1,
+                                     const vector<LitClausePair> &,
+                                     int lhs2, vector<LRAT_ID> &,
+                                     vector<LRAT_ID> &);
+  void add_xor_shrinking_proof_chain (Gate *g, int src);
+  void extract_xor_gates ();
+  void extract_xor_gates_with_base_clause (Clause *c);
+  Clause *find_large_xor_side_clause (std::vector<int> &lits);
+
+  void merge_condeq (int cond, lit_equivalences &condeq,
+                     lit_equivalences &not_condeq);
+  void find_conditional_equivalences (int lit, lit_implications &condbin,
+                                      lit_equivalences &condeq);
+  void copy_conditional_equivalences (int lit, lit_implications &condbin);
+  void check_ite_implied (int lhs, int cond, int then_lit, int else_lit);
+  void check_ite_gate_implied (Gate *g);
+  void check_and_gate_implied (Gate *g);
+  void check_ite_lrat_reasons (Gate *g, bool = false);
+  void check_contained_module_rewriting (Clause *c, int lit, bool,
+                                         int except);
+  void delete_proof_chain ();
+
+  // ite gate extraction
+  void extract_ite_gates_of_literal (int);
+  void extract_ite_gates_of_variable (int idx);
+  void extract_condeq_pairs (int lit, lit_implications &condbin,
+                             lit_equivalences &condeq);
+  void init_ite_gate_extraction (std::vector<ClauseSize> &candidates);
+  lit_implications::const_iterator find_lit_implication_second_literal (
+      int lit, lit_implications::const_iterator begin,
+      lit_implications::const_iterator end);
+  void search_condeq (int lit, int pos_lit,
+                      lit_implications::const_iterator pos_begin,
+                      lit_implications::const_iterator pos_end, int neg_lit,
+                      lit_implications::const_iterator neg_begin,
+                      lit_implications::const_iterator neg_end,
+                      lit_equivalences &condeq);
+  void reset_ite_gate_extraction ();
+  void extract_ite_gates ();
+
+  void forward_subsume_matching_clauses ();
+
+  void extract_congruence ();
+
+  void add_ite_matching_proof_chain (Gate *g, Gate *h, int lhs1, int lhs2,
+                                     std::vector<LRAT_ID> &reasons1,
+                                     std::vector<LRAT_ID> &reasons2);
+  void add_ite_turned_and_binary_clauses (Gate *g);
+  Gate *new_and_gate (Clause *, int);
+  Gate *new_ite_gate (int lhs, int cond, int then_lit, int else_lit,
+                      std::vector<LitClausePair> &&clauses);
+  Gate *new_xor_gate (const vector<LitClausePair> &, int);
+  // check
+  void check_xor_gate_implied (Gate const *const);
+  void check_ternary (int a, int b, int c);
+  void check_binary_implied (int a, int b);
+  void check_implied ();
+
+  // learn units. You can delay units if you want to learn several at once before
+  // propagation. Otherwise, propagate! If you need propagation even if nothing is set, use the
+  // second parameter.
+  //
+  // The function can also learn the empty clause if the unit is already set. Do not add the unit in
+  // the chain!
+  bool learn_congruence_unit (int unit, bool = false, bool = false);
+  bool fully_propagate ();  
+  void learn_congruence_unit_falsifies_lrat_chain (Gate *g, int src,
+                                                   int dst, 
+                                                   int clashing,
+                                                   int falsified, int unit);
+  void learn_congruence_unit_when_lhs_set (Gate *g, int src, LRAT_ID id1,
+                                           LRAT_ID id2, int dst);
+
+  void find_units ();
+  void find_equivalences ();
+  void subsume_clause (Clause *subsuming, Clause *subsumed);
+  bool find_subsuming_clause (Clause *c);
+  void produce_rewritten_clause_lrat_and_clean (vector<LitClausePair> &,
+                                                int execept_lhs = 0,
+                                                bool = true);
+  // rewrite the clause using eager rewriting and rew1 and rew2, except for
+  // 2 literals Usage:
+  //   - the except are used to ignore LHS of gates that have not and should
+  //   not be rewritten.
+  //   - TODO: except_lhs2 should never be used actually
+  //   - the Rewrite are for additional rewrite to allow for lazy rewrites
+  //   to be taken into account without being added to the eager rewriting
+  //   (yet)
+  Clause *produce_rewritten_clause_lrat (Clause *c, int execept_lhs = 0,
+                                         bool remove_units = true, bool = true);
+  void produce_rewritten_clause_lrat (vector<LitClausePair> &,
+                                                int execept_lhs = 0,
+                                                bool = true);
+  void compute_rewritten_clause_lrat_simple (Clause *c, int except);
+  // variant where we update the indices after removing the tautologies and
+  // remove the tautological clauses
+  void produce_rewritten_clause_lrat_and_clean (
+      std::vector<LitClausePair> &litIds, int except_lhs,
+      size_t &old_position1, size_t &old_position2,
+      bool remove_units = true);
+  // binary extraction and ternary strengthening
+  void extract_binaries ();
+  bool find_binary (int, int) const;
+
+  Clause *new_tmp_clause (std::vector<int> &clause);
+  Clause *maybe_promote_tmp_binary_clause (Clause *);
+  void check_not_tmp_binary_clause (Clause *c);
+  Clause *new_clause ();
+  //
+  void sort_literals_by_var (vector<int> &rhs);
+  void sort_literals_by_var_except (vector<int> &rhs, int, int except2 = 0);
+
+  // schedule
+  queue<int> schedule;
+  void schedule_literal (int lit);
+  void add_clause_to_chain (std::vector<int>, LRAT_ID);
+  // proof. If delete_id is non-zero, then delete the clause instead of
+  // learning it
+  LRAT_ID simplify_and_add_to_proof_chain (vector<int> &unsimplified,
+                                           LRAT_ID delete_id = 0);
+
+  // we define our own wrapper as cadical has otherwise a non-compatible
+  // marking system
+  signed char &marked (int lit);
+  void set_mu1_reason (int lit, Clause *c);
+  void set_mu2_reason (int lit, Clause *c);
+  void set_mu4_reason (int lit, Clause *c);
+  LitClausePair marked_mu1 (int lit);
+  LitClausePair marked_mu2 (int lit);
+  LitClausePair marked_mu4 (int lit);
+
+  // XOR
+  uint32_t number_from_xor_reason_reversed (const std::vector<int> &rhs);
+  uint32_t number_from_xor_reason (const std::vector<int> &rhs, int,
+                                   int except2 = 0, bool flip = 0);
+  void gate_sort_lrat_reasons (std::vector<LitClausePair> &, int,
+                               int except2 = 0, bool flip = 0);
+  void gate_sort_lrat_reasons (LitClausePair &, int, int except2 = 0,
+                               bool flip = 0);
+
+  bool rewrite_ite_gate_to_and (Gate *g, int dst, int src, size_t c,
+                                size_t d, int cond_lit_to_learn_if_degenerated);
+  void produce_ite_merge_then_else_reasons (
+      Gate *g, int dst, int src, std::vector<LRAT_ID> &reasons_implication,
+      std::vector<LRAT_ID> &reasons_back);
+  void produce_ite_merge_lhs_then_else_reasons (
+      Gate *g, std::vector<LRAT_ID> &reasons_implication,
+      std::vector<LRAT_ID> &reasons_back,
+      std::vector<LRAT_ID> &reasons_unit, bool, bool &);
+  void rewrite_ite_gate_update_lrat_reasons (Gate *g, int src, int dst);
+  void simplify_ite_gate_produce_unit_lrat (Gate *g, int lit, size_t idx1,
+                                            size_t idx2);
+  void merge_and_gate_lrat_produce_lrat (
+      Gate *g, Gate *h, std::vector<LRAT_ID> &reasons_lrat,
+      std::vector<LRAT_ID> &reasons_lrat_back, bool remove_units = true);
+  // first index is a binary clause after unit propagation and the second
+  // has length 3
+  bool simplify_ite_gate_to_and (Gate *g, size_t idx1, size_t idx2,
+                                 int removed);
+  void
+  merge_ite_gate_same_then_else_lrat (std::vector<LitClausePair> &clauses,
+                               std::vector<LRAT_ID> &reasons_implication,
+                               std::vector<LRAT_ID> &reasons_back);
+  void simplify_ite_gate_then_else_set (
+      Gate *g, std::vector<LRAT_ID> &reasons_implication,
+      std::vector<LRAT_ID> &reasons_back, size_t idx1, size_t idx2);
+
+  void simplify_ite_gate_condition_set (
+      Gate *g, std::vector<LRAT_ID> &reasons_lrat,
+      std::vector<LRAT_ID> &reasons_back_lrat, size_t idx1, size_t idx2);
+  bool normalize_ite_lits_gate (Gate *rhs);
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/contract.hpp b/src/sat/cadical/contract.hpp
new file mode 100644
index 000000000..4a3ba066a
--- /dev/null
+++ b/src/sat/cadical/contract.hpp
@@ -0,0 +1,142 @@
+#ifndef _contract_hpp_INCLUDED
+#define _contract_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+/*------------------------------------------------------------------------*/
+#ifndef CADICAL_NCONTRACTS
+/*------------------------------------------------------------------------*/
+
+// If the user violates API contracts while calling functions declared in
+// 'cadical.hpp' and implemented in 'solver.cpp' then an error is reported.
+// Currently we also force aborting the program.  In the future it might be
+// better to allow the user to provide a call back function, which then can
+// for instance throw a C++ exception or execute a 'longjmp' in 'C' etc.
+
+#define CONTRACT_VIOLATED(...) \
+  do { \
+    fatal_message_start (); \
+    fprintf (stderr, \
+             "invalid API usage of '%s' in '%s': ", __PRETTY_FUNCTION__, \
+             __FILE__); \
+    fprintf (stderr, __VA_ARGS__); \
+    fputc ('\n', stderr); \
+    fflush (stderr); \
+    abort (); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+
+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)
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// These are common shortcuts for 'Solver' API contracts (requirements).
+
+#define REQUIRE(COND, ...) \
+  do { \
+    if ((COND)) \
+      break; \
+    CONTRACT_VIOLATED (__VA_ARGS__); \
+  } while (0)
+
+#define REQUIRE_INITIALIZED() \
+  do { \
+    REQUIRE_NON_ZERO_THIS (); \
+    REQUIRE (external, "external solver not initialized"); \
+    REQUIRE (internal, "internal solver not initialized"); \
+  } while (0)
+
+#define REQUIRE_VALID_STATE() \
+  do { \
+    REQUIRE_INITIALIZED (); \
+    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 (); \
+    REQUIRE (this->state () & (VALID | SOLVING), \
+             "solver neither in valid nor solving state"); \
+  } while (0)
+
+#define REQUIRE_VALID_LIT(LIT) \
+  do { \
+    REQUIRE ((int) (LIT) && ((int) (LIT)) != INT_MIN, \
+             "invalid literal '%d'", (int) (LIT)); \
+    REQUIRE (external->is_valid_input ((int) (LIT)), \
+             "extension variable %d defined by the solver", (int) (LIT)); \
+  } while (0)
+
+#define REQUIRE_STEADY_STATE() \
+  do { \
+    REQUIRE_INITIALIZED (); \
+    REQUIRE (this->state () & STEADY, "solver is not in steady state"); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+#else // CADICAL_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)
+#define REQUIRE_STEADY_STATE() \
+  do { \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif
+/*------------------------------------------------------------------------*/
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/cover.hpp b/src/sat/cadical/cover.hpp
new file mode 100644
index 000000000..47e6f1b82
--- /dev/null
+++ b/src/sat/cadical/cover.hpp
@@ -0,0 +1,36 @@
+#ifndef _cover_hpp_INCLUDED
+#define _cover_hpp_INCLUDED
+
+#include "global.h"
+
+/*------------------------------------------------------------------------*/
+
+// This header only provides the 'COVER' macro for testing.  It is unrelated
+// to 'cover.cpp' which implements covered clause elimination (CCE), but we
+// wanted to use the name base name in both cases.  More explanation on CCE
+// is provided in 'cover.cpp'.
+
+/*------------------------------------------------------------------------*/
+
+// Coverage goal, used similar to 'CADICAL_assert' (but with flipped condition) and
+// also included even if 'CADICAL_NDEBUG' is defined (in optimizing compilation).
+//
+// This should in essence not be used in production code.
+//
+// There seems to be no problem overloading the name 'COVER' of this macro
+// with the constant 'COVER' of 'Internal::Mode' (surprisingly).
+
+#define COVER(COND) \
+  do { \
+    if (!(COND)) \
+      break; \
+    fprintf (stderr, \
+             "%scadical%s: %s:%d: %s: Coverage goal %s`%s'%s reached.\n", \
+             terr.bold_code (), terr.normal_code (), __FUNCTION__, \
+             __LINE__, __FILE__, terr.green_code (), #COND, \
+             terr.normal_code ()); \
+    fflush (stderr); \
+    abort (); \
+  } while (0)
+
+#endif
diff --git a/src/sat/cadical/decompose.hpp b/src/sat/cadical/decompose.hpp
new file mode 100644
index 000000000..9c93e8448
--- /dev/null
+++ b/src/sat/cadical/decompose.hpp
@@ -0,0 +1,29 @@
+#ifndef _decompose_hpp_INCLUDED
+#define _decompose_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// This implements Tarjan's algorithm for decomposing the binary implication
+// graph intro strongly connected components (SCCs).  Literals in one SCC
+// are equivalent and we replace them all by the literal with the smallest
+// index in the SCC.  These variables are marked 'substituted' and will be
+// removed from all clauses.  Their value will be fixed during 'extend'.
+
+#define TRAVERSED UINT_MAX // mark completely traversed
+
+struct DFS {
+  unsigned idx;   // depth first search index
+  unsigned min;   // minimum reachable index
+  Clause *parent; // for lrat
+  DFS () : idx (0), min (0), parent (0) {}
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/delay.hpp b/src/sat/cadical/delay.hpp
new file mode 100644
index 000000000..9ee9a9234
--- /dev/null
+++ b/src/sat/cadical/delay.hpp
@@ -0,0 +1,44 @@
+#ifndef _delay_hpp_INCLUDED
+#define _delay_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdint>
+#include <limits>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+struct Delay {
+  unsigned count;
+  unsigned current;
+
+  Delay () : count (0), current (0) {}
+
+  bool delay () {
+    if (count) {
+      --count;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  void bump_delay () {
+    current += current < std::numeric_limits<unsigned>::max ();
+    count = current;
+  }
+
+  void reduce_delay () {
+    if (!current)
+      return;
+    current /= 2;
+    count = current;
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/drattracer.hpp b/src/sat/cadical/drattracer.hpp
new file mode 100644
index 000000000..8c2c023d5
--- /dev/null
+++ b/src/sat/cadical/drattracer.hpp
@@ -0,0 +1,59 @@
+#ifndef _drattracer_h_INCLUDED
+#define _drattracer_h_INCLUDED
+
+#include "global.h"
+
+#include "tracer.hpp"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+class DratTracer : public FileTracer {
+
+  Internal *internal;
+  File *file;
+  bool binary;
+#ifndef CADICAL_QUIET
+  int64_t added, deleted;
+#endif
+  void put_binary_zero ();
+  void put_binary_lit (int external_lit);
+
+  // support DRAT
+  void drat_add_clause (const vector<int> &);
+  void drat_delete_clause (const vector<int> &);
+
+public:
+  // own and delete 'file'
+  DratTracer (Internal *, File *file, bool binary);
+  ~DratTracer ();
+
+  void connect_internal (Internal *i) override;
+  void begin_proof (int64_t) override {} // skip
+
+  void add_original_clause (int64_t, bool, const vector<int> &,
+                            bool = false) override {} // skip
+
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &) override;
+
+  void delete_clause (int64_t, bool, const vector<int> &) override;
+
+  void finalize_clause (int64_t, const vector<int> &) override {} // skip
+
+  void report_status (int, int64_t) override {} // skip
+
+#ifndef CADICAL_QUIET
+  void print_statistics ();
+#endif
+  bool closed () override;
+  void close (bool) override;
+  void flush (bool) override;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/elim.hpp b/src/sat/cadical/elim.hpp
new file mode 100644
index 000000000..73e1bf547
--- /dev/null
+++ b/src/sat/cadical/elim.hpp
@@ -0,0 +1,59 @@
+#ifndef _elim_hpp_INCLUDED
+#define _elim_hpp_INCLUDED
+
+#include "global.h"
+
+#include "heap.hpp" // Alphabetically after 'elim.hpp'.
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct elim_more {
+  Internal *internal;
+  elim_more (Internal *i) : internal (i) {}
+  bool operator() (unsigned a, unsigned b);
+};
+
+typedef heap<elim_more> ElimSchedule;
+
+struct proof_clause {
+  int64_t id;
+  vector<int> literals;
+  // for lrat
+  unsigned cid; // cadical_kitten id
+  bool learned;
+  vector<int64_t> chain;
+};
+
+enum GateType { NO = 0, EQUI = 1, AND = 2, ITE = 3, XOR = 4, DEF = 5 };
+
+struct Eliminator {
+
+  Internal *internal;
+  ElimSchedule schedule;
+
+  Eliminator (Internal *i)
+      : internal (i), schedule (elim_more (i)), definition_unit (0),
+        gatetype (NO) {}
+  ~Eliminator ();
+
+  queue<Clause *> backward;
+
+  Clause *dequeue ();
+  void enqueue (Clause *);
+
+  vector<Clause *> gates;
+  unsigned definition_unit;
+  vector<proof_clause> proof_clauses;
+  vector<int> marked;
+  GateType gatetype;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/ema.hpp b/src/sat/cadical/ema.hpp
new file mode 100644
index 000000000..51eb5f8c1
--- /dev/null
+++ b/src/sat/cadical/ema.hpp
@@ -0,0 +1,74 @@
+#ifndef _ema_hpp_INCLUDED
+#define _ema_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdint>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Internal;
+
+// This is a more complex generic exponential moving average class to
+// support more robust initialization (see comments in the 'update'
+// implementation).
+
+struct EMA {
+
+#ifdef LOGGING
+  uint64_t updated;
+#endif
+  double value;  // unbiased (corrected) moving average
+  double biased; // biased initialized moving average
+  double alpha;  // input scaling with 'alpha = 1 - beta'
+  double beta;   // decay of 'biased' with 'beta = 1 - alpha'
+  double exp;    // 'exp = pow (beta, updated)'
+
+  EMA ()
+      :
+#ifdef LOGGING
+        updated (0),
+#endif
+        value (0), biased (0), alpha (0), beta (0), exp (0) {
+  }
+
+  EMA (double a)
+      :
+#ifdef LOGGING
+        updated (0),
+#endif
+        value (0), biased (0), alpha (a), beta (1 - a), exp (!!beta) {
+    CADICAL_assert (beta >= 0);
+  }
+
+  operator double () const { return value; }
+  void update (Internal *, double y, const char *name);
+};
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// Compact average update and initialization macros for better logging.
+
+#define UPDATE_AVERAGE(A, Y) \
+  do { \
+    A.update (internal, (Y), #A); \
+  } while (0)
+
+#define INIT_EMA(E, WINDOW) \
+  do { \
+    CADICAL_assert ((WINDOW) >= 1); \
+    double ALPHA = 1.0 / (double) (WINDOW); \
+    E = EMA (ALPHA); \
+    LOG ("init " #E " EMA target alpha %g window %d", ALPHA, \
+         (int) WINDOW); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/external.hpp b/src/sat/cadical/external.hpp
new file mode 100644
index 000000000..7618fb936
--- /dev/null
+++ b/src/sat/cadical/external.hpp
@@ -0,0 +1,467 @@
+#ifndef _external_hpp_INCLUDED
+#define _external_hpp_INCLUDED
+
+#include "global.h"
+
+/*------------------------------------------------------------------------*/
+
+#include "range.hpp"
+#include <unordered_map>
+#include <vector>
+
+/*------------------------------------------------------------------------*/
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+using namespace std;
+
+/*------------------------------------------------------------------------*/
+
+// The CaDiCaL code is split into three layers:
+//
+//   Solver:       facade object providing the actual API of the solver
+//   External:     communication layer between 'Solver' and 'Internal'
+//   Internal:     the actual solver code
+//
+// Note, that 'Solver' is defined in 'cadical.hpp' and 'solver.cpp', while
+// 'External' and 'Internal' in '{external,internal}.{hpp,cpp}'.
+//
+// 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).
+// This is helpful for shrinking the working size of the internal solver
+// after many variables become inactive.  It will also help to provide
+// support for extended resolution in the future, since it allows to
+// introduce only internally visible variables (even though we do not know
+// how to support generating incremental proofs in this situation yet).
+//
+// External literals are usually called 'elit' and internal 'ilit'.
+
+/*------------------------------------------------------------------------*/
+
+struct Clause;
+struct Internal;
+struct CubesWithStatus;
+
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+
+struct External {
+
+  /*==== start of state ==================================================*/
+
+  Internal *internal; // The actual internal solver.
+
+  int max_var;  // External maximum variable index.
+  size_t vsize; // Allocated external size.
+
+  vector<bool> vals; // Current external (extended) assignment.
+  vector<int> e2i;   // External 'idx' to internal 'lit'.
+
+  vector<int> assumptions; // External assumptions.
+  vector<int> constraint;  // External constraint. Terminated by zero.
+
+  vector<int64_t>
+      ext_units; // External units. Needed to compute LRAT for eclause
+  vector<bool> ext_flags; // to avoid duplicate units
+  vector<int> eclause;    // External version of original input clause.
+  // 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.
+  bool concluded;
+  vector<int> extension; // Solution reconstruction extension stack.
+
+  vector<bool> witness; // Literal witness on extension stack.
+  vector<bool> tainted; // Literal tainted in adding literals.
+
+  vector<bool> ervars; // Variables added through Extended Resolution.
+
+  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> &);
+
+  // If there is a listener for fixed assignments.
+
+  FixedAssignmentListener *fixed_listener;
+
+  // If there is an external propagator.
+
+  ExternalPropagator *propagator;
+
+  vector<bool> is_observed; // Quick flag for each external variable
+
+  // Saved 'forgettable' original clauses coming from the external
+  // propagator. The value of the map starts with a Boolean flag indicating
+  // if the clause is still present or got already deleted, and then
+  // followed by the literals of the clause.
+  unordered_map<uint64_t, vector<int>> forgettable_original;
+
+  void add_observed_var (int elit);
+  void remove_observed_var (int elit);
+  void reset_observed_vars ();
+
+  bool observed (int elit);
+  bool is_witness (int elit);
+  bool is_decision (int elit);
+
+  void force_backtrack (size_t new_level);
+
+  //----------------------------------------------------------------------//
+
+  signed char *solution; // Given solution checking for debugging.
+  int solution_size;     // 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 (CADICAL_assertion) checking code.
+
+  inline int vidx (int elit) const {
+    CADICAL_assert (elit);
+    CADICAL_assert (elit != INT_MIN);
+    int res = abs (elit);
+    CADICAL_assert (res <= max_var);
+    return res;
+  }
+
+  inline int vlit (int elit) const {
+    CADICAL_assert (elit);
+    CADICAL_assert (elit != INT_MIN);
+    CADICAL_assert (abs (elit) <= max_var);
+    return elit;
+  }
+
+  inline bool is_valid_input (int elit) {
+    CADICAL_assert (elit);
+    CADICAL_assert (elit != INT_MIN);
+    int eidx = abs (elit);
+    return eidx > max_var || !ervars[eidx];
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  // 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.
+
+  void push_zero_on_extension_stack ();
+
+  // Our general version of extension stacks always pushes a set of witness
+  // literals (for variable elimination the literal of the eliminated
+  // literal and for blocked clauses the blocking literal) followed by all
+  // the clause literals starting with and separated by zero.
+  //
+  void push_clause_literal_on_extension_stack (int ilit);
+  void push_witness_literal_on_extension_stack (int ilit);
+
+  void push_clause_on_extension_stack (Clause *);
+  void push_clause_on_extension_stack (Clause *, int witness);
+  void push_binary_clause_on_extension_stack (int64_t id, int witness,
+                                              int other);
+
+  // The main 'extend' function which extends an internal assignment to an
+  // external assignment using the extension stack (and sets 'extended').
+  //
+  void extend ();
+  void conclude_sat ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Marking external literals.
+
+  unsigned elit2ulit (int elit) const {
+    CADICAL_assert (elit);
+    CADICAL_assert (elit != INT_MIN);
+    const int idx = abs (elit) - 1;
+    CADICAL_assert (idx <= max_var);
+    return 2u * idx + (elit < 0);
+  }
+
+  bool marked (const vector<bool> &map, int elit) const {
+    const unsigned ulit = elit2ulit (elit);
+    return ulit < map.size () ? map[ulit] : false;
+  }
+
+  void mark (vector<bool> &map, int elit) {
+    const unsigned ulit = elit2ulit (elit);
+    if (ulit >= map.size ())
+      map.resize (ulit + 1, false);
+    map[ulit] = true;
+  }
+
+  void unmark (vector<bool> &map, int elit) {
+    const unsigned ulit = elit2ulit (elit);
+    if (ulit < map.size ())
+      map[ulit] = false;
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  void push_external_clause_and_witness_on_extension_stack (
+      const vector<int> &clause, const vector<int> &witness, int64_t id);
+
+  void push_id_on_extension_stack (int64_t id);
+
+  // 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,
+                       const int64_t id);
+
+  void restore_clauses ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Explicitly freeze and melt literals (instead of just freezing
+  // internally and implicitly assumed literals).  Passes on freezing and
+  // melting to the internal solver, which has separate frozen counters.
+
+  void freeze (int elit);
+  void melt (int elit);
+
+  bool frozen (int elit) {
+    CADICAL_assert (elit);
+    CADICAL_assert (elit != INT_MIN);
+    int eidx = abs (elit);
+    if (eidx > max_var)
+      return false;
+    if (eidx >= (int) frozentab.size ())
+      return false;
+    return frozentab[eidx] > 0;
+  }
+
+  /*----------------------------------------------------------------------*/
+
+  External (Internal *);
+  ~External ();
+
+  void enlarge (int new_max_var); // Enlarge allocated 'vsize'.
+  void init (int new_max_var,
+             bool extension = false); // Initialize up-to 'new_max_var'.
+
+  int internalize (
+      int,
+      bool extension = false); // Translate external to internal literal.
+
+  /*----------------------------------------------------------------------*/
+
+  // According to the CaDiCaL API contract (as well as IPASIR) we have to
+  // forget about the previous assumptions after a 'solve' call.  This
+  // should however be delayed until we transition out of an 'UNSATISFIED'
+  // state, i.e., after no more 'failed' calls are expected.  Note that
+  // 'failed' requires to know the failing assumptions, and the 'failed'
+  // status of those should cleared before at start of the next 'solve'.
+  // As a consequence 'reset_assumptions' is only called from
+  // 'transition_to_unknown_state' in API calls in 'solver.cpp'.
+
+  void reset_assumptions ();
+
+  // Similarly to 'failed', 'conclude' needs to know about failing
+  // assumptions and therefore needs to be reset when leaving the
+  // 'UNSATISFIED' state.
+  //
+  void reset_concluded ();
+
+  // Similarly a valid external assignment obtained through 'extend' has to
+  // be reset at each point it risks to become invalid.  This is done
+  // in the external layer in 'external.cpp' functions..
+
+  void reset_extended ();
+
+  // Finally, the semantics of incremental solving also require that limits
+  // are only valid for the next 'solve' call.  Since the limits can not
+  // really be queried, handling them is less complex and they are just
+  // reset immediately at the end of 'External::solve'.
+
+  void reset_limits ();
+
+  /*----------------------------------------------------------------------*/
+
+  // Proxies to IPASIR functions.
+
+  void add (int elit);
+  void assume (int elit);
+  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 {
+    CADICAL_assert (elit != INT_MIN);
+    int eidx = abs (elit);
+    bool val = false;
+    if (eidx <= max_var && (size_t) eidx < vals.size ())
+      val = vals[eidx];
+    if (elit < 0)
+      val = !val;
+    return val ? elit : -elit;
+  }
+
+  bool flip (int elit);
+  bool flippable (int elit);
+
+  bool failed (int elit);
+
+  void terminate ();
+
+  // Other important non IPASIR functions.
+
+  /*----------------------------------------------------------------------*/
+
+  // Add literal to external constraint.
+  //
+  void constrain (int elit);
+
+  // Returns true if 'solve' returned 20 because of the constraint.
+  //
+  bool failed_constraint ();
+
+  // Deletes the current constraint clause. Called on
+  // 'transition_to_unknown_state' and if a new constraint is added. Can be
+  // called directly using the API.
+  //
+  void reset_constraint ();
+
+  /*----------------------------------------------------------------------*/
+
+  int propagate_assumptions ();
+  void implied (std::vector<int> &entrailed);
+  void conclude_unknown ();
+
+  /*----------------------------------------------------------------------*/
+  int lookahead ();
+  CaDiCaL::CubesWithStatus generate_cubes (int, int);
+
+  int fixed (int elit) const; // Implemented in 'internal.hpp'.
+
+  /*----------------------------------------------------------------------*/
+
+  void phase (int elit);
+  void unphase (int elit);
+
+  /*----------------------------------------------------------------------*/
+
+  // Traversal functions for the witness stack and units.  The explanation
+  // in 'external.cpp' for why we have to distinguish these cases.
+
+  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 &);
+
+  /*----------------------------------------------------------------------*/
+
+  // Copy flags for determining preprocessing state.
+
+  void copy_flags (External &other) const;
+
+  /*----------------------------------------------------------------------*/
+
+  // Check solver behaves as expected during testing and debugging.
+
+  void check_assumptions_satisfied ();
+  void check_constraint_satisfied ();
+  void check_failing ();
+
+  void check_solution_on_learned_clause ();
+  void check_solution_on_shrunken_clause (Clause *);
+  void check_solution_on_learned_unit_clause (int unit);
+  void check_no_solution_after_learning_empty_clause ();
+
+  void check_learned_empty_clause () {
+    if (solution)
+      check_no_solution_after_learning_empty_clause ();
+  }
+
+  void check_learned_unit_clause (int unit) {
+    if (solution)
+      check_solution_on_learned_unit_clause (unit);
+  }
+
+  void check_learned_clause () {
+    if (solution)
+      check_solution_on_learned_clause ();
+  }
+
+  void check_shrunken_clause (Clause *c) {
+    if (solution)
+      check_solution_on_shrunken_clause (c);
+  }
+
+  void check_assignment (int (External::*assignment) (int) const);
+
+  void check_satisfiable ();
+  void check_unsatisfiable ();
+
+  void check_solve_result (int res);
+
+  void update_molten_literals ();
+
+  /*----------------------------------------------------------------------*/
+
+  // For debugging and testing only.  See 'solution.hpp' for more details.
+  // TODO: if elit > solution_size, elit is an extension variable. For now
+  // the clause will count as satisfied regardless. For the future one
+  // should check that actually there is one consistent extension for the
+  // solution that satisfies the clauses with this extension variable (by
+  // setting it to a value once a clause is learned which is not satisfied
+  // already).
+  //
+  inline int sol (int elit) const {
+    CADICAL_assert (solution);
+    CADICAL_assert (elit != INT_MIN);
+    int eidx = abs (elit);
+    if (eidx > max_var)
+      return 0;
+    else if (eidx > solution_size)
+      return elit;
+    signed char value = solution[eidx];
+    if (!value)
+      return 0;
+    if (elit < 0)
+      value = -value;
+    return value > 0 ? elit : -elit;
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/factor.hpp b/src/sat/cadical/factor.hpp
new file mode 100644
index 000000000..3aa5ea6c6
--- /dev/null
+++ b/src/sat/cadical/factor.hpp
@@ -0,0 +1,60 @@
+#ifndef _factor_hpp_INCLUDED
+#define _factor_hpp_INCLUDED
+
+#include "global.h"
+
+#include "clause.hpp"
+#include "heap.hpp"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct factor_occs_size {
+  Internal *internal;
+  factor_occs_size (Internal *i) : internal (i) {}
+  bool operator() (unsigned a, unsigned b);
+};
+
+struct Quotient {
+  Quotient (int f) : factor (f) {}
+  ~Quotient () {}
+  int factor;
+  size_t id;
+  int64_t bid; // for LRAT
+  Quotient *prev, *next;
+  vector<Clause *> qlauses;
+  vector<size_t> matches;
+  size_t matched;
+};
+
+typedef heap<factor_occs_size> FactorSchedule;
+
+struct Factoring {
+  Factoring (Internal *, int64_t);
+  ~Factoring ();
+
+  // These are initialized by the constructor
+  Internal *internal;
+  int64_t limit;
+  FactorSchedule schedule;
+
+  int initial;
+  int bound;
+  vector<unsigned> count;
+  vector<int> fresh;
+  vector<int> counted;
+  vector<int> nounted;
+  vector<Clause *> flauses;
+  struct {
+    Quotient *first, *last;
+  } quotients;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/file.hpp b/src/sat/cadical/file.hpp
new file mode 100644
index 000000000..860e9613a
--- /dev/null
+++ b/src/sat/cadical/file.hpp
@@ -0,0 +1,221 @@
+#ifndef _file_hpp_INCLUDED
+#define _file_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+
+#ifndef CADICAL_NDEBUG
+#include <climits>
+#endif
+
+/*------------------------------------------------------------------------*/
+#ifdef WIN32
+#define cadical_putc_unlocked putc
+#define cadical_getc_unlocked getc
+#else
+#ifndef NUNLOCKED
+#define cadical_putc_unlocked putc_unlocked
+#define cadical_getc_unlocked getc_unlocked
+#else
+#define cadical_putc_unlocked putc
+#define cadical_getc_unlocked getc
+#endif
+#endif
+/*------------------------------------------------------------------------*/
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// Wraps a 'C' file 'FILE' with name and supports zipped reading and writing
+// through 'popen' using external helper tools.  Reading has line numbers.
+// Compression and decompression relies on external utilities, e.g., 'gzip',
+// 'bzip2', 'xz', and '7z', which should be in the 'PATH'.
+
+struct Internal;
+
+class File {
+
+  Internal *internal;
+#if !defined(CADICAL_QUIET) || !defined(CADICAL_NDEBUG)
+  bool writing;
+#endif
+
+  int close_file; // need to close file (1=fclose, 2=pclose, 3=pipe)
+  int child_pid;
+  FILE *file;
+  char *_name;
+  uint64_t _lineno;
+  uint64_t _bytes;
+
+  File (Internal *, bool, int, int, FILE *, const char *);
+
+  static FILE *open_file (Internal *, const char *path, const char *mode);
+  static FILE *read_file (Internal *, const char *path);
+  static FILE *write_file (Internal *, const char *path);
+
+  static void split_str (const char *, std::vector<char *> &);
+  static void delete_str_vector (std::vector<char *> &);
+
+  static FILE *open_pipe (Internal *, const char *fmt, const char *path,
+                          const char *mode);
+  static FILE *read_pipe (Internal *, const char *fmt, const int *sig,
+                          const char *path);
+#ifndef WIN32
+  static FILE *write_pipe (Internal *, const char *fmt, const char *path,
+                           int &child_pid);
+#endif
+
+public:
+  static char *find_program (const char *prg); // search in 'PATH'
+  static bool exists (const char *path);       // file exists?
+  static bool writable (const char *path);     // can write to that file?
+  static size_t size (const char *path);       // file size in bytes
+
+  bool piping (); // Is opened file a pipe?
+
+  // Does the file match the file type signature.
+  //
+  static bool match (Internal *, const char *path, const int *sig);
+
+  // Read from existing file. Assume given name.
+  //
+  static File *read (Internal *, FILE *f, const char *name);
+
+  // Open file from path name for reading (possibly through opening a pipe
+  // to a decompression utility, based on the suffix).
+  //
+  static File *read (Internal *, const char *path);
+
+  // Same for writing as for reading above.
+  //
+  static File *write (Internal *, FILE *, const char *name);
+  static File *write (Internal *, const char *path);
+
+  ~File ();
+
+  // Using the 'unlocked' versions here is way faster but
+  // not thread safe if the same file is used by different
+  // threads, which on the other hand currently is impossible.
+
+  int get () {
+    CADICAL_assert (!writing);
+    int res = cadical_getc_unlocked (file);
+    if (res == '\n')
+      _lineno++;
+    if (res != EOF)
+      _bytes++;
+    return res;
+  }
+
+  bool put (char ch) {
+    CADICAL_assert (writing);
+    if (cadical_putc_unlocked (ch, file) == EOF)
+      return false;
+    _bytes++;
+    return true;
+  }
+
+  bool endl () { return put ('\n'); }
+
+  bool put (unsigned char ch) {
+    CADICAL_assert (writing);
+    if (cadical_putc_unlocked (ch, file) == EOF)
+      return false;
+    _bytes++;
+    return true;
+  }
+
+  bool put (const char *s) {
+    for (const char *p = s; *p; p++)
+      if (!put (*p))
+        return false;
+    return true;
+  }
+
+  bool put (int lit) {
+    CADICAL_assert (writing);
+    if (!lit)
+      return put ('0');
+    else if (lit == -2147483648) {
+      CADICAL_assert (lit == INT_MIN);
+      return put ("-2147483648");
+    } else {
+      char buffer[11];
+      int i = sizeof buffer;
+      buffer[--i] = 0;
+      CADICAL_assert (lit != INT_MIN);
+      unsigned idx = abs (lit);
+      while (idx) {
+        CADICAL_assert (i > 0);
+        buffer[--i] = '0' + idx % 10;
+        idx /= 10;
+      }
+      if (lit < 0 && !put ('-'))
+        return false;
+      return put (buffer + i);
+    }
+  }
+
+  bool put (int64_t l) {
+    CADICAL_assert (writing);
+    if (!l)
+      return put ('0');
+    else if (l == INT64_MIN) {
+      CADICAL_assert (sizeof l == 8);
+      return put ("-9223372036854775808");
+    } else {
+      char buffer[21];
+      int i = sizeof buffer;
+      buffer[--i] = 0;
+      CADICAL_assert (l != INT64_MIN);
+      uint64_t k = l < 0 ? -l : l;
+      while (k) {
+        CADICAL_assert (i > 0);
+        buffer[--i] = '0' + k % 10;
+        k /= 10;
+      }
+      if (l < 0 && !put ('-'))
+        return false;
+      return put (buffer + i);
+    }
+  }
+
+  bool put (uint64_t l) {
+    CADICAL_assert (writing);
+    if (!l)
+      return put ('0');
+    else {
+      char buffer[22];
+      int i = sizeof buffer;
+      buffer[--i] = 0;
+      while (l) {
+        CADICAL_assert (i > 0);
+        buffer[--i] = '0' + l % 10;
+        l /= 10;
+      }
+      return put (buffer + i);
+    }
+  }
+
+  const char *name () const { return _name; }
+  uint64_t lineno () const { return _lineno; }
+  uint64_t bytes () const { return _bytes; }
+
+  void connect_internal (Internal *i) { internal = i; }
+  bool closed () { return !file; }
+
+  void close (bool print = false);
+  void flush ();
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/flags.hpp b/src/sat/cadical/flags.hpp
new file mode 100644
index 000000000..995438c7a
--- /dev/null
+++ b/src/sat/cadical/flags.hpp
@@ -0,0 +1,91 @@
+#ifndef _flags_hpp_INCLUDED
+#define _flags_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Flags { // Variable flags.
+
+  //  The first set of flags is related to 'analyze' and 'minimize'.
+  //
+  bool seen : 1;       // seen in generating first UIP clause in 'analyze'
+  bool keep : 1;       // keep in learned clause in 'minimize'
+  bool poison : 1;     // can not be removed in 'minimize'
+  bool removable : 1;  // can be removed in 'minimize'
+  bool shrinkable : 1; // can be removed in 'shrink'
+  bool added : 1; // has already been added to lrat_chain (in 'minimize')
+
+  // These three variable flags are used to schedule clauses in subsumption
+  // ('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 sweep : 1;
+  bool blockable : 1;
+
+  unsigned char
+      marked_signed : 2; // generate correct LRAT chains in decompose
+  unsigned char factor : 2;
+
+  // These literal flags are used by blocked clause elimination ('block').
+  //
+  unsigned char block : 2; // removed since last 'block' round (*)
+  unsigned char skip : 2;  // skip this literal as blocking literal
+
+  // Bits for handling assumptions.
+  //
+  unsigned char assumed : 2;
+  unsigned char failed : 2; // 0 if not part of failure
+                            // 1 if positive lit is in failure
+                            // 2 if negated lit is in failure
+
+  enum {
+    UNUSED = 0,
+    ACTIVE = 1,
+    FIXED = 2,
+    ELIMINATED = 3,
+    SUBSTITUTED = 4,
+    PURE = 5
+  };
+
+  unsigned char status : 3;
+
+  // Initialized explicitly in 'Internal::init' through this function.
+  //
+  Flags () {
+    seen = keep = poison = removable = shrinkable = added = sweep = false;
+    subsume = elim = ternary = true;
+    block = 3u;
+    skip = assumed = failed = marked_signed = factor = 0;
+    status = UNUSED;
+  }
+
+  bool unused () const { return status == UNUSED; }
+  bool active () const { return status == ACTIVE; }
+  bool fixed () const { return status == FIXED; }
+  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;
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/format.hpp b/src/sat/cadical/format.hpp
new file mode 100644
index 000000000..cf229e760
--- /dev/null
+++ b/src/sat/cadical/format.hpp
@@ -0,0 +1,42 @@
+#ifndef _format_hpp_INCLUDED
+#define _format_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdarg>
+#include <cstdint>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// This class provides a 'printf' style formatting utility.
+// Only '%c', '%d', '%s' are supported at this point.
+// It is used to capture and save an error message.
+
+class Format {
+  char *buffer;
+  int64_t count, size;
+  void enlarge ();
+  void push_char (char);
+  void push_string (const char *);
+  void push_int (int);
+  void push_uint64 (uint64_t);
+  const char *add (const char *fmt, va_list &);
+
+public:
+  Format () : buffer (0), count (0), size (0) {}
+  ~Format () {
+    if (buffer)
+      delete[] buffer;
+  }
+  const char *init (const char *fmt, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  const char *append (const char *fmt, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  operator const char * () const { return count ? buffer : 0; }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/frattracer.hpp b/src/sat/cadical/frattracer.hpp
new file mode 100644
index 000000000..cadfa3721
--- /dev/null
+++ b/src/sat/cadical/frattracer.hpp
@@ -0,0 +1,68 @@
+#ifndef _frattracer_h_INCLUDED
+#define _frattracer_h_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+class FratTracer : public FileTracer {
+
+  Internal *internal;
+  File *file;
+  bool binary;
+  bool with_antecedents;
+
+#ifndef CADICAL_QUIET
+  int64_t added, deleted;
+  int64_t finalized, original;
+#endif
+
+  vector<int64_t> delete_ids;
+
+  void put_binary_zero ();
+  void put_binary_lit (int external_lit);
+  void put_binary_id (int64_t id, bool = false);
+
+  // support FRAT
+  void frat_add_original_clause (int64_t, const vector<int> &);
+  void frat_add_derived_clause (int64_t, const vector<int> &);
+  void frat_add_derived_clause (int64_t, const vector<int> &,
+                                const vector<int64_t> &);
+  void frat_delete_clause (int64_t, const vector<int> &);
+  void frat_finalize_clause (int64_t, const vector<int> &);
+
+public:
+  // own and delete 'file'
+  FratTracer (Internal *, File *file, bool binary, bool antecedents);
+  ~FratTracer ();
+
+  void connect_internal (Internal *i) override;
+  void begin_proof (int64_t) override {} // skip
+
+  void add_original_clause (int64_t, bool, const vector<int> &,
+                            bool = false) override;
+
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &) override;
+
+  void delete_clause (int64_t, bool, const vector<int> &) override;
+
+  void finalize_clause (int64_t, const vector<int> &) override;
+
+  void report_status (int, int64_t) override {} // skip
+
+#ifndef CADICAL_QUIET
+  void print_statistics ();
+#endif
+  bool closed () override;
+  void close (bool) override;
+  void flush (bool) override;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/global.h b/src/sat/cadical/global.h
new file mode 100644
index 000000000..916246cab
--- /dev/null
+++ b/src/sat/cadical/global.h
@@ -0,0 +1,21 @@
+#ifndef ABC_SAT_CADICAL_GLOBAL_HPP_
+#define ABC_SAT_CADICAL_GLOBAL_HPP_
+
+// comment out next line to enable cadical debug mode
+#define CADICAL_NDEBUG
+
+#define CADICAL_NBUILD
+#define CADICAL_QUIET
+#define CADICAL_NCONTRACTS
+#define CADICAL_NTRACING
+#define CADICAL_NCLOSEFROM
+
+#ifdef CADICAL_NDEBUG
+#define CADICAL_assert(ignore) ((void)0)
+#else
+#define CADICAL_assert(cond) assert(cond)
+#endif
+
+#include "misc/util/abc_global.h"
+
+#endif
diff --git a/src/sat/cadical/heap.hpp b/src/sat/cadical/heap.hpp
new file mode 100644
index 000000000..c42941413
--- /dev/null
+++ b/src/sat/cadical/heap.hpp
@@ -0,0 +1,218 @@
+#ifndef _heap_hpp_INCLUDED
+#define _heap_hpp_INCLUDED
+
+#include "global.h"
+
+#include "util.hpp" // Alphabetically after 'heap.hpp'.
+
+#include <cassert>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+using namespace std;
+
+// This is a priority queue with updates for unsigned integers implemented
+// as binary heap.  We need to map integer elements added (through
+// 'push_back') to positions on the binary heap in 'array'. This map is
+// stored in the 'pos' array. This approach is really wasteful (at least in
+// terms of memory) if only few and a sparse set of integers is added.  So
+// it should not be used in this situation.  A generic priority queue would
+// implement the mapping externally provided by another template parameter.
+// Since we use 'UINT_MAX' as 'not contained' flag, we can only have
+// 'UINT_MAX - 1' elements in the heap.
+
+const unsigned invalid_heap_position = UINT_MAX;
+
+template <class C> class heap {
+
+  vector<unsigned> array; // actual binary heap
+  vector<unsigned> pos;   // positions of elements in array
+  C less;                 // less-than for elements
+
+  // Map an element to its position entry in the 'pos' map.
+  //
+  unsigned &index (unsigned e) {
+    if (e >= pos.size ())
+      pos.resize (1 + (size_t) e, invalid_heap_position);
+    unsigned &res = pos[e];
+    CADICAL_assert (res == invalid_heap_position || (size_t) res < array.size ());
+    return res;
+  }
+
+  bool has_parent (unsigned e) { return index (e) > 0; }
+  bool has_left (unsigned e) {
+    return (size_t) 2 * index (e) + 1 < size ();
+  }
+  bool has_right (unsigned e) {
+    return (size_t) 2 * index (e) + 2 < size ();
+  }
+
+  unsigned parent (unsigned e) {
+    CADICAL_assert (has_parent (e));
+    return array[(index (e) - 1) / 2];
+  }
+
+  unsigned left (unsigned e) {
+    CADICAL_assert (has_left (e));
+    return array[2 * index (e) + 1];
+  }
+
+  unsigned right (unsigned e) {
+    CADICAL_assert (has_right (e));
+    return array[2 * index (e) + 2];
+  }
+
+  // Exchange elements 'a' and 'b' in 'array' and fix their positions.
+  //
+  void exchange (unsigned a, unsigned b) {
+    unsigned &i = index (a), &j = index (b);
+    swap (array[i], array[j]);
+    swap (i, j);
+  }
+
+  // Bubble up an element as far as necessary.
+  //
+  void up (unsigned e) {
+    unsigned p;
+    while (has_parent (e) && less ((p = parent (e)), e))
+      exchange (p, e);
+  }
+
+  // Bubble down an element as far as necessary.
+  //
+  void down (unsigned e) {
+    while (has_left (e)) {
+      unsigned c = left (e);
+      if (has_right (e)) {
+        unsigned r = right (e);
+        if (less (c, r))
+          c = r;
+      }
+      if (!less (e, c))
+        break;
+      exchange (e, c);
+    }
+  }
+
+  // Very expensive checker for the main 'heap' invariant.  Can be enabled
+  // to find violations of antisymmetry in the client implementation of
+  // 'less' and as well of course bugs in this heap implementation.  It
+  // should be enabled during testing applications of the heap.
+  //
+  void check () {
+#if 0 // EXPENSIVE HEAP CHECKING IF ENABLED
+#warning "expensive checking in heap enabled"
+    CADICAL_assert (array.size () <= invalid_heap_position);
+    for (size_t i = 0; i < array.size (); i++) {
+      size_t l = 2*i + 1, r = 2*i + 2;
+      if (l < array.size ()) CADICAL_assert (!less (array[i], array[l]));
+      if (r < array.size ()) CADICAL_assert (!less (array[i], array[r]));
+      CADICAL_assert (array[i] >= 0);
+      {
+        CADICAL_assert ((size_t) array[i] < pos.size ());
+        CADICAL_assert (i == (size_t) pos[array[i]]);
+      }
+    }
+    for (size_t i = 0; i < pos.size (); i++) {
+      if (pos[i] == invalid_heap_position) continue;
+      CADICAL_assert (pos[i] < array.size ());
+      CADICAL_assert (array[pos[i]] == (unsigned) i);
+    }
+#endif
+  }
+
+public:
+  heap (const C &c) : less (c) {}
+
+  // Number of elements in the heap.
+  //
+  size_t size () const { return array.size (); }
+
+  // Check if no more elements are in the heap.
+  //
+  bool empty () const { return array.empty (); }
+
+  // Check whether 'e' is already in the heap.
+  //
+  bool contains (unsigned e) const {
+    if ((size_t) e >= pos.size ())
+      return false;
+    return pos[e] != invalid_heap_position;
+  }
+
+  // Add a new (not contained) element 'e' to the heap.
+  //
+  void push_back (unsigned e) {
+    CADICAL_assert (!contains (e));
+    size_t i = array.size ();
+    CADICAL_assert (i < (size_t) invalid_heap_position);
+    array.push_back (e);
+    index (e) = (unsigned) i;
+    up (e);
+    down (e);
+    check ();
+  }
+
+  // Returns the maximum element in the heap.
+  //
+  unsigned front () const {
+    CADICAL_assert (!empty ());
+    return array[0];
+  }
+
+  // Removes the maximum element in the heap.
+  //
+  unsigned pop_front () {
+    CADICAL_assert (!empty ());
+    unsigned res = array[0], last = array.back ();
+    if (size () > 1)
+      exchange (res, last);
+    index (res) = invalid_heap_position;
+    array.pop_back ();
+    if (size () > 1)
+      down (last);
+    check ();
+    return res;
+  }
+
+  // Notify the heap, that evaluation of 'less' has changed for 'e'.
+  //
+  void update (unsigned e) {
+    CADICAL_assert (contains (e));
+    up (e);
+    down (e);
+    check ();
+  }
+
+  void clear () {
+    array.clear ();
+    pos.clear ();
+  }
+
+  void erase () {
+    erase_vector (array);
+    erase_vector (pos);
+  }
+
+  void shrink () {
+    shrink_vector (array);
+    shrink_vector (pos);
+  }
+
+  // Standard iterators 'inherited' from 'vector'.
+  //
+  typedef typename vector<unsigned>::iterator iterator;
+  typedef typename vector<unsigned>::const_iterator const_iterator;
+  iterator begin () { return array.begin (); }
+  iterator end () { return array.end (); }
+  const_iterator begin () const { return array.begin (); }
+  const_iterator end () const { return array.end (); }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/idruptracer.hpp b/src/sat/cadical/idruptracer.hpp
new file mode 100644
index 000000000..4ea478705
--- /dev/null
+++ b/src/sat/cadical/idruptracer.hpp
@@ -0,0 +1,116 @@
+#ifndef _idruptracer_h_INCLUDED
+#define _idruptracer_h_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+class FileTracer;
+
+namespace CaDiCaL {
+
+struct IdrupClause {
+  IdrupClause *next; // collision chain link for hash table
+  uint64_t hash;     // previously computed full 64-bit hash
+  int64_t id;        // id of clause
+  unsigned size;
+  int literals[1];
+};
+
+class IdrupTracer : public FileTracer {
+
+  Internal *internal;
+  File *file;
+  bool binary;
+  bool piping; // The 'file' is a pipe and needs eagerly flushing.
+
+  // hash table for conclusion
+  //
+  uint64_t num_clauses;  // number of clauses in hash table
+  uint64_t size_clauses; // size of clause hash table
+  IdrupClause **clauses; // hash table of clauses
+  vector<int> imported_clause;
+  vector<int> assumptions;
+
+  static const unsigned num_nonces = 4;
+
+  uint64_t nonces[num_nonces]; // random numbers for hashing
+  uint64_t last_hash;          // last computed hash value of clause
+  int64_t last_id;             // id of the last added clause
+  IdrupClause *last_clause;
+  uint64_t compute_hash (int64_t); // compute and save hash value of clause
+
+  IdrupClause *new_clause ();
+  void delete_clause (IdrupClause *);
+
+  static uint64_t reduce_hash (uint64_t hash, uint64_t size);
+
+  void enlarge_clauses (); // enlarge hash table for clauses
+  void insert ();          // insert clause in hash table
+  bool
+  find_and_delete (const int64_t); // find clause position in hash table
+
+#ifndef CADICAL_QUIET
+  int64_t added, deleted, weakened, restore, original, solved;
+#endif
+
+  void flush_if_piping ();
+
+  void put_binary_zero ();
+  void put_binary_lit (int external_lit);
+  void put_binary_id (int64_t id, bool = false);
+
+  void idrup_add_derived_clause (const vector<int> &clause);
+  void idrup_delete_clause (int64_t id, const vector<int> &clause);
+  void idrup_add_restored_clause (const vector<int> &clause);
+  void idrup_add_original_clause (const vector<int> &clause);
+  void idrup_conclude_and_delete (const vector<int64_t> &conclusion);
+  void idrup_report_status (int status);
+  void idrup_conclude_sat (const vector<int> &model);
+  void idrup_conclude_unknown (const vector<int> &trail);
+  void idrup_solve_query ();
+
+public:
+  IdrupTracer (Internal *, File *file, bool);
+  ~IdrupTracer ();
+
+  // proof section:
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &) override;
+  void add_assumption_clause (int64_t, const vector<int> &,
+                              const vector<int64_t> &) override;
+  void weaken_minus (int64_t, const vector<int> &) override;
+  void delete_clause (int64_t, bool, const vector<int> &) override;
+  void add_original_clause (int64_t, bool, const vector<int> &,
+                            bool = false) override;
+  void report_status (int, int64_t) override;
+  void conclude_sat (const vector<int> &) override;
+  void conclude_unsat (ConclusionType, const vector<int64_t> &) override;
+  void conclude_unknown (const vector<int> &) override;
+
+  void solve_query () override;
+  void add_assumption (int) override;
+  void reset_assumptions () override;
+
+  // skip
+  void begin_proof (int64_t) override {}
+  void finalize_clause (int64_t, const vector<int> &) override {}
+  void strengthen (int64_t) override {}
+  void add_constraint (const vector<int> &) override {}
+
+  // logging and file io
+  void connect_internal (Internal *i) override;
+
+#ifndef CADICAL_QUIET
+  void print_statistics ();
+#endif
+  bool closed () override;
+  void close (bool) override;
+  void flush (bool) override;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/instantiate.hpp b/src/sat/cadical/instantiate.hpp
new file mode 100644
index 000000000..f6c8767dd
--- /dev/null
+++ b/src/sat/cadical/instantiate.hpp
@@ -0,0 +1,51 @@
+#ifndef _instantiate_hpp_INCLUDED
+#define _instantiate_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// We are trying to remove literals in clauses, which occur in few clauses
+// and further restrict this removal to variables for which variable
+// elimination failed.  Thus if for instance we succeed in removing the
+// single occurrence of a literal, pure literal elimination can
+// eliminate the corresponding variable in the next variable elimination
+// round.  The set of such literal clause candidate pairs is collected at
+// the end of a variable elimination round and tried before returning.  The
+// name of this technique is inspired by 'variable instantiation' as
+// described in [AnderssonBjesseCookHanna-DAC'02] and apparently
+// successfully used in the 'Oepir' SAT solver.
+
+struct Clause;
+struct Internal;
+
+class Instantiator {
+
+  friend struct Internal;
+
+  struct Candidate {
+    int lit;
+    int size;
+    size_t negoccs;
+    Clause *clause;
+    Candidate (int l, Clause *c, int s, size_t n)
+        : lit (l), size (s), negoccs (n), clause (c) {}
+  };
+
+  vector<Candidate> candidates;
+
+public:
+  void candidate (int l, Clause *c, int s, size_t n) {
+    candidates.push_back (Candidate (l, c, s, n));
+  }
+
+  operator bool () const { return !candidates.empty (); }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/internal.hpp b/src/sat/cadical/internal.hpp
new file mode 100644
index 000000000..d86479a52
--- /dev/null
+++ b/src/sat/cadical/internal.hpp
@@ -0,0 +1,1866 @@
+#ifndef _internal_hpp_INCLUDED
+#define _internal_hpp_INCLUDED
+
+#include "global.h"
+
+/*------------------------------------------------------------------------*/
+
+// Wrapped build specific headers which should go first.
+
+#include "inttypes.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// Common 'C' headers.
+
+#include <cassert>
+#include <cctype>
+#include <climits>
+#include <cmath>
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+// Less common 'C' header.
+
+#ifndef WIN32
+extern "C" {
+#include <unistd.h>
+}
+#endif
+
+/*------------------------------------------------------------------------*/
+
+// Common 'C++' headers.
+
+#include <algorithm>
+#include <queue>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+/*------------------------------------------------------------------------*/
+
+// All internal headers are included here.  This gives a nice overview on
+// what is needed altogether. The 'Internal' class needs almost all the
+// headers anyhow (since the idea is to avoid pointer references as much as
+// possible).  Most implementation files need to see the definition of the
+// 'Internal' too.  Thus there is no real advantage in trying to reduce the
+// number of header files included here.  The other benefit of having all
+// header files here is that '.cpp' files then only need to include this.
+
+#include "arena.hpp"
+#include "averages.hpp"
+#include "bins.hpp"
+#include "block.hpp"
+#include "cadical.hpp"
+#include "checker.hpp"
+#include "clause.hpp"
+#include "config.hpp"
+#include "congruence.hpp"
+#include "contract.hpp"
+#include "cover.hpp"
+#include "decompose.hpp"
+#include "drattracer.hpp"
+#include "elim.hpp"
+#include "ema.hpp"
+#include "external.hpp"
+#include "factor.hpp"
+#include "file.hpp"
+#include "flags.hpp"
+#include "format.hpp"
+#include "frattracer.hpp"
+#include "heap.hpp"
+#include "idruptracer.hpp"
+#include "instantiate.hpp"
+#include "internal.hpp"
+#include "level.hpp"
+#include "lidruptracer.hpp"
+#include "limit.hpp"
+#include "logging.hpp"
+#include "lratchecker.hpp"
+#include "lrattracer.hpp"
+#include "message.hpp"
+#include "occs.hpp"
+#include "options.hpp"
+#include "parse.hpp"
+#include "phases.hpp"
+#include "profile.hpp"
+#include "proof.hpp"
+#include "queue.hpp"
+#include "radix.hpp"
+#include "random.hpp"
+#include "range.hpp"
+#include "reap.hpp"
+#include "reluctant.hpp"
+#include "resources.hpp"
+#include "score.hpp"
+#include "stats.hpp"
+#include "sweep.hpp"
+#include "terminal.hpp"
+#include "tracer.hpp"
+#include "util.hpp"
+#include "var.hpp"
+#include "veripbtracer.hpp"
+#include "version.hpp"
+#include "vivify.hpp"
+#include "watch.hpp"
+
+// c headers
+//extern "C" {
+#include "kitten.h"
+//}
+/*------------------------------------------------------------------------*/
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+using namespace std;
+
+struct Coveror;
+struct External;
+struct Walker;
+class Tracer;
+class FileTracer;
+class StatTracer;
+
+struct CubesWithStatus {
+  int status = 0;
+  std::vector<std::vector<int>> cubes;
+};
+
+/*------------------------------------------------------------------------*/
+
+struct Internal {
+
+  /*----------------------------------------------------------------------*/
+
+  // The actual internal state of the solver is set and maintained in this
+  // section.  This is currently only used for debugging and testing.
+
+  enum Mode {
+    BLOCK = (1 << 0),
+    CONDITION = (1 << 1),
+    CONGRUENCE = (1 << 2),
+    COVER = (1 << 3),
+    DECOMP = (1 << 4),
+    DEDUP = (1 << 5),
+    ELIM = (1 << 6),
+    FACTOR = (1 << 7),
+    LUCKY = (1 << 8),
+    PROBE = (1 << 9),
+    SEARCH = (1 << 10),
+    SIMPLIFY = (1 << 11),
+    SUBSUME = (1 << 12),
+    SWEEP = (1 << 13),
+    TERNARY = (1 << 14),
+    TRANSRED = (1 << 15),
+    VIVIFY = (1 << 16),
+    WALK = (1 << 17),
+  };
+
+  bool in_mode (Mode m) const { return (mode & m) != 0; }
+  void set_mode (Mode m) {
+    CADICAL_assert (!(mode & m));
+    mode |= m;
+  }
+  void reset_mode (Mode m) {
+    CADICAL_assert (mode & m);
+    mode &= ~m;
+  }
+  void require_mode (Mode m) const { CADICAL_assert (mode & m), (void) m; }
+
+  /*----------------------------------------------------------------------*/
+
+  int mode; // current internal state
+  int tier1[2] = {
+      2, 2}; // tier1 limit for 0=focused, 1=stable; aka tier1[stable]
+  int tier2[2] = {
+      6, 6};      // tier2 limit for 0=focused, 1=stable; aka tier1[stable]
+  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 searching_lucky_phases; // during 'lucky_phases'
+  bool stable;                 // true during stabilization phase
+  bool reported;               // reported in this solving call
+  bool external_prop;         // true if an external propagator is connected
+  bool did_external_prop;     // true if ext. propagation happened
+  bool external_prop_is_lazy; // true if the external propagator is lazy
+  bool forced_backt_allowed;  // external propagator can force backtracking
+  bool private_steps;   // no notification of ext. prop during these steps
+  char rephased;        // last type of resetting phases
+  Reluctant reluctant;  // restart counter in stable mode
+  size_t vsize;         // actually allocated variable data size
+  int max_var;          // internal maximum variable index
+  int64_t clause_id;    // last used id for clauses
+  int64_t original_id;  // ids for original clauses to produce LRAT
+  int64_t reserved_ids; // number of reserved ids for original clauses
+  int64_t conflict_id;  // store conflict id for finalize (frat)
+  int64_t saved_decisions;    // to compute decision rate average
+  bool concluded;             // keeps track of conclude
+  vector<int64_t> conclusion; // store ids of conclusion clauses
+  vector<int64_t>
+      unit_clauses_idx;       // keep track of unit_clauses (LRAT/FRAT)
+  vector<int64_t> lrat_chain; // create LRAT in solver: option lratdirect
+  vector<int64_t> mini_chain; // used to create LRAT in minimize
+  vector<int64_t> minimize_chain; // used to create LRAT in minimize
+  vector<int64_t> unit_chain;     // used to avoid duplicate units
+  vector<Clause *> inst_chain;    // for LRAT in instantiate
+  vector<vector<vector<int64_t>>>
+      probehbr_chains;          // only used if opts.probehbr=false
+  bool lrat;                    // generate LRAT internally
+  bool frat;                    // finalize non-deleted clauses in proof
+  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]
+  vector<unsigned> frozentab;   // frozen counters [1,max_var]
+  vector<int> i2e;              // maps internal 'idx' to external 'lit'
+  vector<unsigned> relevanttab; // Reference counts for observed variables.
+  Queue queue;                  // variable move to front decision queue
+  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]
+  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<Occs> rtab;            // table of redundant occurrences
+  vector<int> ptab;             // table for caching probing attempts
+  vector<int64_t> ntab;         // number of one-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'
+  Clause *ignore;               // ignored during 'vivify_propagate'
+  Clause *dummy_binary;         // Dummy binary clause for subsumption
+  Clause *external_reason;      // used as reason at external propagations
+  Clause *newest_clause;        // used in external_propagate
+  bool force_no_backtrack;      // for new clauses with external propagator
+  bool from_propagator;         // differentiate new clauses...
+  bool ext_clause_forgettable;  // Is new clause from propagator forgettable
+  int tainted_literal;          // used for ILB
+  size_t notified;           // next trail position to notify external prop
+  Clause *probe_reason;      // set during probing
+  size_t propagated;         // next trail position to propagate
+  size_t propagated2;        // next binary trail position to propagate
+  size_t propergated;        // propagated without blocking literals
+  size_t best_assigned;      // best maximum assigned ever
+  size_t target_assigned;    // maximum assigned without conflict
+  size_t no_conflict_until;  // largest trail prefix without conflict
+  vector<int> trail;         // currently assigned literals
+  vector<int> clause;        // simplified in parsing & learning
+  vector<int> assumptions;   // assumed literals
+  vector<int> constraint;    // literals of the constraint
+  bool unsat_constraint;     // constraint used for unsatisfiability?
+  bool marked_failed;        // are the failed assumptions marked?
+  vector<int> original;      // original added literals
+  vector<int> levels;        // decision levels in learned clause
+  vector<int> analyzed;      // analyzed literals in 'analyze'
+  vector<int> unit_analyzed; // to avoid duplicate units in lrat_chain
+  vector<int> sign_marked;   // literals skipped in 'decompose'
+  vector<int> minimized;     // removable or poison in 'minimize'
+  vector<int> shrinkable;    // removable or poison in 'shrink'
+  Reap reap;                 // radix heap for shrink
+
+  vector<int> sweep_schedule; // remember sweep varibles to reschedule
+  bool sweep_incomplete;      // sweep
+
+  cadical_kitten *citten;
+
+  size_t num_assigned; // check for satisfied
+
+  vector<int> probes;       // remaining scheduled probes
+  vector<Level> control;    // 'level + 1 == control.size ()'
+  vector<Clause *> clauses; // ordered collection of all clauses
+  Averages averages;        // glue, size, jump moving averages
+  Delay delay[2];           // Delay certain functions
+  Delay congruence_delay;   // Delay congruence if not successful recently
+  Limit lim;                // limits for various phases
+  Last last;                // statistics at last occurrence
+  Inc inc;                  // increments on limits
+
+  Delay delaying_vivify_irredundant;
+  Delay delaying_sweep;
+
+  Proof *proof; // abstraction layer between solver and tracers
+  vector<Tracer *>
+      tracers; // proof tracing objects (ie interpolant calculator)
+  vector<FileTracer *>
+      file_tracers; // file proof tracers (ie DRAT, LRAT...)
+  vector<StatTracer *> stat_tracers; // checkers
+
+  Options opts; // run-time options
+  Stats stats;  // statistics
+#ifndef CADICAL_QUIET
+  Profiles profiles;         // time profiles for various functions
+  bool force_phase_messages; // force 'phase (...)' messages
+#endif
+  Arena arena;          // memory arena for moving garbage collector
+  Format error_message; // provide persistent error message
+  string prefix;        // verbose messages prefix
+
+  Internal *internal; // proxy to 'this' in macros
+  External *external; // proxy to 'external' buddy in 'Solver'
+
+  const unsigned max_used = 255; // must fix into the header of the clause!
+  /*----------------------------------------------------------------------*/
+
+  // 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_vars' function initializes
+  // variables up to and including the requested variable index.
+  //
+  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);
+
+  // only able to restore irredundant clause
+  void finish_added_clause_with_id (int64_t id, bool restore = false);
+
+  // Reserve ids for original clauses to produce lrat
+  void reserve_ids (int number);
+
+  // Enlarge tables.
+  //
+  void enlarge_vals (size_t new_vsize);
+  void enlarge (int new_max_var);
+
+  // A variable is 'active' if it is not eliminated nor fixed.
+  //
+  bool active (int lit) { return flags (lit).active (); }
+
+  int active () const {
+    int res = stats.active;
+#ifndef CADICAL_NDEBUG
+    int tmp = max_var;
+    tmp -= stats.unused;
+    tmp -= stats.now.fixed;
+    tmp -= stats.now.eliminated;
+    tmp -= stats.now.substituted;
+    tmp -= stats.now.pure;
+    CADICAL_assert (tmp >= 0);
+    CADICAL_assert (tmp == res);
+#endif
+    return res;
+  }
+
+  void reactivate (int lit); // During 'restore'.
+
+  // Currently remaining active redundant and irredundant clauses.
+
+  int64_t redundant () const { return stats.current.redundant; }
+
+  int64_t irredundant () const { return stats.current.irredundant; }
+
+  double clause_variable_ratio () const {
+    return relative (irredundant (), active ());
+  }
+
+  // Scale values relative to clause variable ratio.
+  //
+  double scale (double v) const;
+
+  // Unsigned literals (abs) with checks.
+  //
+  int vidx (int lit) const {
+    int idx;
+    CADICAL_assert (lit);
+    CADICAL_assert (lit != INT_MIN);
+    idx = abs (lit);
+    CADICAL_assert (idx <= max_var);
+    return idx;
+  }
+
+  // Unsigned version with LSB denoting sign.  This is used in indexing
+  // arrays by literals.  The idea is to keep the elements in such an array
+  // for both the positive and negated version of a literal close together.
+  //
+  unsigned vlit (int lit) const {
+    return (lit < 0) + 2u * (unsigned) vidx (lit);
+  }
+
+  int u2i (unsigned u) {
+    CADICAL_assert (u > 1);
+    int res = u / 2;
+    CADICAL_assert (res <= max_var);
+    if (u & 1)
+      res = -res;
+    return res;
+  }
+
+  int citten2lit (unsigned ulit) {
+    int res = (ulit / 2) + 1;
+    CADICAL_assert (res <= max_var);
+    if (ulit & 1)
+      res = -res;
+    return res;
+  }
+
+  unsigned lit2citten (int lit) {
+    int idx = vidx (lit) - 1;
+    return (lit < 0) + 2u * (unsigned) idx;
+  }
+
+  int64_t unit_id (int lit) const {
+    CADICAL_assert (lrat || frat);
+    CADICAL_assert (val (lit) > 0);
+    const unsigned uidx = vlit (lit);
+    int64_t id = unit_clauses_idx[uidx];
+    CADICAL_assert (id);
+    return id;
+  }
+
+  inline int64_t &unit_clauses (int uidx) {
+    CADICAL_assert (lrat || frat);
+    CADICAL_assert (uidx > 0);
+    CADICAL_assert ((size_t) uidx < unit_clauses_idx.size ());
+    return unit_clauses_idx[uidx];
+  }
+
+  // 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)]; }
+  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)]; }
+
+  const Flags &flags (int lit) const { return ftab[vidx (lit)]; }
+
+  bool occurring () const { return !otab.empty (); }
+  bool watching () const { return !wtab.empty (); }
+
+  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 (EVSIDS) as in MiniSAT.
+  //
+  bool use_scores () const { return opts.score && stable; }
+  void bump_variable_score (int lit);
+  void bump_variable_score_inc ();
+  void rescale_variable_scores ();
+
+  // Marking variables with a sign (positive or negative).
+  //
+  signed char marked (int lit) const {
+    signed char res = marks[vidx (lit)];
+    if (lit < 0)
+      res = -res;
+    return res;
+  }
+  void mark (int lit) {
+    CADICAL_assert (!marked (lit));
+    marks[vidx (lit)] = sign (lit);
+    CADICAL_assert (marked (lit) > 0);
+    CADICAL_assert (marked (-lit) < 0);
+  }
+  void unmark (int lit) {
+    marks[vidx (lit)] = 0;
+    CADICAL_assert (!marked (lit));
+  }
+
+  // Use only bits 6 and 7 to store the sign or zero.  The remaining
+  // bits can be used as additional flags.
+  //
+  signed char marked67 (int lit) const {
+    signed char res = marks[vidx (lit)] >> 6;
+    if (lit < 0)
+      res = -res;
+    return res;
+  }
+  void mark67 (int lit) {
+    signed char &m = marks[vidx (lit)];
+    const signed char mask = 0x3f;
+#ifndef CADICAL_NDEBUG
+    const signed char bits = m & mask;
+#endif
+    m = (m & mask) | (sign (lit) << 6);
+    CADICAL_assert (marked (lit) > 0);
+    CADICAL_assert (marked (-lit) < 0);
+    CADICAL_assert ((m & mask) == bits);
+    CADICAL_assert (marked67 (lit) > 0);
+    CADICAL_assert (marked67 (-lit) < 0);
+  }
+  void unmark67 (int lit) {
+    signed char &m = marks[vidx (lit)];
+    const signed char mask = 0x3f;
+#ifndef CADICAL_NDEBUG
+    const signed bits = m & mask;
+#endif
+    m &= mask;
+    CADICAL_assert ((m & mask) == bits);
+  }
+
+  void unmark (vector<int> &lits) {
+    for (const auto &lit : lits)
+      unmark (lit);
+  }
+
+  // The other 6 bits of the 'marks' bytes can be used as additional
+  // (unsigned) marking bits.  Currently we only use the least significant
+  // bit in 'condition' to mark variables in the conditional part.
+  //
+  bool getbit (int lit, int bit) const {
+    CADICAL_assert (0 <= bit), CADICAL_assert (bit < 6);
+    return marks[vidx (lit)] & (1 << bit);
+  }
+  void setbit (int lit, int bit) {
+    CADICAL_assert (0 <= bit), CADICAL_assert (bit < 6);
+    CADICAL_assert (!getbit (lit, bit));
+    marks[vidx (lit)] |= (1 << bit);
+    CADICAL_assert (getbit (lit, bit));
+  }
+  void unsetbit (int lit, int bit) {
+    CADICAL_assert (0 <= bit), CADICAL_assert (bit < 6);
+    CADICAL_assert (getbit (lit, bit));
+    marks[vidx (lit)] &= ~(1 << bit);
+    CADICAL_assert (!getbit (lit, bit));
+  }
+
+  // Marking individual literals.
+  //
+  bool marked2 (int lit) const {
+    unsigned res = marks[vidx (lit)];
+    CADICAL_assert (res <= 3);
+    unsigned bit = bign (lit);
+    return (res & bit) != 0;
+  }
+  void mark2 (int lit) {
+    marks[vidx (lit)] |= bign (lit);
+    CADICAL_assert (marked2 (lit));
+  }
+
+  // marks bits 1,2,3 and 4,5,6 depending on fact and sign of lit
+  //
+  bool getfact (int lit, int fact) const {
+    CADICAL_assert (fact == 1 || fact == 2 || fact == 4);
+    int res = marks[vidx (lit)];
+    if (lit < 0) {
+      res >>= 3;
+    } else {
+      res &= 7;
+    }
+    // CADICAL_assert (!res || res == 1 || res == 2 || res == 4);
+    return res & fact;
+  }
+
+  void markfact (int lit, int fact) {
+    CADICAL_assert (fact == 1 || fact == 2 || fact == 4);
+    CADICAL_assert (!getfact (lit, fact));
+#ifndef CADICAL_NDEBUG
+    int before = getfact (-lit, fact);
+#endif
+    int res = marks[vidx (lit)];
+    if (lit < 0) {
+      res |= fact << 3;
+    } else {
+      res |= fact;
+    }
+    marks[vidx (lit)] = res;
+    CADICAL_assert (getfact (lit, fact));
+#ifndef CADICAL_NDEBUG
+    CADICAL_assert (getfact (-lit, fact) == before);
+#endif
+  }
+
+  void unmarkfact (int lit, int fact) {
+    CADICAL_assert (fact == 1 || fact == 2 || fact == 4);
+    CADICAL_assert (getfact (lit, fact));
+    int res = marks[vidx (lit)];
+    if (lit < 0) {
+      res &= ~(fact << 3);
+    } else {
+      res &= ~fact;
+    }
+    marks[vidx (lit)] = res;
+    CADICAL_assert (!getfact (lit, fact));
+  }
+
+  // Marking and unmarking of all literals in a clause.
+  //
+  void mark_clause (); // mark 'this->clause'
+  void mark (Clause *);
+  void mark2 (Clause *);
+  void unmark_clause (); // unmark 'this->clause'
+  void unmark (Clause *);
+
+  // Watch literal 'lit' in clause with blocking literal 'blit'.
+  // Inlined here, since it occurs in the tight inner loop of 'propagate'.
+  //
+  inline void watch_literal (int lit, int blit, Clause *c) {
+    CADICAL_assert (lit != blit);
+    Watches &ws = watches (lit);
+    ws.push_back (Watch (blit, c));
+    LOG (c, "watch %d blit %d in", lit, blit);
+  }
+
+  // Add two watches to a clause.  This is used initially during allocation
+  // of a clause and during connecting back all watches after preprocessing.
+  //
+  inline void watch_clause (Clause *c) {
+    const int l0 = c->literals[0];
+    const int l1 = c->literals[1];
+    watch_literal (l0, l1, c);
+    watch_literal (l1, l0, c);
+  }
+
+  inline void unwatch_clause (Clause *c) {
+    const int l0 = c->literals[0];
+    const int l1 = c->literals[1];
+    remove_watch (watches (l0), c);
+    remove_watch (watches (l1), c);
+  }
+
+  // Update queue to point to last potentially still unassigned variable.
+  // All variables after 'queue.unassigned' in bump order are assumed to be
+  // assigned.  Then update the 'queue.bumped' field and log it.  This is
+  // inlined here since it occurs in several inner loops.
+  //
+  inline void update_queue_unassigned (int idx) {
+    CADICAL_assert (0 < idx);
+    CADICAL_assert (idx <= max_var);
+    queue.unassigned = idx;
+    queue.bumped = btab[idx];
+    LOG ("queue unassigned now %d bumped %" PRId64 "", idx, btab[idx]);
+  }
+
+  void bump_queue (int idx);
+
+  // Mark (active) variables as eliminated, substituted, pure or fixed,
+  // which turns them into inactive variables.
+  //
+  void mark_eliminated (int);
+  void mark_substituted (int);
+  void mark_active (int);
+  void mark_fixed (int);
+  void mark_pure (int);
+
+  // Managing clauses in 'clause.cpp'.  Without explicit 'Clause' argument
+  // these functions work on the global temporary 'clause'.
+  //
+  Clause *new_clause (bool red, int glue = 0);
+  void promote_clause (Clause *, int new_glue);
+  void promote_clause_glue_only (Clause *, int new_glue);
+  size_t shrink_clause (Clause *, int new_size);
+  void minimize_sort_clause ();
+  void shrink_and_minimize_clause ();
+  void reset_shrinkable ();
+  void mark_shrinkable_as_removable (int, std::vector<int>::size_type);
+  int shrink_literal (int, int, unsigned);
+  unsigned shrunken_block_uip (int, int,
+                               std::vector<int>::reverse_iterator &,
+                               std::vector<int>::reverse_iterator &,
+                               std::vector<int>::size_type, const int);
+  void shrunken_block_no_uip (const std::vector<int>::reverse_iterator &,
+                              const std::vector<int>::reverse_iterator &,
+                              unsigned &, const int);
+  void push_literals_of_block (const std::vector<int>::reverse_iterator &,
+                               const std::vector<int>::reverse_iterator &,
+                               int, unsigned);
+  unsigned shrink_next (int, unsigned &, unsigned &);
+  std::vector<int>::reverse_iterator
+  minimize_and_shrink_block (std::vector<int>::reverse_iterator &,
+                             unsigned int &, unsigned int &, const int);
+  unsigned shrink_block (std::vector<int>::reverse_iterator &,
+                         std::vector<int>::reverse_iterator &, int,
+                         unsigned &, unsigned &, const int, unsigned);
+  unsigned shrink_along_reason (int, int, bool, bool &, unsigned);
+
+  void deallocate_clause (Clause *);
+  void delete_clause (Clause *);
+  void mark_garbage (Clause *);
+  void assign_original_unit (int64_t, int);
+  void add_new_original_clause (int64_t);
+  Clause *new_learned_redundant_clause (int glue);
+  Clause *new_hyper_binary_resolved_clause (bool red, int glue);
+  Clause *new_clause_as (const Clause *orig);
+  Clause *new_resolved_irredundant_clause ();
+
+  // Forward reasoning through propagation in 'propagate.cpp'.
+  //
+  int assignment_level (int lit, Clause *);
+  void build_chain_for_units (int lit, Clause *reason, bool forced);
+  void build_chain_for_empty ();
+  void search_assign (int lit, Clause *);
+  void search_assign_driving (int lit, Clause *reason);
+  void search_assign_external (int lit);
+  void search_assume_decision (int decision);
+  void assign_unit (int lit);
+  int64_t cache_lines (size_t bytes) { return (bytes + 127) / 128; }
+  int64_t cache_lines (size_t n, size_t bytes) {
+    return cache_lines (n * bytes);
+  }
+  bool propagate ();
+
+#ifdef PROFILE_MODE
+  bool propagate_wrapper ();
+  bool propagate_unstable ();
+  bool propagate_stable ();
+  void analyze_wrapper ();
+  void analyze_unstable ();
+  void analyze_stable ();
+  int decide_wrapper ();
+  int decide_stable ();
+  int decide_unstable ();
+#else
+#define propagate_wrapper propagate
+#define analyze_wrapper analyze
+#define decide_wrapper decide
+#endif
+
+  void propergate (); // Repropagate without blocking literals.
+
+  // Undo and restart in 'backtrack.cpp'.
+  //
+  void unassign (int lit);
+  void update_target_and_best ();
+  void backtrack (int target_level = 0);
+  void backtrack_without_updating_phases (int target_level = 0);
+
+  // Minimized learned clauses in 'minimize.cpp'.
+  //
+  bool minimize_literal (int lit, int depth = 0);
+  void minimize_clause ();
+  void calculate_minimize_chain (int lit, std::vector<int> &stack);
+
+  // Learning from conflicts in 'analyze.cc'.
+  //
+  void learn_empty_clause ();
+  void learn_unit_clause (int lit);
+
+  void bump_variable (int lit);
+  void bump_variables ();
+  int recompute_glue (Clause *);
+  void bump_clause (Clause *);
+  void bump_clause2 (Clause *);
+  void clear_unit_analyzed_literals ();
+  void clear_analyzed_literals ();
+  void clear_analyzed_levels ();
+  void clear_minimized_literals ();
+  bool bump_also_reason_literal (int lit);
+  void bump_also_reason_literals (int lit, int depth_limit,
+                                  size_t size_limit);
+  void bump_also_all_reason_literals ();
+  void analyze_literal (int lit, int &open, int &resolvent_size,
+                        int &antecedent_size);
+  void analyze_reason (int lit, Clause *, int &open, int &resolvent_size,
+                       int &antecedent_size);
+  Clause *new_driving_clause (const int glue, int &jump);
+  int find_conflict_level (int &forced);
+  int determine_actual_backtrack_level (int jump);
+  void otfs_strengthen_clause (Clause *, int, int,
+                               const std::vector<int> &);
+  void otfs_subsume_clause (Clause *subsuming, Clause *subsumed);
+  int otfs_find_backtrack_level (int &forced);
+  Clause *on_the_fly_strengthen (Clause *conflict, int lit);
+  void update_decision_rate_average ();
+  void analyze ();
+  void iterate (); // report learned unit clause
+
+  // Learning from external propagator in 'external_propagate.cpp'
+  //
+  bool external_propagate ();
+  bool external_check_solution ();
+  void add_external_clause (int propagated_lit = 0,
+                            bool no_backtrack = false);
+  Clause *learn_external_reason_clause (int lit, int falsified_elit = 0,
+                                        bool no_backtrack = false);
+  Clause *wrapped_learn_external_reason_clause (int lit);
+  void explain_external_propagations ();
+  void explain_reason (int lit, Clause *, int &open);
+  void move_literals_to_watch ();
+  void handle_external_clause (Clause *);
+  void notify_assignments ();
+  void notify_decision ();
+  void notify_backtrack (size_t new_level);
+  void force_backtrack (size_t new_level);
+  int ask_decision ();
+  bool ask_external_clause ();
+  void add_observed_var (int ilit);
+  void remove_observed_var (int ilit);
+  bool observed (int ilit) const;
+  bool is_decision (int ilit);
+  void check_watched_literal_invariants ();
+  void set_tainted_literal ();
+  void renotify_trail_after_ilb ();
+  void renotify_trail_after_local_search ();
+  void renotify_full_trail ();
+  void connect_propagator ();
+  void mark_garbage_external_forgettable (int64_t id);
+  bool is_external_forgettable (int64_t id);
+#ifndef CADICAL_NDEBUG
+  bool get_merged_literals (std::vector<int> &);
+  void get_all_fixed_literals (std::vector<int> &);
+#endif
+
+  void recompute_tier ();
+  // Use last learned clause to subsume some more.
+  //
+  void eagerly_subsume_recently_learned_clauses (Clause *);
+
+  // Restarting policy in 'restart.cc'.
+  //
+  bool stabilizing ();
+  bool restarting ();
+  int reuse_trail ();
+  void restart ();
+
+  // Functions to set and reset certain 'phases'.
+  //
+  void clear_phases (vector<signed char> &); // reset argument to zero
+  void copy_phases (vector<signed char> &);  // copy 'saved' to argument
+
+  // Resetting the saved phased in 'rephase.cpp'.
+  //
+  bool rephasing ();
+  char rephase_best ();
+  char rephase_flipping ();
+  char rephase_inverted ();
+  char rephase_original ();
+  char rephase_random ();
+  char rephase_walk ();
+  void shuffle_scores ();
+  void shuffle_queue ();
+  void rephase ();
+
+  // Lucky feasible case checking.
+  //
+  int unlucky (int res);
+  bool lucky_propagate_discrepency (int);
+  int trivially_false_satisfiable ();
+  int trivially_true_satisfiable ();
+  int forward_false_satisfiable ();
+  int forward_true_satisfiable ();
+  int backward_false_satisfiable ();
+  int backward_true_satisfiable ();
+  int positive_horn_satisfiable ();
+  int negative_horn_satisfiable ();
+
+  // Asynchronous terminating check.
+  //
+  bool terminated_asynchronously (int factor = 1);
+
+  bool search_limits_hit ();
+
+  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
+  // those which are not used as reason anymore with garbage collection.
+  //
+  bool flushing ();
+  bool reducing ();
+  void protect_reasons ();
+  void mark_clauses_to_be_flushed ();
+  void mark_useless_redundant_clauses_as_garbage ();
+  bool propagate_out_of_order_units ();
+  void unprotect_reasons ();
+  void reduce ();
+
+  // Garbage collection in 'collect.cpp' called from 'reduce' and during
+  // inprocessing and preprocessing.
+  //
+  int clause_contains_fixed_literal (Clause *);
+  void remove_falsified_literals (Clause *);
+  void mark_satisfied_clauses_as_garbage ();
+  void copy_clause (Clause *);
+  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 ();
+  void check_var_stats ();
+  bool arenaing ();
+  void garbage_collection ();
+
+  // only remove binary clauses from the watches
+  void remove_garbage_binaries ();
+
+  // Set-up occurrence list counters and containers.
+  //
+  void init_occs ();
+  void init_bins ();
+  void init_noccs ();
+  void clear_noccs ();
+  void clear_occs ();
+  void reset_occs ();
+  void reset_bins ();
+  void reset_noccs ();
+
+  // Operators on watches.
+  //
+  void init_watches ();
+  void connect_watches (bool irredundant_only = false);
+  void connect_binary_watches ();
+  void sort_watches ();
+  void clear_watches ();
+  void reset_watches ();
+
+  // Regular forward subsumption checking in 'subsume.cpp'.
+  //
+  void strengthen_clause (Clause *, int);
+  void subsume_clause (Clause *subsuming, Clause *subsumed);
+  int subsume_check (Clause *subsuming, Clause *subsumed);
+  int try_to_subsume_clause (Clause *, vector<Clause *> &shrunken);
+  void reset_subsume_bits ();
+  bool subsume_round ();
+  void subsume ();
+
+  // Covered clause elimination of large clauses.
+  //
+  void covered_literal_addition (int lit, Coveror &);
+  void asymmetric_literal_addition (int lit, Coveror &);
+  void cover_push_extension (int lit, Coveror &);
+  bool cover_propagate_asymmetric (int lit, Clause *ignore, Coveror &);
+  bool cover_propagate_covered (int lit, Coveror &);
+  bool cover_clause (Clause *c, Coveror &);
+  int64_t cover_round ();
+  bool cover ();
+
+  // Strengthening through vivification in 'vivify.cpp'.
+  //
+  void demote_clause (Clause *);
+  void flush_vivification_schedule (std::vector<Clause *> &, int64_t &);
+  void vivify_increment_stats (const Vivifier &vivifier);
+  void vivify_subsume_clause (Clause *subsuming, Clause *subsumed);
+  void compute_tier_limits (Vivifier &);
+  void vivify_initialize (Vivifier &vivifier, int64_t &ticks);
+  inline void vivify_prioritize_leftovers (char, size_t prioritized,
+                                           std::vector<Clause *> &schedule);
+  bool consider_to_vivify_clause (Clause *candidate);
+  void vivify_sort_watched (Clause *c);
+  bool vivify_instantiate (
+      const std::vector<int> &, Clause *,
+      std::vector<std::tuple<int, Clause *, bool>> &lrat_stack,
+      int64_t &ticks);
+  void vivify_analyze_redundant (Vivifier &, Clause *start, bool &);
+  void vivify_build_lrat (int, Clause *,
+                          std::vector<std::tuple<int, Clause *, bool>> &);
+  void vivify_chain_for_units (int lit, Clause *reason);
+  void vivify_strengthen (Clause *candidate);
+  void vivify_assign (int lit, Clause *);
+  void vivify_assume (int lit);
+  bool vivify_propagate (int64_t &);
+  void vivify_deduce (Clause *candidate, Clause *conflct, int implied,
+                      Clause **, bool &);
+  bool vivify_clause (Vivifier &, Clause *candidate);
+  void vivify_analyze (Clause *start, bool &, Clause **,
+                       const Clause *const, int implied, bool &);
+  bool vivify_shrinkable (const std::vector<int> &sorted, Clause *c);
+  void vivify_round (Vivifier &, int64_t delta);
+  bool vivify ();
+
+  // Compacting (shrinking internal variable tables) in 'compact.cpp'
+  //
+  bool compacting ();
+  void compact ();
+
+  // Transitive reduction of binary implication graph in 'transred.cpp'
+  //
+  void transred ();
+
+  // We monitor the maximum size and glue of clauses during 'reduce' and
+  // thus can predict if a redundant extended clause is likely to be kept in
+  // the next 'reduce' phase.  These clauses are target of subsumption and
+  // vivification checks, in addition to irredundant clauses.  Their
+  // variables are also marked as being 'added'.
+  //
+  bool likely_to_be_kept_clause (Clause *c) {
+    if (!c->redundant)
+      return true;
+    if (c->glue <= tier2[false])
+      return true;
+    if (c->glue > lim.keptglue)
+      return false;
+    if (c->size > lim.keptsize)
+      return false;
+    return true;
+  }
+
+  // We mark variables in added or shrunken clauses as 'subsume' candidates
+  // if the clause is likely to be kept in the next 'reduce' phase (see last
+  // function above).  This gives a persistent (across consecutive
+  // interleaved search and inprocessing phases) set of variables which have
+  // to be reconsidered in subsumption checks, i.e., only clauses with
+  // 'subsume' marked variables are checked to be forward subsumed.
+  // A similar technique is used to reduce the effort in hyper ternary
+  // resolution to focus on variables in new ternary clauses.
+  //
+  void mark_subsume (int lit) {
+    Flags &f = flags (lit);
+    if (f.subsume)
+      return;
+    LOG ("marking %d as subsuming literal candidate", abs (lit));
+    stats.mark.subsume++;
+    f.subsume = true;
+  }
+  void mark_ternary (int lit) {
+    Flags &f = flags (lit);
+    if (f.ternary)
+      return;
+    LOG ("marking %d as ternary resolution literal candidate", abs (lit));
+    stats.mark.ternary++;
+    f.ternary = true;
+  }
+  void mark_factor (int lit) {
+    Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    if (f.factor & bit)
+      return;
+    LOG ("marking %d as factor literal candidate", lit);
+    stats.mark.factor++;
+    f.factor |= bit;
+  }
+  void mark_added (int lit, int size, bool redundant);
+  void mark_added (Clause *);
+
+  bool marked_subsume (int lit) const { return flags (lit).subsume; }
+
+  // If irredundant clauses are removed or literals in clauses are removed,
+  // then variables in such clauses should be reconsidered to be eliminated
+  // through bounded variable elimination.  In contrast to 'subsume' the
+  // 'elim' flag is restricted to 'irredundant' clauses only. For blocked
+  // clause elimination it is better to have a more precise signed version,
+  // which allows to independently mark positive and negative literals.
+  //
+  void mark_elim (int lit) {
+    Flags &f = flags (lit);
+    if (f.elim)
+      return;
+    LOG ("marking %d as elimination literal candidate", lit);
+    stats.mark.elim++;
+    f.elim = true;
+  }
+  void mark_block (int lit) {
+    Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    if (f.block & bit)
+      return;
+    LOG ("marking %d as blocking literal candidate", lit);
+    stats.mark.block++;
+    f.block |= bit;
+  }
+  void mark_removed (int lit) {
+    mark_elim (lit);
+    mark_block (-lit);
+  }
+  void mark_removed (Clause *, int except = 0);
+
+  // The following two functions are only used for testing & debugging.
+
+  bool marked_block (int lit) const {
+    const Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    return (f.block & bit) != 0;
+  }
+  void unmark_block (int lit) {
+    Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    f.block &= ~bit;
+  }
+
+  // During scheduling literals for blocked clause elimination we skip those
+  // literals which occur negated in a too large clause.
+  //
+  void mark_skip (int lit) {
+    Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    if (f.skip & bit)
+      return;
+    LOG ("marking %d to be skipped as blocking literal", lit);
+    f.skip |= bit;
+  }
+  bool marked_skip (int lit) {
+    const Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    return (f.skip & bit) != 0;
+  }
+
+  // During decompose ignore literals where we already built LRAT chains
+  //
+  void mark_decomposed (int lit) {
+    Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    CADICAL_assert ((f.marked_signed & bit) == 0);
+    sign_marked.push_back (lit);
+    f.marked_signed |= bit;
+  }
+  void unmark_decomposed (int lit) {
+    Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    f.marked_signed &= ~bit;
+  }
+  bool marked_decomposed (int lit) {
+    const Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    return (f.marked_signed & bit) != 0;
+  }
+  void clear_sign_marked_literals ();
+
+  // Blocked Clause elimination in 'block.cpp'.
+  //
+  bool is_blocked_clause (Clause *c, int pivot);
+  void block_schedule (Blocker &);
+  size_t block_candidates (Blocker &, int lit);
+  Clause *block_impossible (Blocker &, int lit);
+  void block_literal_with_at_least_two_negative_occs (Blocker &, int lit);
+  void block_literal_with_one_negative_occ (Blocker &, int lit);
+  void block_pure_literal (Blocker &, int lit);
+  void block_reschedule_clause (Blocker &, int lit, Clause *);
+  void block_reschedule (Blocker &, int lit);
+  void block_literal (Blocker &, int lit);
+  bool block ();
+
+  // Find gates in 'gates.cpp' for bounded variable substitution.
+  //
+  int second_literal_in_binary_clause_lrat (Clause *, int first);
+  int second_literal_in_binary_clause (Eliminator &, Clause *, int first);
+  void mark_binary_literals (Eliminator &, int pivot);
+  void find_and_gate (Eliminator &, int pivot);
+  void find_equivalence (Eliminator &, int pivot);
+
+  bool get_ternary_clause (Clause *, int &, int &, int &);
+  bool match_ternary_clause (Clause *, int, int, int);
+  Clause *find_ternary_clause (int, int, int);
+
+  bool get_clause (Clause *, vector<int> &);
+  bool is_clause (Clause *, const vector<int> &);
+  Clause *find_clause (const vector<int> &);
+  void find_xor_gate (Eliminator &, int pivot);
+
+  void find_if_then_else (Eliminator &, int pivot);
+
+  Clause *find_binary_clause (int, int);
+  void find_gate_clauses (Eliminator &, int pivot);
+  void unmark_gate_clauses (Eliminator &);
+
+  // mine definitions for cadical_kitten in 'definition.cpp'
+  //
+  void find_definition (Eliminator &, int);
+  void init_citten ();
+  void reset_citten ();
+  void citten_clear_track_log_terminate ();
+
+  // Bounded variable elimination in 'elim.cpp'.
+  //
+  bool ineliminating ();
+  double compute_elim_score (unsigned lit);
+  void mark_redundant_clauses_with_eliminated_variables_as_garbage ();
+  void unmark_binary_literals (Eliminator &);
+  bool resolve_clauses (Eliminator &, Clause *, int pivot, Clause *, bool);
+  void mark_eliminated_clauses_as_garbage (Eliminator &, int pivot, bool &);
+  bool elim_resolvents_are_bounded (Eliminator &, int pivot);
+  void elim_update_removed_lit (Eliminator &, int lit);
+  void elim_update_removed_clause (Eliminator &, Clause *, int except = 0);
+  void elim_update_added_clause (Eliminator &, Clause *);
+  void elim_add_resolvents (Eliminator &, int pivot);
+  void elim_backward_clause (Eliminator &, Clause *);
+  void elim_backward_clauses (Eliminator &);
+  void elim_propagate (Eliminator &, int unit);
+  void elim_on_the_fly_self_subsumption (Eliminator &, Clause *, int);
+  void try_to_eliminate_variable (Eliminator &, int pivot, bool &);
+  void increase_elimination_bound ();
+  int elim_round (bool &completed, bool &);
+  void elim (bool update_limits = true);
+
+  int64_t flush_elimfast_occs (int lit);
+  void elimfast_add_resolvents (Eliminator &, int pivot);
+  bool elimfast_resolvents_are_bounded (Eliminator &, int pivot);
+  void try_to_fasteliminate_variable (Eliminator &, int pivot, bool &);
+  int elimfast_round (bool &completed, bool &);
+  void elimfast ();
+
+  // sweeping in 'sweep.cpp'
+  int sweep_solve ();
+  void sweep_set_cadical_kitten_ticks_limit (Sweeper &sweeper);
+  bool cadical_kitten_ticks_limit_hit (Sweeper &sweeper, const char *when);
+  void init_sweeper (Sweeper &sweeper);
+  void release_sweeper (Sweeper &sweeper);
+  void clear_sweeper (Sweeper &sweeper);
+  int sweep_repr (Sweeper &sweeper, int lit);
+  void add_literal_to_environment (Sweeper &sweeper, unsigned depth, int);
+  void sweep_clause (Sweeper &sweeper, unsigned depth, Clause *);
+  void sweep_add_clause (Sweeper &sweeper, unsigned depth);
+  void add_core (Sweeper &sweeper, unsigned core_idx);
+  void save_core (Sweeper &sweeper, unsigned core);
+  void clear_core (Sweeper &sweeper, unsigned core_idx);
+  void save_add_clear_core (Sweeper &sweeper);
+  void init_backbone_and_partition (Sweeper &sweeper);
+  void sweep_empty_clause (Sweeper &sweeper);
+  void sweep_refine_partition (Sweeper &sweeper);
+  void sweep_refine_backbone (Sweeper &sweeper);
+  void sweep_refine (Sweeper &sweeper);
+  void flip_backbone_literals (struct Sweeper &sweeper);
+  bool sweep_backbone_candidate (Sweeper &sweeper, int lit);
+  int64_t add_sweep_binary (sweep_proof_clause, int lit, int other);
+  bool scheduled_variable (Sweeper &sweeper, int idx);
+  void schedule_inner (Sweeper &sweeper, int idx);
+  void schedule_outer (Sweeper &sweeper, int idx);
+  int next_scheduled (Sweeper &sweeper);
+  void substitute_connected_clauses (Sweeper &sweeper, int lit, int other,
+                                     int64_t id);
+  void sweep_remove (Sweeper &sweeper, int lit);
+  void flip_partition_literals (struct Sweeper &sweeper);
+  const char *sweep_variable (Sweeper &sweeper, int idx);
+  bool scheduable_variable (Sweeper &sweeper, int idx, size_t *occ_ptr);
+  unsigned schedule_all_other_not_scheduled_yet (Sweeper &sweeper);
+  bool sweep_equivalence_candidates (Sweeper &sweeper, int lit, int other);
+  unsigned reschedule_previously_remaining (Sweeper &sweeper);
+  unsigned incomplete_variables ();
+  void mark_incomplete (Sweeper &sweeper);
+  unsigned schedule_sweeping (Sweeper &sweeper);
+  void unschedule_sweeping (Sweeper &sweeper, unsigned swept,
+                            unsigned scheduled);
+  bool sweep ();
+  void sweep_dense_propagate (Sweeper &sweeper);
+  void sweep_sparse_mode ();
+  void sweep_dense_mode_and_watch_irredundant ();
+  void sweep_substitute_lrat (Clause *c, int64_t id);
+  void sweep_substitute_new_equivalences (Sweeper &sweeper);
+  void sweep_update_noccs (Clause *c);
+  void delete_sweep_binary (const sweep_binary &sb);
+  bool can_sweep_clause (Clause *c);
+  bool sweep_flip (int);
+  int sweep_flip_and_implicant (int);
+  bool sweep_extract_fixed (Sweeper &sweeper, int lit);
+
+  // factor
+  void factor_mode ();
+  void reset_factor_mode ();
+  double tied_next_factor_score (int);
+  Quotient *new_quotient (Factoring &, int);
+  void release_quotients (Factoring &);
+  size_t first_factor (Factoring &, int);
+  void clear_nounted (vector<int> &);
+  void clear_flauses (vector<Clause *> &);
+  Quotient *best_quotient (Factoring &, size_t *);
+  int next_factor (Factoring &, unsigned *);
+  void factorize_next (Factoring &, int, unsigned);
+  void resize_factoring (Factoring &factoring, int lit);
+  void flush_unmatched_clauses (Quotient *);
+  void add_self_subsuming_factor (Quotient *, Quotient *);
+  bool self_subsuming_factor (Quotient *);
+  void add_factored_divider (Quotient *, int);
+  void blocked_clause (Quotient *q, int);
+  void add_factored_quotient (Quotient *, int not_fresh);
+  void eagerly_remove_from_occurences (Clause *c);
+  void delete_unfactored (Quotient *q);
+  void update_factored (Factoring &factoring, Quotient *q);
+  bool apply_factoring (Factoring &factoring, Quotient *q);
+  void update_factor_candidate (Factoring &, int);
+  void schedule_factorization (Factoring &);
+  bool run_factorization (int64_t limit);
+  bool factor ();
+  int get_new_extension_variable ();
+  Clause *new_factor_clause ();
+
+  // instantiate
+  //
+  void inst_assign (int lit);
+  bool inst_propagate ();
+  void collect_instantiation_candidates (Instantiator &);
+  bool instantiate_candidate (int lit, Clause *);
+  void instantiate (Instantiator &);
+
+  void new_trail_level (int lit);
+
+  // Hyper ternary resolution.
+  //
+  bool ternary_find_binary_clause (int, int);
+  bool ternary_find_ternary_clause (int, int, int);
+  Clause *new_hyper_ternary_resolved_clause (bool red);
+  Clause *new_hyper_ternary_resolved_clause_and_watch (bool red, bool);
+  bool hyper_ternary_resolve (Clause *, int, Clause *);
+  void ternary_lit (int pivot, int64_t &steps, int64_t &htrs);
+  void ternary_idx (int idx, int64_t &steps, int64_t &htrs);
+  bool ternary_round (int64_t &steps, int64_t &htrs);
+  bool ternary ();
+
+  // Probing in 'probe.cpp'.
+  //
+  bool inprobing ();
+  void failed_literal (int lit);
+  void probe_lrat_for_units (int lit);
+  void probe_assign_unit (int lit);
+  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);
+  void clean_probehbr_lrat ();
+  void init_probehbr_lrat ();
+  void get_probehbr_lrat (int lit, int uip);
+  void set_probehbr_lrat (int lit, int uip);
+  void probe_post_dominator_lrat (vector<Clause *> &, int, int);
+  void probe_dominator_lrat (int dom, Clause *reason);
+  int probe_dominator (int a, int b);
+  int hyper_binary_resolve (Clause *);
+  void probe_propagate2 ();
+  bool probe_propagate ();
+  bool is_binary_clause (Clause *c, int &, int &);
+  void generate_probes ();
+  void flush_probes ();
+  int next_probe ();
+  bool probe ();
+  void inprobe (bool update_limits = true);
+
+  // ProbSAT/WalkSAT implementation called initially or from 'rephase'.
+  //
+  void walk_save_minimum (Walker &);
+  Clause *walk_pick_clause (Walker &);
+  unsigned walk_break_value (int lit);
+  int walk_pick_lit (Walker &, Clause *);
+  void walk_flip_lit (Walker &, int lit);
+  int walk_round (int64_t limit, bool prev);
+  void walk ();
+
+  // Detect strongly connected components in the binary implication graph
+  // (BIG) and equivalent literal substitution (ELS) in 'decompose.cpp'.
+  //
+  void decompose_conflicting_scc_lrat (DFS *dfs, vector<int> &);
+  void build_lrat_for_clause (const vector<vector<Clause *>> &dfs_chains,
+                              bool invert = false);
+  vector<Clause *> decompose_analyze_binary_clauses (DFS *dfs, int from);
+  void decompose_analyze_binary_chain (DFS *dfs, int);
+  bool decompose_round ();
+  void decompose ();
+
+  void reset_limits (); // Reset after 'solve' call.
+
+  // Try flipping a literal while not falsifying a model.
+
+  bool flip (int lit);
+  bool flippable (int lit);
+
+  // Assumption handling.
+  //
+  void assume_analyze_literal (int lit);
+  void assume_analyze_reason (int lit, Clause *reason);
+  void assume (int);                  // New assumption literal.
+  bool failed (int lit);              // Literal failed assumption?
+  void reset_assumptions ();          // Reset after 'solve' call.
+  void sort_and_reuse_assumptions (); // reorder the assumptions in order to
+                                      // reuse parts of the trail
+  void failing ();                    // Prepare failed assumptions.
+
+  bool assumed (int lit) { // Marked as assumption.
+    Flags &f = flags (lit);
+    const unsigned bit = bign (lit);
+    return (f.assumed & bit) != 0;
+  }
+
+  // Add temporary clause as constraint.
+  //
+  void constrain (int); // Add literal to constraint.
+  bool
+  failed_constraint ();     // Was constraint used to proof unsatisfiablity?
+  void reset_constraint (); // Reset after 'solve' call.
+
+  // Propagate the current set of assumptions and return the
+  // non-witness assigned literals
+  int propagate_assumptions ();
+  void implied (std::vector<int> &entrailed);
+
+  // 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;
+  bool is_conditional_literal (int lit) const;
+  void mark_as_conditional_literal (int lit);
+  void unmark_as_conditional_literal (int lit);
+  //
+  bool is_in_candidate_clause (int lit) const;
+  void mark_in_candidate_clause (int lit);
+  void unmark_in_candidate_clause (int lit);
+  //
+  void condition_assign (int lit);
+  void condition_unassign (int lit);
+  //
+  bool conditioning ();
+  long condition_round (long unassigned_literal_propagation_limit);
+  void condition (bool update_limits = true);
+
+  // Part on picking the next decision in 'decide.cpp'.
+  //
+  bool satisfied ();
+  int next_decision_variable_on_queue ();
+  int next_decision_variable_with_best_score ();
+  int next_decision_variable ();
+  int decide_phase (int idx, bool target);
+  int likely_phase (int idx);
+  bool better_decision (int lit, int other);
+  int decide (); // 0=decision, 20=failed
+
+  // 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.
+  void limit_local_search (int);  // Enable 'n' local search rounds.
+
+  // External versions can access limits by 'name'.
+  //
+  static bool is_valid_limit (const char *name);
+  bool limit (const char *name, int); // 'true' if 'name' valid
+
+  // Set all the CDCL search limits and increments for scheduling
+  // inprocessing, restarts, clause database reductions, etc.
+  //
+  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'
+  // averages, which are used to schedule (prohibit actually) restarts
+  // during 'unstable' phases ('stable' phases use reluctant doubling).
+  //
+  void init_averages ();
+  void swap_averages ();
+
+  int try_to_satisfy_formula_by_saved_phases ();
+  void produce_failed_assumptions ();
+
+  // 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 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::simplify' only preprocessing is called
+  // though. This is all orchestrated by the 'solve' function.
+  //
+  int already_solved ();
+  int restore_clauses ();
+  bool preprocess_round (int round);
+  void preprocess_quickly ();
+  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);
+  void finalize (int);
+
+  //
+  int lookahead ();
+  CubesWithStatus generate_cubes (int, int);
+  int most_occurring_literal ();
+  int lookahead_probing ();
+  int lookahead_next_probe ();
+  void lookahead_flush_probes ();
+  void lookahead_generate_probes ();
+  std::vector<int> lookahead_populate_locc ();
+  int lookahead_locc (const std::vector<int> &);
+
+  bool terminating_asked ();
+
+#ifndef CADICAL_QUIET
+  // Built in profiling in 'profile.cpp' (see also 'profile.hpp').
+  //
+  void start_profiling (Profile &p, double);
+  void stop_profiling (Profile &p, double);
+
+  double update_profiles (); // Returns 'time ()'.
+  void print_profile ();
+#endif
+
+  // Get the value of an internal literal: -1=false, 0=unassigned, 1=true.
+  // We use a redundant table for both negative and positive literals.  This
+  // allows a branch-less check for the value of literal and is considered
+  // substantially faster than negating the result if the argument is
+  // negative.  We also avoid taking the absolute value.
+  //
+  signed char val (int lit) const {
+    CADICAL_assert (-max_var <= lit);
+    CADICAL_assert (lit);
+    CADICAL_assert (lit <= max_var);
+    return vals[lit];
+  }
+
+  // As suggested by Matt Ginsberg it might be useful to factor-out a common
+  // setter function for setting and resetting the value of a literal.
+  //
+  void set_val (int lit, signed char val) {
+    CADICAL_assert (-1 <= val);
+    CADICAL_assert (val <= 1);
+    CADICAL_assert (-max_var <= lit);
+    CADICAL_assert (lit);
+    CADICAL_assert (lit <= max_var);
+    vals[lit] = val;
+    vals[-lit] = -val;
+  }
+
+  // As 'val' but restricted to the root-level value of a literal.
+  // It is not that time critical and also needs to check the decision level
+  // of the variable anyhow.
+  //
+  int fixed (int lit) {
+    CADICAL_assert (-max_var <= lit);
+    CADICAL_assert (lit);
+    CADICAL_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;
+  }
+
+  // Map back an internal literal to an external.
+  //
+  int externalize (int lit) {
+    CADICAL_assert (lit != INT_MIN);
+    const int idx = abs (lit);
+    CADICAL_assert (idx);
+    CADICAL_assert (idx <= max_var);
+    int res = i2e[idx];
+    if (lit < 0)
+      res = -res;
+    return res;
+  }
+
+  // Explicit freezing and melting of variables.
+  //
+  void freeze (int lit) {
+    int idx = vidx (lit);
+    if ((size_t) idx >= frozentab.size ()) {
+      size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) max_var;
+      while (new_vsize <= (size_t) max_var)
+        new_vsize *= 2;
+      frozentab.resize (new_vsize);
+    }
+    unsigned &ref = frozentab[idx];
+    if (ref < UINT_MAX) {
+      ref++;
+      LOG ("variable %d frozen %u times", idx, ref);
+    } else
+      LOG ("variable %d remains frozen forever", idx);
+  }
+  void melt (int lit) {
+    int idx = vidx (lit);
+    unsigned &ref = frozentab[idx];
+    if (ref < UINT_MAX) {
+      if (!--ref) {
+        if (relevanttab[idx]) {
+          LOG ("variable %d is observed, can not be completely molten",
+               idx);
+          ref++;
+        } else
+          LOG ("variable %d completely molten", idx);
+      } else
+        LOG ("variable %d melted once but remains frozen %u times", lit,
+             ref);
+    } else
+      LOG ("variable %d remains frozen forever", idx);
+  }
+  bool frozen (int lit) {
+    return (size_t) vidx (lit) < frozentab.size () &&
+           frozentab[vidx (lit)] > 0;
+  }
+
+  // Congruence closure
+  bool extract_gates ();
+
+  // Parsing functions in 'parse.cpp'.
+  //
+  const char *parse_dimacs (FILE *);
+  const char *parse_dimacs (const char *);
+  const char *parse_solution (const char *);
+
+  // Enable and disable proof logging and checking.
+  //
+  void new_proof_on_demand ();
+  void force_lrat ();                    // sets lrat=true
+  void resize_unit_clauses_idx ();       // resizes unit_clauses_idx
+  void close_trace (bool stats = false); // Stop proof tracing.
+  void flush_trace (bool stats = false); // Flush proof trace file.
+  void trace (File *);                   // Start write proof file.
+  void check ();                         // Enable online proof checking.
+
+  void connect_proof_tracer (Tracer *tracer, bool antecedents,
+                             bool finalize_clauses = false);
+  void connect_proof_tracer (InternalTracer *tracer, bool antecedents,
+                             bool finalize_clauses = false);
+  void connect_proof_tracer (StatTracer *tracer, bool antecedents,
+                             bool finalize_clauses = false);
+  void connect_proof_tracer (FileTracer *tracer, bool antecedents,
+                             bool finalize_clauses = false);
+  bool disconnect_proof_tracer (Tracer *tracer);
+  bool disconnect_proof_tracer (StatTracer *tracer);
+  bool disconnect_proof_tracer (FileTracer *tracer);
+  void conclude_unsat ();
+  void reset_concluded ();
+
+  // Dump to '<stdout>' as DIMACS for debugging.
+  //
+  void dump (Clause *);
+  void dump ();
+
+  // Export and traverse all irredundant (non-unit) clauses.
+  //
+  bool traverse_clauses (ClauseIterator &);
+
+  // Export and traverse all irredundant (non-unit) clauses.
+  //
+  bool traverse_constraint (ClauseIterator &);
+
+  /*----------------------------------------------------------------------*/
+
+  double solve_time (); // accumulated time spent in 'solve ()'
+
+  double process_time () const; // since solver was initialized
+  double real_time () const;    // since solver was initialized
+
+  double time () { return opts.realtime ? real_time () : process_time (); }
+
+  // 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 ();
+
+  /*----------------------------------------------------------------------*/
+
+#ifndef CADICAL_QUIET
+
+  void print_prefix ();
+
+  // Non-verbose messages and warnings, i.e., always printed unless 'quiet'
+  // is set, which disables messages at run-time, or even 'CADICAL_QUIET' is defined
+  // through the configuration option './configure --quiet', which disables
+  // such messages completely at compile-time.
+  //
+  void vmessage (const char *, va_list &);
+  void message (const char *, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  void message (); // empty line
+
+  // Verbose messages with explicit verbose 'level' controlled by
+  // 'opts.verbose' (verbose level '0' gives the same as 'message').
+  //
+  void vverbose (int level, const char *fmt, va_list &);
+  void verbose (int level, const char *fmt, ...)
+      CADICAL_ATTRIBUTE_FORMAT (3, 4);
+  void verbose (int level);
+
+  // This is for printing section headers in the form
+  //
+  //  c ---- [ <title> ] ---------------------
+  //
+  // nicely aligned (and of course is ignored if 'quiet' is set).
+  //
+  void section (const char *title);
+
+  // Print verbose message about phases if 'opts.verbose > 1' (but not if
+  // 'quiet' is set).  Note that setting 'log' or '-l' forces all verbose
+  // output (and also ignores 'quiet' set to true').  The 'phase' argument
+  // is used to print a 'phase' prefix for the message as follows:
+  //
+  //  c [<phase>] ...
+  //
+  void phase (const char *phase, const char *, ...)
+      CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+  // Same as the last 'phase' above except that the prefix gets a count:
+  //
+  //  c [<phase>-<count>] ...
+  //
+  void phase (const char *phase, int64_t count, const char *, ...)
+      CADICAL_ATTRIBUTE_FORMAT (4, 5);
+#endif
+
+  // Print error messages which are really always printed (even if 'quiet'
+  // is set).  This leads to exit the current process with exit status '1'.
+  //
+  // TODO add possibility to use a call back instead of calling exit.
+  //
+  void error_message_end ();
+  void verror (const char *, va_list &);
+  void error (const char *, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  void error_message_start ();
+
+  // Warning messages.
+  //
+  void warning (const char *, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
+};
+
+// Fatal internal error which leads to abort.
+//
+void fatal_message_start ();
+void fatal_message_end ();
+void fatal (const char *, ...) CADICAL_ATTRIBUTE_FORMAT (1, 2);
+
+/*------------------------------------------------------------------------*/
+
+// Has to be put here, i.e., not into 'score.hpp', since we need the
+// definition of 'Internal::score' above (after '#include "score.hpp"').
+
+inline bool score_smaller::operator() (unsigned a, unsigned b) {
+
+  // Avoid computing twice 'abs' in 'score ()'.
+  //
+  CADICAL_assert (1 <= a);
+  CADICAL_assert (a <= (unsigned) internal->max_var);
+  CADICAL_assert (1 <= b);
+  CADICAL_assert (b <= (unsigned) internal->max_var);
+  double s = internal->stab[a];
+  double t = internal->stab[b];
+
+  if (s < t)
+    return true;
+  if (s > t)
+    return false;
+
+  return a > b;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Implemented here for keeping it all inline (requires Internal::fixed).
+
+inline int External::fixed (int elit) const {
+  CADICAL_assert (elit);
+  CADICAL_assert (elit != INT_MIN);
+  int eidx = abs (elit);
+  if (eidx > max_var)
+    return 0;
+  int ilit = e2i[eidx];
+  if (!ilit)
+    return 0;
+  if (elit < 0)
+    ilit = -ilit;
+  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) {
+    CADICAL_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 %d",
+         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--) {
+    CADICAL_assert (factor > 0);
+    CADICAL_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 () {
+  CADICAL_assert (!preprocessing);
+  CADICAL_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;
+}
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/inttypes.hpp b/src/sat/cadical/inttypes.hpp
new file mode 100644
index 000000000..2f7cb74a4
--- /dev/null
+++ b/src/sat/cadical/inttypes.hpp
@@ -0,0 +1,30 @@
+#ifndef _inttypes_h_INCLUDED
+#define _inttypes_h_INCLUDED
+
+#include "global.h"
+
+// This is an essence a wrapper around '<cinttypes>' respectively
+// 'inttypes.h' in order to please the 'MinGW' cross-compiler (we are using
+// 'i686-w64-mingw32-gcc') to produce correct 'printf' style formatting for
+// 64-bit numbers as this does not work out-of-the-box (which is also very
+// annoying).  This also produces lots of warnings (through '-Wformat' and
+// the corresponding 'attribute' declaration for 'printf' style functions).
+// Again 'MinGW' is not fully standard compliant here and we have to cover
+// up for that manually.
+
+// We repeat the code on making this work which is also contained in
+// 'cadical.hpp' as we do not want to require users of the library to
+// include another header file (like this one) beside 'cadical.hpp'.
+
+#ifndef PRINTF_FORMAT
+#ifdef __MINGW32__
+#define __USE_MINGW_ANSI_STDIO 1
+#define PRINTF_FORMAT __MINGW_PRINTF_FORMAT
+#else
+#define PRINTF_FORMAT printf
+#endif
+#endif
+
+#include <cinttypes>
+
+#endif
diff --git a/src/sat/cadical/ipasir.h b/src/sat/cadical/ipasir.h
new file mode 100644
index 000000000..ccb610130
--- /dev/null
+++ b/src/sat/cadical/ipasir.h
@@ -0,0 +1,35 @@
+#ifndef _ipasir_h_INCLUDED
+#define _ipasir_h_INCLUDED
+
+#include "global.h"
+
+/*------------------------------------------------------------------------*/
+ABC_NAMESPACE_HEADER_START
+/*------------------------------------------------------------------------*/
+
+// Here are the declarations for the actual IPASIR functions, which is the
+// generic incremental reentrant SAT solver API used for instance in the SAT
+// competition.  The other 'C' API in 'ccadical.h' is (more) type safe and
+// has additional functions only supported by the CaDiCaL library.  Please
+// also refer to our SAT Race 2015 article in the Journal of AI from 2016.
+
+const char *ipasir_signature (void);
+void *ipasir_init (void);
+void ipasir_release (void *solver);
+void ipasir_add (void *solver, int lit);
+void ipasir_assume (void *solver, int lit);
+int ipasir_solve (void *solver);
+int ipasir_val (void *solver, int lit);
+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));
+
+/*------------------------------------------------------------------------*/
+ABC_NAMESPACE_HEADER_END
+/*------------------------------------------------------------------------*/
+
+#endif
diff --git a/src/sat/cadical/kitten.h b/src/sat/cadical/kitten.h
new file mode 100644
index 000000000..c70d47b0d
--- /dev/null
+++ b/src/sat/cadical/kitten.h
@@ -0,0 +1,95 @@
+#ifndef _cadical_kitten_h_INCLUDED
+#define _cadical_kitten_h_INCLUDED
+
+#include "global.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+ABC_NAMESPACE_HEADER_START
+
+typedef struct cadical_kitten cadical_kitten;
+
+cadical_kitten *cadical_kitten_init (void);
+void cadical_kitten_clear (cadical_kitten *);
+void cadical_kitten_release (cadical_kitten *);
+
+#ifdef LOGGING
+void cadical_kitten_set_logging (cadical_kitten *cadical_kitten);
+#endif
+
+void cadical_kitten_track_antecedents (cadical_kitten *);
+
+void cadical_kitten_shuffle_clauses (cadical_kitten *);
+void cadical_kitten_flip_phases (cadical_kitten *);
+void cadical_kitten_randomize_phases (cadical_kitten *);
+
+void cadical_kitten_assume (cadical_kitten *, unsigned lit);
+void cadical_kitten_assume_signed (cadical_kitten *, int lit);
+
+void cadical_kitten_clause (cadical_kitten *, size_t size, unsigned *);
+void citten_clause_with_id (cadical_kitten *, unsigned id, size_t size, int *);
+void cadical_kitten_unit (cadical_kitten *, unsigned);
+void cadical_kitten_binary (cadical_kitten *, unsigned, unsigned);
+
+void cadical_kitten_clause_with_id_and_exception (cadical_kitten *, unsigned id,
+                                          size_t size, const unsigned *,
+                                          unsigned except);
+
+void citten_clause_with_id_and_exception (cadical_kitten *, unsigned id,
+                                          size_t size, const int *,
+                                          unsigned except);
+void citten_clause_with_id_and_equivalence (cadical_kitten *, unsigned id,
+                                            size_t size, const int *,
+                                            unsigned, unsigned);
+void cadical_kitten_no_ticks_limit (cadical_kitten *);
+void cadical_kitten_set_ticks_limit (cadical_kitten *, uint64_t);
+uint64_t cadical_kitten_current_ticks (cadical_kitten *);
+
+void cadical_kitten_no_terminator (cadical_kitten *);
+void cadical_kitten_set_terminator (cadical_kitten *, void *, int (*) (void *));
+
+int cadical_kitten_solve (cadical_kitten *);
+int cadical_kitten_status (cadical_kitten *);
+
+signed char cadical_kitten_value (cadical_kitten *, unsigned);
+signed char cadical_kitten_signed_value (cadical_kitten *, int); // converts second argument
+signed char cadical_kitten_fixed (cadical_kitten *, unsigned);
+signed char cadical_kitten_fixed_signed (cadical_kitten *, int); // converts
+bool cadical_kitten_failed (cadical_kitten *, unsigned);
+bool cadical_kitten_flip_literal (cadical_kitten *, unsigned);
+bool cadical_kitten_flip_signed_literal (cadical_kitten *, int);
+
+unsigned cadical_kitten_compute_clausal_core (cadical_kitten *, uint64_t *learned);
+void cadical_kitten_shrink_to_clausal_core (cadical_kitten *);
+
+void cadical_kitten_traverse_core_ids (cadical_kitten *, void *state,
+                               void (*traverse) (void *state, unsigned id));
+
+void cadical_kitten_traverse_core_clauses (cadical_kitten *, void *state,
+                                   void (*traverse) (void *state,
+                                                     bool learned, size_t,
+                                                     const unsigned *));
+void cadical_kitten_traverse_core_clauses_with_id (
+    cadical_kitten *, void *state,
+    void (*traverse) (void *state, unsigned, bool learned, size_t,
+                      const unsigned *));
+void cadical_kitten_trace_core (cadical_kitten *, void *state,
+                        void (*trace) (void *, unsigned, unsigned, bool,
+                                       size_t, const unsigned *, size_t,
+                                       const unsigned *));
+
+int cadical_kitten_compute_prime_implicant (cadical_kitten *cadical_kitten, void *state,
+                                    bool (*ignore) (void *, unsigned));
+
+void cadical_kitten_add_prime_implicant (cadical_kitten *cadical_kitten, void *state, int side,
+                                 void (*add_implicant) (void *, int, size_t,
+                                                        const unsigned *));
+
+int cadical_kitten_flip_and_implicant_for_signed_literal (cadical_kitten *cadical_kitten, int elit);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/level.hpp b/src/sat/cadical/level.hpp
new file mode 100644
index 000000000..bbfe774ff
--- /dev/null
+++ b/src/sat/cadical/level.hpp
@@ -0,0 +1,39 @@
+#ifndef _level_hpp_INCLUDED
+#define _level_hpp_INCLUDED
+
+#include "global.h"
+
+#include <climits>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// For each new decision we increase the decision level and push a 'Level'
+// on the 'control' stack.  The information gathered here is used in
+// 'reuse_trail' and for early aborts in clause minimization.
+
+struct Level {
+
+  int decision; // decision literal of this level
+  int trail;    // trail start of this level
+
+  struct {
+    int count; // how many variables seen during 'analyze'
+    int trail; // smallest trail position seen on this level
+  } seen;
+
+  void reset () {
+    seen.count = 0;
+    seen.trail = INT_MAX;
+  }
+
+  Level (int d, int t) : decision (d), trail (t) { reset (); }
+  Level () {}
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/lidruptracer.hpp b/src/sat/cadical/lidruptracer.hpp
new file mode 100644
index 000000000..02cd33fcd
--- /dev/null
+++ b/src/sat/cadical/lidruptracer.hpp
@@ -0,0 +1,123 @@
+#ifndef _lidruptracer_h_INCLUDED
+#define _lidruptracer_h_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+class FileTracer;
+
+namespace CaDiCaL {
+
+struct LidrupClause {
+  LidrupClause *next; // collision chain link for hash table
+  uint64_t hash;      // previously computed full 64-bit hash
+  int64_t id;         // id of clause
+  std::vector<int64_t> chain;
+  std::vector<int> literals;
+};
+
+class LidrupTracer : public FileTracer {
+
+  Internal *internal;
+  File *file;
+  bool binary;
+  bool piping; // The 'file' is a pipe and needs eagerly flushing.
+
+  // hash table for conclusion
+  //
+  uint64_t num_clauses;   // number of clauses in hash table
+  uint64_t size_clauses;  // size of clause hash table
+  LidrupClause **clauses; // hash table of clauses
+  vector<int> imported_clause;
+  vector<int> assumptions;
+  vector<int64_t> imported_chain;
+  vector<int64_t> batch_weaken;
+  vector<int64_t> batch_delete;
+  vector<int64_t> batch_restore;
+
+  static const unsigned num_nonces = 4;
+
+  uint64_t nonces[num_nonces]; // random numbers for hashing
+  uint64_t last_hash;          // last computed hash value of clause
+  int64_t last_id;             // id of the last added clause
+  LidrupClause *last_clause;
+  uint64_t compute_hash (int64_t); // compute and save hash value of clause
+
+  LidrupClause *new_clause ();
+  void delete_clause (LidrupClause *);
+
+  static uint64_t reduce_hash (uint64_t hash, uint64_t size);
+
+  void enlarge_clauses (); // enlarge hash table for clauses
+  void insert ();          // insert clause in hash table
+  bool
+  find_and_delete (const int64_t); // find clause position in hash table
+
+#ifndef CADICAL_QUIET
+  int64_t added, deleted, weakened, restore, original, solved, batched;
+#endif
+
+  void flush_if_piping ();
+
+  void put_binary_zero ();
+  void put_binary_lit (int external_lit);
+  void put_binary_id (int64_t id, bool = true);
+
+  void lidrup_add_derived_clause (int64_t id, const vector<int> &clause,
+                                  const vector<int64_t> &chain);
+  void lidrup_delete_clause (int64_t id); //, const vector<int> &clause);
+  void
+  lidrup_add_restored_clause (int64_t id); //, const vector<int> &clause);
+  void lidrup_add_original_clause (int64_t id, const vector<int> &clause);
+  void lidrup_conclude_and_delete (const vector<int64_t> &conclusion);
+  void lidrup_report_status (int status);
+  void lidrup_conclude_sat (const vector<int> &model);
+  void lidrup_conclude_unknown (const vector<int> &trail);
+  void lidrup_solve_query ();
+  void lidrup_batch_weaken_restore_and_delete ();
+
+public:
+  LidrupTracer (Internal *, File *file, bool);
+  ~LidrupTracer ();
+
+  // proof section:
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &) override;
+  void add_assumption_clause (int64_t, const vector<int> &,
+                              const vector<int64_t> &) override;
+  void weaken_minus (int64_t, const vector<int> &) override;
+  void delete_clause (int64_t, bool, const vector<int> &) override;
+  void add_original_clause (int64_t, bool, const vector<int> &,
+                            bool = false) override;
+  void report_status (int, int64_t) override;
+  void conclude_sat (const vector<int> &) override;
+  void conclude_unsat (ConclusionType, const vector<int64_t> &) override;
+  void conclude_unknown (const vector<int> &) override;
+
+  void solve_query () override;
+  void add_assumption (int) override;
+  void reset_assumptions () override;
+
+  // skip
+  void begin_proof (int64_t) override {}
+  void finalize_clause (int64_t, const vector<int> &) override {}
+  void strengthen (int64_t) override {}
+  void add_constraint (const vector<int> &) override {}
+
+  // logging and file io
+  void connect_internal (Internal *i) override;
+
+#ifndef CADICAL_QUIET
+  void print_statistics ();
+#endif
+  bool closed () override;
+  void close (bool) override;
+  void flush (bool) override;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/limit.hpp b/src/sat/cadical/limit.hpp
new file mode 100644
index 000000000..0f6923214
--- /dev/null
+++ b/src/sat/cadical/limit.hpp
@@ -0,0 +1,162 @@
+#ifndef _limit_hpp_INCLUDED
+#define _limit_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdint>
+#include <limits>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct Limit {
+
+  bool initialized;
+
+  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
+
+  int64_t compact;   // conflict limit for next 'compact'
+  int64_t condition; // conflict limit for next 'condition'
+  int64_t elim;      // conflict limit for next 'elim'
+  int64_t flush;     // conflict limit for next 'flush'
+  int64_t inprobe;   // conflict limit for next 'inprobe'
+  int64_t reduce;    // conflict limit for next 'reduce'
+  int64_t rephase;   // conflict limit for next 'rephase'
+  int64_t report;    // report limit for header
+  int64_t restart;   // conflict limit for next 'restart'
+  int64_t stabilize; // conflict/ticks limit for next 'stabilize'
+
+  int keptsize;           // maximum kept size in 'reduce'
+  int keptglue;           // maximum kept glue in 'reduce'
+  int64_t recompute_tier; // conflict limit for next tier recomputation
+
+  // How often rephased during (1) or out (0) of stabilization.
+  //
+  int64_t rephased[2];
+
+  // Current elimination bound per eliminated variable.
+  //
+  int64_t elimbound;
+
+  struct {
+    int check;  // countdown to next terminator call
+    int forced; // forced termination for testing
+  } terminate;
+
+  Limit ();
+};
+
+struct Delay {
+  struct {
+    int64_t interval = 0, limit = 0;
+    bool bypass = 0;
+
+    bool delay () {
+      if (bypass)
+        return true;
+      if (limit) {
+        --limit;
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+    void bump_delay () {
+      interval += interval < INT64_MAX;
+      limit = interval;
+    }
+
+    void reduce_delay () {
+      if (!interval)
+        return;
+      interval /= 2;
+      limit = interval;
+    }
+
+    void bypass_delay () { bypass = 1; }
+    void unbypass_delay () { bypass = 0; }
+  } bumpreasons;
+};
+
+struct Last {
+  struct {
+    int64_t propagations;
+  } transred;
+  struct {
+    int64_t ticks;
+  } sweep, vivify, probe;
+  struct {
+    int64_t fixed, subsumephases, marked;
+  } elim;
+  struct {
+    int64_t reductions;
+  } inprobe;
+  struct {
+    int64_t conflicts;
+  } reduce, rephase;
+  struct {
+    int64_t ticks;
+    int64_t marked;
+  } ternary;
+  struct {
+    int64_t fixed;
+  } collect;
+  struct {
+    int64_t marked, ticks;
+  } factor;
+  struct {
+    int64_t conflicts;
+    int64_t ticks;
+  } stabilize;
+  Last ();
+};
+
+struct Inc {
+  int64_t flush;         // flushing interval in terms of conflicts
+  int64_t stabilize;     // base ticks limit after first mode switch
+  int64_t conflicts;     // next conflict limit if non-negative
+  int64_t decisions;     // next decision limit if non-negative
+  int64_t preprocessing; // next preprocessing limit if non-negative
+  int64_t localsearch;   // next local search limit if non-negative
+  Inc ();
+};
+
+#define SET_EFFORT_LIMIT(LIMIT, NAME, THRESHHOLD) \
+  int64_t LIMIT; \
+  do { \
+    const int64_t OLD_LIMIT = stats.ticks.NAME; \
+    const int64_t TICKS = stats.ticks.search[0] + stats.ticks.search[1]; \
+    const int64_t LAST = last.NAME.ticks; \
+    int64_t REFERENCE = TICKS - LAST; \
+    if (!REFERENCE || !stats.conflicts) { \
+      VERBOSE (2, "last %" PRId64 " current %" PRId64 " delta %" PRId64, \
+               LAST, TICKS, REFERENCE); \
+      REFERENCE = opts.preprocessinit; \
+    } \
+    const double EFFORT = (double) opts.NAME##effort * 1e-3; \
+    const int64_t DELTA = EFFORT * REFERENCE; \
+    const int64_t THRESH = opts.NAME##thresh * clauses.size (); \
+    if (THRESHHOLD && DELTA < THRESH) { \
+      VERBOSE (2, \
+               "delaying %s with ticklimit %" PRId64 \
+               " and threshhold %" PRId64, \
+               #NAME, DELTA, THRESH); \
+      return false; \
+    } \
+    last.NAME.ticks = TICKS; \
+    const int64_t NEW_LIMIT = OLD_LIMIT + DELTA; \
+    LIMIT = NEW_LIMIT; \
+  } while (0)
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/logging.hpp b/src/sat/cadical/logging.hpp
new file mode 100644
index 000000000..edbd60f8c
--- /dev/null
+++ b/src/sat/cadical/logging.hpp
@@ -0,0 +1,104 @@
+#ifndef _logging_hpp_INCLUDED
+#define _logging_hpp_INCLUDED
+
+#include "global.h"
+
+/*------------------------------------------------------------------------*/
+#ifdef LOGGING
+/*------------------------------------------------------------------------*/
+
+#include <cstdint>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// For debugging purposes and to help understanding what the solver is doing
+// there is a logging facility which is compiled in by './configure -l'.  It
+// still has to be enabled at run-time though (again using the '-l' option
+// in the stand-alone solver).  It produces quite a bit of information.
+
+using namespace std;
+
+struct Clause;
+struct Gate;
+struct Internal;
+
+struct Logger {
+
+  static void print_log_prefix (Internal *);
+
+  // Simple logging of a C-style format string.
+  //
+  static void log (Internal *, const char *fmt, ...)
+      CADICAL_ATTRIBUTE_FORMAT (2, 3);
+
+  // Prints the format string (with its argument) and then the clause.  The
+  // clause can also be a zero pointer and then is interpreted as a decision
+  // (current decision level > 0) or unit clause (zero decision level) and
+  // printed accordingly.
+  //
+  static void log (Internal *, const Clause *, const char *fmt, ...)
+      CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+  // Same as before, except that this is meant for the global 'clause' stack
+  // used for new clauses (and not for reasons).
+  //
+  static void log (Internal *, const vector<int> &, const char *fmt, ...)
+      CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+  // Another variant, to avoid copying (without logging).
+  //
+  static void log (Internal *, const vector<int>::const_iterator &begin,
+                   const vector<int>::const_iterator &end, const char *fmt,
+                   ...) CADICAL_ATTRIBUTE_FORMAT (4, 5);
+
+  // used for logging LRAT proof chains
+  //
+  static void log (Internal *, const vector<int64_t> &, const char *fmt,
+                   ...) CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+  static void log (Internal *, const int *, const unsigned, const char *fmt,
+                   ...) CADICAL_ATTRIBUTE_FORMAT (4, 5);
+
+  static void log_empty_line (Internal *);
+
+  static void log (Internal *, const Gate *, const char *fmt, ...)
+      CADICAL_ATTRIBUTE_FORMAT (3, 4);
+
+  static string loglit (Internal *, int lit);
+};
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// Make sure that 'logging' code is really not included (second case of the
+// '#ifdef') if logging code is not included.
+
+#define LOG(...) \
+  do { \
+    if (!internal->opts.log) \
+      break; \
+    Logger::log (internal, __VA_ARGS__); \
+  } while (0)
+
+#define LOGLIT(lit) Logger::loglit (internal, lit).c_str ()
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+/*------------------------------------------------------------------------*/
+#else // end of 'then' part of 'ifdef LOGGING'
+/*------------------------------------------------------------------------*/
+
+#define LOG(...) \
+  do { \
+  } while (0)
+
+#define LOGLIT(...)
+
+/*------------------------------------------------------------------------*/
+#endif // end of 'else' part of 'ifdef LOGGING'
+/*------------------------------------------------------------------------*/
+#endif
diff --git a/src/sat/cadical/lratchecker.hpp b/src/sat/cadical/lratchecker.hpp
new file mode 100644
index 000000000..0e791e9f4
--- /dev/null
+++ b/src/sat/cadical/lratchecker.hpp
@@ -0,0 +1,170 @@
+#ifndef _lratchecker_hpp_INCLUDED
+#define _lratchecker_hpp_INCLUDED
+
+#include "global.h"
+
+/*------------------------------------------------------------------------*/
+#include <unordered_map>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// This checker implements an LRUP checker.
+// It requires LRAT-style proof chains for each learned clause
+//
+// Most of the infrastructure is taken from checker, but without the
+// propagation
+
+/*------------------------------------------------------------------------*/
+
+struct LratCheckerClause {
+  LratCheckerClause *next; // collision chain link for hash table
+  uint64_t hash;           // previously computed full 64-bit hash
+  int64_t id;              // id of clause
+  bool garbage;            // for garbage clauses
+  unsigned size;
+  bool used;
+  bool tautological;
+  int literals[1]; // 'literals' of length 'size'
+};
+
+/*------------------------------------------------------------------------*/
+
+class LratChecker : public StatTracer {
+
+  Internal *internal;
+
+  // Capacity of variable values.
+  //
+  int64_t size_vars;
+
+  // The 'watchers' and 'marks' data structures are not that time critical
+  // and thus we access them by first mapping a literal to 'unsigned'.
+  //
+  static unsigned l2u (int lit);
+
+  signed char &checked_lit (int lit);
+  signed char &mark (int lit);
+
+  vector<signed char> checked_lits;
+  vector<signed char> marks; // mark bits of literals
+  unordered_map<int64_t, vector<int>> clauses_to_reconstruct;
+  vector<int> assumptions;
+  vector<int> constraint;
+  bool concluded;
+
+  uint64_t num_clauses; // number of clauses in hash table
+  uint64_t num_finalized;
+  uint64_t num_garbage;        // number of garbage clauses
+  uint64_t size_clauses;       // size of clause hash table
+  LratCheckerClause **clauses; // hash table of clauses
+  LratCheckerClause *garbage;  // linked list of garbage clauses
+
+  vector<int> imported_clause; // original clause for reporting
+  vector<int64_t> assumption_clauses;
+
+  void enlarge_vars (int64_t idx);
+  void import_literal (int lit);
+  void import_clause (const vector<int> &);
+
+  static const unsigned num_nonces = 4;
+
+  uint64_t nonces[num_nonces];     // random numbers for hashing
+  uint64_t last_hash;              // last computed hash value of clause
+  int64_t last_id;                 // id of the last added/deleted clause
+  int64_t current_id;              // id of the last added clause
+  uint64_t compute_hash (int64_t); // compute and save hash value of clause
+
+  // Reduce hash value to the actual size.
+  //
+  static uint64_t reduce_hash (uint64_t hash, uint64_t size);
+
+  void enlarge_clauses (); // enlarge hash table for clauses
+  void insert ();          // insert clause in hash table
+  LratCheckerClause **
+  find (const int64_t); // find clause position in hash table
+
+  void add_clause (const char *type);
+
+  void collect_garbage_clauses ();
+
+  LratCheckerClause *new_clause ();
+  void delete_clause (LratCheckerClause *);
+
+  bool check (vector<int64_t>);            // check RUP
+  bool check_resolution (vector<int64_t>); // check resolution
+  bool check_blocked (vector<int64_t>);    // check ER
+
+  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 deleted;   // number of deleted clauses
+    int64_t finalized; // number of finalized clauses
+
+    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 collections; // garbage collections
+
+  } stats;
+
+public:
+  LratChecker (Internal *);
+  virtual ~LratChecker ();
+
+  void connect_internal (Internal *i) override;
+  void begin_proof (int64_t) override;
+
+  void add_original_clause (int64_t, bool, const vector<int> &,
+                            bool restore) override;
+  void restore_clause (int64_t, const vector<int> &);
+
+  // check the proof chain for the new clause and add it to the checker
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &) override;
+
+  // check if the clause is present and delete it from the checker
+  void delete_clause (int64_t, bool, const vector<int> &) override;
+  // check if the clause is present and delete it from the checker
+  void weaken_minus (int64_t, const vector<int> &) override;
+
+  // check if the clause is present and delete it from the checker
+  void finalize_clause (int64_t, const vector<int> &) override;
+
+  // check the proof chain of the assumption clause and delete it
+  // immediately also check that they contain only assumptions and
+  // constraints
+  void add_assumption_clause (int64_t, const vector<int> &,
+                              const vector<int64_t> &) override;
+
+  // mark lit as assumption
+  void add_assumption (int) override;
+
+  // mark lits as constraint
+  void add_constraint (const vector<int> &) override;
+
+  void reset_assumptions () override;
+
+  // check if all clauses have been deleted
+  void report_status (int, int64_t) override;
+
+  void conclude_unsat (ConclusionType, const vector<int64_t> &) override;
+
+  void print_stats () override;
+  void dump (); // for debugging purposes only
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/lrattracer.hpp b/src/sat/cadical/lrattracer.hpp
new file mode 100644
index 000000000..9d8e92b6a
--- /dev/null
+++ b/src/sat/cadical/lrattracer.hpp
@@ -0,0 +1,63 @@
+#ifndef _lrattracer_h_INCLUDED
+#define _lrattracer_h_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+class LratTracer : public FileTracer {
+
+  Internal *internal;
+  File *file;
+  bool binary;
+
+#ifndef CADICAL_QUIET
+  int64_t added, deleted;
+#endif
+  int64_t latest_id;
+  vector<int64_t> delete_ids;
+
+  void put_binary_zero ();
+  void put_binary_lit (int external_lit);
+  void put_binary_id (int64_t id);
+
+  // support LRAT
+  void lrat_add_clause (int64_t, const vector<int> &,
+                        const vector<int64_t> &);
+  void lrat_delete_clause (int64_t);
+
+public:
+  // own and delete 'file'
+  LratTracer (Internal *, File *file, bool binary);
+  ~LratTracer ();
+
+  void connect_internal (Internal *i) override;
+  void begin_proof (int64_t) override;
+
+  void add_original_clause (int64_t, bool, const vector<int> &,
+                            bool = false) override {} // skip
+
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &) override;
+
+  void delete_clause (int64_t, bool, const vector<int> &) override;
+
+  void finalize_clause (int64_t, const vector<int> &) override {} // skip
+
+  void report_status (int, int64_t) override {} // skip
+
+#ifndef CADICAL_QUIET
+  void print_statistics ();
+#endif
+  bool closed () override;
+  void close (bool) override;
+  void flush (bool) override;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/message.hpp b/src/sat/cadical/message.hpp
new file mode 100644
index 000000000..e0209fed8
--- /dev/null
+++ b/src/sat/cadical/message.hpp
@@ -0,0 +1,71 @@
+#ifndef _message_h_INCLUDED
+#define _message_h_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+/*------------------------------------------------------------------------*/
+
+// Macros for compact message code.
+
+#ifndef CADICAL_QUIET
+
+#define LINE() \
+  do { \
+    if (internal) \
+      internal->message (); \
+  } while (0)
+
+#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
+
+#define LINE() \
+  do { \
+  } while (0)
+#define MSG(...) \
+  do { \
+  } while (0)
+#define PHASE(...) \
+  do { \
+  } while (0)
+#define SECTION(...) \
+  do { \
+  } while (0)
+#define VERBOSE(...) \
+  do { \
+  } while (0)
+
+#endif
+
+#define FATAL fatal
+#define WARNING(...) internal->warning (__VA_ARGS__)
+
+/*------------------------------------------------------------------------*/
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif // ifndef _message_h_INCLUDED
diff --git a/src/sat/cadical/module.make b/src/sat/cadical/module.make
new file mode 100644
index 000000000..74f5d23cb
--- /dev/null
+++ b/src/sat/cadical/module.make
@@ -0,0 +1,91 @@
+SRC +=src/sat/cadical/cadicalSolver.c \
+src/sat/cadical/cadicalTest.c \
+src/sat/cadical/cadical_analyze.cpp \
+src/sat/cadical/cadical_arena.cpp \
+src/sat/cadical/cadical_assume.cpp \
+src/sat/cadical/cadical_averages.cpp \
+src/sat/cadical/cadical_backtrack.cpp \
+src/sat/cadical/cadical_backward.cpp \
+src/sat/cadical/cadical_bins.cpp \
+src/sat/cadical/cadical_block.cpp \
+src/sat/cadical/cadical_ccadical.cpp \
+src/sat/cadical/cadical_checker.cpp \
+src/sat/cadical/cadical_clause.cpp \
+src/sat/cadical/cadical_collect.cpp \
+src/sat/cadical/cadical_compact.cpp \
+src/sat/cadical/cadical_condition.cpp \
+src/sat/cadical/cadical_config.cpp \
+src/sat/cadical/cadical_congruence.cpp \
+src/sat/cadical/cadical_constrain.cpp \
+src/sat/cadical/cadical_contract.cpp \
+src/sat/cadical/cadical_cover.cpp \
+src/sat/cadical/cadical_decide.cpp \
+src/sat/cadical/cadical_decompose.cpp \
+src/sat/cadical/cadical_deduplicate.cpp \
+src/sat/cadical/cadical_definition.cpp \
+src/sat/cadical/cadical_drattracer.cpp \
+src/sat/cadical/cadical_elim.cpp \
+src/sat/cadical/cadical_elimfast.cpp \
+src/sat/cadical/cadical_ema.cpp \
+src/sat/cadical/cadical_extend.cpp \
+src/sat/cadical/cadical_external.cpp \
+src/sat/cadical/cadical_external_propagate.cpp \
+src/sat/cadical/cadical_factor.cpp \
+src/sat/cadical/cadical_file.cpp \
+src/sat/cadical/cadical_flags.cpp \
+src/sat/cadical/cadical_flip.cpp \
+src/sat/cadical/cadical_format.cpp \
+src/sat/cadical/cadical_frattracer.cpp \
+src/sat/cadical/cadical_gates.cpp \
+src/sat/cadical/cadical_idruptracer.cpp \
+src/sat/cadical/cadical_instantiate.cpp \
+src/sat/cadical/cadical_internal.cpp \
+src/sat/cadical/cadical_ipasir.cpp \
+src/sat/cadical/cadical_lidruptracer.cpp \
+src/sat/cadical/cadical_limit.cpp \
+src/sat/cadical/cadical_logging.cpp \
+src/sat/cadical/cadical_lookahead.cpp \
+src/sat/cadical/cadical_lratchecker.cpp \
+src/sat/cadical/cadical_lrattracer.cpp \
+src/sat/cadical/cadical_lucky.cpp \
+src/sat/cadical/cadical_message.cpp \
+src/sat/cadical/cadical_minimize.cpp \
+src/sat/cadical/cadical_occs.cpp \
+src/sat/cadical/cadical_options.cpp \
+src/sat/cadical/cadical_parse.cpp \
+src/sat/cadical/cadical_phases.cpp \
+src/sat/cadical/cadical_probe.cpp \
+src/sat/cadical/cadical_profile.cpp \
+src/sat/cadical/cadical_proof.cpp \
+src/sat/cadical/cadical_propagate.cpp \
+src/sat/cadical/cadical_queue.cpp \
+src/sat/cadical/cadical_random.cpp \
+src/sat/cadical/cadical_reap.cpp \
+src/sat/cadical/cadical_reduce.cpp \
+src/sat/cadical/cadical_rephase.cpp \
+src/sat/cadical/cadical_report.cpp \
+src/sat/cadical/cadical_resources.cpp \
+src/sat/cadical/cadical_restart.cpp \
+src/sat/cadical/cadical_restore.cpp \
+src/sat/cadical/cadical_score.cpp \
+src/sat/cadical/cadical_shrink.cpp \
+src/sat/cadical/cadical_signal.cpp \
+src/sat/cadical/cadical_solution.cpp \
+src/sat/cadical/cadical_solver.cpp \
+src/sat/cadical/cadical_stable.cpp \
+src/sat/cadical/cadical_stats.cpp \
+src/sat/cadical/cadical_subsume.cpp \
+src/sat/cadical/cadical_sweep.cpp \
+src/sat/cadical/cadical_terminal.cpp \
+src/sat/cadical/cadical_ternary.cpp \
+src/sat/cadical/cadical_tier.cpp \
+src/sat/cadical/cadical_transred.cpp \
+src/sat/cadical/cadical_unstable.cpp \
+src/sat/cadical/cadical_util.cpp \
+src/sat/cadical/cadical_var.cpp \
+src/sat/cadical/cadical_veripbtracer.cpp \
+src/sat/cadical/cadical_version.cpp \
+src/sat/cadical/cadical_vivify.cpp \
+src/sat/cadical/cadical_walk.cpp \
+src/sat/cadical/cadical_watch.cpp \
+src/sat/cadical/cadical_kitten.c
diff --git a/src/sat/cadical/occs.hpp b/src/sat/cadical/occs.hpp
new file mode 100644
index 000000000..28a9246bc
--- /dev/null
+++ b/src/sat/cadical/occs.hpp
@@ -0,0 +1,42 @@
+#ifndef _occs_h_INCLUDED
+#define _occs_h_INCLUDED
+
+#include "global.h"
+
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// Full occurrence lists used in a one-watch scheme for all clauses in
+// subsumption checking and for irredundant clauses in variable elimination.
+
+struct Clause;
+using namespace std;
+
+typedef vector<Clause *> Occs;
+
+inline void shrink_occs (Occs &os) { shrink_vector (os); }
+inline void erase_occs (Occs &os) { erase_vector (os); }
+
+inline void remove_occs (Occs &os, Clause *c) {
+  const auto end = os.end ();
+  auto i = os.begin ();
+  for (auto j = i; j != end; j++) {
+    const Clause *d = *i++ = *j;
+    if (c == d)
+      i--;
+  }
+  CADICAL_assert (i + 1 == end);
+  os.resize (i - os.begin ());
+}
+
+typedef Occs::iterator occs_iterator;
+typedef Occs::const_iterator const_occs_iterator;
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/options.hpp b/src/sat/cadical/options.hpp
new file mode 100644
index 000000000..1527da2e1
--- /dev/null
+++ b/src/sat/cadical/options.hpp
@@ -0,0 +1,422 @@
+#ifndef _options_hpp_INCLUDED
+#define _options_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+/*------------------------------------------------------------------------*/
+
+// In order to add a new option, simply add a new line below. Make sure that
+// options are sorted correctly (with '!}sort -k 2' in 'vi').  Otherwise
+// 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.  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.
+
+// clang-format off
+
+#define OPTIONS \
+\
+/*      NAME         DEFAULT, LO, HI,O,P,R, USAGE */ \
+\
+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( bumpreasonlimit,  10,  1,2e9,0,0,1, "bump reason limit") \
+OPTION( bumpreasonrate,  100,  1,2e9,0,0,1, "bump reason decision rate") \
+OPTION( check,             0,  0,  1,0,0,0, "enable internal checking") \
+OPTION( checkassumptions,  1,  0,  1,0,0,0, "check assumptions satisfied") \
+OPTION( checkconstraint,   1,  0,  1,0,0,0, "check constraint 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,        3,  0,  3,0,0,0, "1=drat, 2=lrat, 3=both") \
+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,1,1, "globally blocked clause elim") \
+OPTION( conditioneffort, 100,  1,1e5,0,0,1, "relative efficiency per mille") \
+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,   0,  0,2e9,1,0,1, "minimum condition efficiency") \
+OPTION( congruence,        1,  0,  1,0,0,1, "congruence closure") \
+OPTION( congruenceand,     1,  0,  1,0,0,1, "extract AND gates") \
+OPTION( congruenceandarity,1e6,2,5e7,0,0,1, "AND gate arity limit") \
+OPTION( congruencebinaries,1,  0,  1,0,0,1, "extract binary and strengthen ternary clauses") \
+OPTION( congruenceite,     1,  0,  1,0,0,1, "extract ITE gates") \
+OPTION( congruencexor,     1,  0,  1,0,0,1, "extract XOR gates") \
+OPTION( congruencexorarity,4,  2, 31,0,0,1, "XOR gate arity limit") \
+OPTION( congruencexorcounts,1, 1,5e6,0,0,1, "XOR gate round") \
+OPTION( cover,             0,  0,  1,0,1,1, "covered clause elimination") \
+OPTION( covereffort,       4,  1,1e5,1,0,1, "relative efficiency per mille") \
+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,       0,  0,2e9,1,0,1, "minimum cover efficiency") \
+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,1,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( 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( elimdef,           0,  0,  1,0,0,1, "mine definitions with cadical_kitten") \
+OPTION( elimdefcores,      1,  1,100,0,0,1, "number of unsat cores") \
+OPTION( elimdefticks,    2e5,  0,2e9,1,0,1, "cadical_kitten ticks limit") \
+OPTION( elimeffort,      1e3,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( elimequivs,        1,  0,  1,0,0,1, "find equivalence gates") \
+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( elimmaxeff,      2e9,  0,2e9,1,0,1, "maximum elimination efficiency") \
+OPTION( elimmineff,      1e7,  0,2e9,1,0,1, "minimum elimination efficiency") \
+OPTION( elimocclim,      1e2,  0,2e9,2,0,1, "occurrence limit") \
+OPTION( elimprod,          1,  0,1e4,0,0,1, "elim score product weight") \
+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( emadecisions,    1e5,  1,2e9,0,0,1, "window decision rate") \
+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( exteagerreasons,   1,  0,  1,0,0,1, "eagerly ask for all reasons (0: only when needed)") \
+OPTION( exteagerrecalc,    1,  0,  1,0,0,1, "after eagerly asking for reasons recalculate all levels (0: trust the external tool)") \
+OPTION( externallrat,      0,  0,  1,0,0,1, "external lrat") \
+OPTION( factor,            1,  0,  1,0,1,1, "bounded variable addition") \
+OPTION( factorcandrounds,  2,  0,2e9,0,0,1, "candidates reduction rounds") \
+OPTION( factoreffort,     50,  0,1e6,0,0,1, "relative effort per mille") \
+OPTION( factoriniticks,  300,  1,1e6,0,0,1, "initial effort in millions") \
+OPTION( factorsize,        5,  2,2e9,0,0,1, "clause size limit") \
+OPTION( factorthresh,      7,  0,100,1,0,1, "delay if ticks smaller thresh*clauses") \
+OPTION( fastelim,          1,  0,  1,0,1,1, "fast BVE during preprocessing") \
+OPTION( fastelimbound,     8,  1,1e3,1,0,1, "fast BVE bound during preprocessing") \
+OPTION( fastelimclslim,  1e2,  2,2e9,2,0,1, "fast BVE resolvent size limit") \
+OPTION( fastelimocclim,  100,  1,2e9,2,0,1, "fast BVE occurence limit during preprocessing") \
+OPTION( fastelimrounds,    4,  1,512,1,0,1, "number of fastelim rounds") \
+OPTION( flush,             0,  0,  1,0,1,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( frat,              0,  0,  2,0,0,1, "1=frat(lrat), 2=frat(drat)") \
+OPTION( idrup,             0,  0,  1,0,0,1, "incremental proof format") \
+OPTION( ilb,               0,  0,  1,0,0,1, "ILB (incremental lazy backtrack)") \
+OPTION( ilbassumptions,    0,  0,  1,0,0,1, "trail reuse for assumptions (ILB-like)") \
+OPTION( inprobeint,      100,  1,2e9,0,0,1, "inprobing interval" ) \
+OPTION( inprobing,         1,  0,  1,0,1,1, "enable probe inprocessing") \
+OPTION( inprocessing,      1,  0,  1,0,1,1, "enable general 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") \
+OPTION( lidrup,            0,  0,  1,0,0,1, "linear incremental proof format") \
+LOGOPT( log,               0,  0,  1,0,0,0, "enable logging") \
+LOGOPT( logsort,           0,  0,  1,0,0,0, "sort logged clauses") \
+OPTION( lrat,              0,  0,  1,0,0,1, "use LRAT proof format") \
+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( minimizeticks,     1,  0,  1,0,0,1, "increment ticks in minimization") \
+OPTION( otfs,              1,  0,  1,0,0,1, "on-the-fly self subsumption") \
+OPTION( phase,             1,  0,  1,0,0,1, "initial phase") \
+OPTION( preprocessinit,  2e6,  0,2e9,2,0,1, "initial preprocessing base limit" ) \
+OPTION( preprocesslight,   1,  0,  1,0,1,1, "lightweight preprocessing" ) \
+OPTION( probe,             1,  0,  1,0,1,1, "failed literal probing" ) \
+OPTION( probeeffort,       8,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( probehbr,          1,  0,  1,0,0,1, "learn hyper binary clauses") \
+OPTION( probethresh,       0,  0,100,1,0,1, "delay if ticks smaller thresh*clauses") \
+OPTION( profile,           2,  0,  4,0,0,0, "profiling level") \
+QUTOPT( quiet,             0,  0,  1,0,0,0, "disable all messages") \
+OPTION( radixsortlim,     32,  0,2e9,0,0,1, "radix sort limit") \
+OPTION( realtime,          0,  0,  1,0,0,0, "real instead of process time") \
+OPTION( recomputetier,     1,  0,  1,0,0,1, "recompute tiers") \
+OPTION( reduce,            1,  0,  1,0,0,1, "reduce useless clauses") \
+OPTION( reduceinit,      300,  1,1e6,0,0,1, "initial interval") \
+OPTION( reduceint,        25,  2,1e6,0,0,1, "reduce interval") \
+OPTION( reduceopt,         1,  0,  2,0,0,1, "0=prct,1=sqrt,2=max") \
+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( shrink,            3,  0,  3,0,0,1, "shrink conflict clause (1=only with binary, 2=minimize when pulling, 3=full)") \
+OPTION( shrinkreap,        1,  0,  1,0,0,1, "use a reap for shrinking") \
+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( stabilizeinit,   1e3,  1,2e9,0,0,1, "stabilizing interval") \
+OPTION( stabilizeonly,     0,  0,  1,0,0,1, "only stabilizing phases") \
+OPTION( stats,             0,  0,  1,0,0,1, "print all statistics at the end of the run") \
+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( subsumeeffort,   1e3,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( subsumelimited,    1,  0,  1,0,0,1, "limit subsumption checks") \
+OPTION( subsumemaxeff,   1e8,  0,2e9,1,0,1, "maximum subsuming efficiency") \
+OPTION( subsumemineff,     0,  0,2e9,1,0,1, "minimum subsuming efficiency") \
+OPTION( subsumeocclim,   1e2,  0,2e9,1,0,1, "watch list length limit") \
+OPTION( subsumestr,        1,  0,  1,0,0,1, "subsume strenghten") \
+OPTION( sweep,             1,  0,  1,0,1,1, "enable SAT sweeping") \
+OPTION( sweepclauses,   1024,  0,2e9,1,0,1, "environment clauses") \
+OPTION( sweepcomplete,     0,  0,  1,0,0,1, "run SAT sweeping to completion") \
+OPTION( sweepcountbinary,  1,  0,  1,0,0,1, "count binaries to environment") \
+OPTION( sweepdepth,        2,  0,2e9,1,0,1, "environment depth") \
+OPTION( sweepeffort,     1e2,  0,1e4,0,0,1, "relative effort in ticks per mille") \
+OPTION( sweepfliprounds,   1,  0,2e9,1,0,1, "flipping rounds") \
+OPTION( sweepmaxclauses, 3e5,  2,2e9,1,0,1, "maximum environment clauses") \
+OPTION( sweepmaxdepth,     3,  1,2e9,1,0,1, "maximum environment depth") \
+OPTION( sweepmaxvars,   8192,  2,2e9,1,0,1, "maximum environment variables") \
+OPTION( sweeprand,         0,  0,  1,0,0,1, "randomize sweeping environment") \
+OPTION( sweepthresh,       5,  0,100,1,0,1, "delay if ticks smaller thresh*clauses") \
+OPTION( sweepvars,       256,  0,2e9,1,0,1, "environment variables") \
+OPTION( target,            1,  0,  2,0,0,1, "target phases (1=stable only)") \
+OPTION( terminateint,     10,  0,1e4,0,0,1, "termination check interval") \
+OPTION( ternary,           1,  0,  1,0,1,1, "hyper ternary resolution") \
+OPTION( ternaryeffort,     8,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( ternarymaxadd,   1e3,  0,1e4,1,0,1, "max clauses added in percent") \
+OPTION( ternaryocclim,   1e2,  1,2e9,2,0,1, "ternary occurrence limit") \
+OPTION( ternaryrounds,     2,  1, 16,1,0,1, "maximum ternary rounds") \
+OPTION( ternarythresh,     6,  0,100,1,0,1, "delay if ticks smaller thresh*clauses") \
+OPTION( tier1limit,       50,  0,100,0,0,1, "limit of tier1 usage in percentage") \
+OPTION( tier2limit,       90,  0,100,0,0,1, "limit of tier2 usage in percentage") \
+OPTION( transred,          1,  0,  1,0,1,1, "transitive reduction of BIG") \
+OPTION( transredeffort,  1e2,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( transredmaxeff,  1e8,  0,2e9,1,0,1, "maximum efficiency") \
+OPTION( transredmineff,    0,  0,2e9,1,0,1, "minimum efficiency") \
+QUTOPT( verbose,           0,  0,  3,0,0,0, "more verbose messages") \
+OPTION( veripb,            0,  0,  4,0,0,1, "odd=checkdeletions, > 2=drat") \
+OPTION( vivify,            1,  0,  1,0,1,1, "vivification") \
+OPTION( vivifycalctier,    0,  0,  1,0,0,1, "recalculate tier limits") \
+OPTION( vivifydemote,      0,  0,  1,0,1,1, "demote irredundant or delete directly") \
+OPTION( vivifyeffort,     50,  0,1e5,1,0,1, "overall efficiency per mille") \
+OPTION( vivifyflush,       1,  0,  1,1,0,1,  "flush subsumed before vivification rounds") \
+OPTION( vivifyinst,        1,  0,  1,0,0,1, "instantiate last literal when vivify") \
+OPTION( vivifyirred,       1,  0,  1,0,1,1, "vivification irred") \
+OPTION( vivifyirredeff,    3,  1,100,1,0,1, "irredundant efficiency per mille") \
+OPTION( vivifyonce,        0,  0,  2,0,0,1, "vivify once: 1=red, 2=red+irr") \
+OPTION( vivifyretry,       0,  0,  5,0,0,1, "re-vivify clause if vivify was successful") \
+OPTION( vivifyschedmax,  5e3, 10,2e9,0,0,1, "maximum schedule size") \
+OPTION( vivifythresh,     20,  0,100,1,0,1, "delay if ticks smaller thresh*clauses") \
+OPTION( vivifytier1,       1,  0,  1,0,1,1, "vivification tier1") \
+OPTION( vivifytier1eff,    4,  0,100,1,0,1, "relative tier1 effort") \
+OPTION( vivifytier2,       1,  0,  1,0,1,1, "vivification tier2") \
+OPTION( vivifytier2eff,    2,  1,100,1,0,1, "relative tier2 effort") \
+OPTION( vivifytier3,       1,  0,  1,0,1,1, "vivification tier3") \
+OPTION( vivifytier3eff,    1,  1,100,1,0,1, "relative tier3 effort") \
+OPTION( walk,              1,  0,  1,0,0,1, "enable random walks") \
+OPTION( walkeffort,       20,  1,1e5,1,0,1, "relative efficiency per mille") \
+OPTION( walkmaxeff,      1e7,  0,2e9,1,0,1, "maximum efficiency") \
+OPTION( walkmineff,        0,  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") \
+
+// Note, keep an empty line right before this line because of the last '\'!
+// Also keep those single spaces after 'OPTION(' for proper sorting.
+
+// clang-format on
+
+/*------------------------------------------------------------------------*/
+
+// Some of the 'OPTION' macros above should only be included if certain
+// compile time options are enabled.  This has the effect, that for instance
+// if 'LOGGING' is defined, and thus logging code is included, then also the
+// 'log' option is defined.  Otherwise the 'log' option is not included.
+
+#ifdef LOGGING
+#define LOGOPT OPTION
+#else
+#define LOGOPT(...) /**/
+#endif
+
+#ifdef CADICAL_QUIET
+#define QUTOPT(...) /**/
+#else
+#define QUTOPT OPTION
+#endif
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+struct Internal;
+
+/*------------------------------------------------------------------------*/
+
+class Options;
+
+struct Option {
+  const char *name;
+  int def, lo, hi;
+  int optimizable;
+  bool preprocessing;
+  const char *description;
+  int &val (Options *);
+};
+
+/*------------------------------------------------------------------------*/
+
+// Produce a compile time constant for the number of options.
+
+static const size_t number_of_options =
+#define OPTION(N, V, L, H, O, P, R, D) 1 +
+    OPTIONS
+#undef OPTION
+    + 0;
+
+/*------------------------------------------------------------------------*/
+
+class Options {
+
+  Internal *internal;
+
+  void set (Option *, int val); // Force to [lo,hi] interval.
+
+  friend struct Option;
+  static Option table[];
+
+  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 (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 reportdefault;
+
+  Options (Internal *);
+
+  // Makes options directly accessible, e.g., for instance declares the
+  // 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.
+public:
+#define OPTION(N, V, L, H, O, P, R, D) \
+  int N; // Access option values by name.
+  OPTIONS
+#undef OPTION
+
+  // 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__' and
+  // that the following options are really allocated directly after it.
+  //
+  inline int &val (size_t idx) {
+    CADICAL_assert (idx < number_of_options);
+    return (&__start_of_options__ + 1)[idx];
+  }
+
+  // With the following function we can get rather fast access to the option
+  // limits, the default value and the description.  The code uses binary
+  // 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 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 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)
+
+  static bool is_preprocessing_option (const char *name);
+
+  // Parse long option argument
+  //
+  //   --<name>
+  //   --<name>=<val>
+  //   --no-<name>
+  //
+  // where '<val>' is as in 'parse_option_value'.  If parsing succeeds,
+  // 'true' is returned and the string will be set to the name of the
+  // option.  Additionally the parsed value is set (last argument).
+  //
+  static bool parse_long_option (const char *, string &, int &);
+
+  // Iterating options.
+
+  typedef Option *iterator;
+  typedef const Option *const_iterator;
+
+  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) {
+  CADICAL_assert (Options::table <= this &&
+          this < Options::table + number_of_options);
+  return opts->val (this - Options::table);
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/parse.hpp b/src/sat/cadical/parse.hpp
new file mode 100644
index 000000000..a37117f43
--- /dev/null
+++ b/src/sat/cadical/parse.hpp
@@ -0,0 +1,78 @@
+#ifndef _parse_hpp_INCLUDED
+#define _parse_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cassert>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// Factors out common functions for parsing of DIMACS and solution files.
+
+class File;
+struct External;
+struct Internal;
+
+class Parser {
+
+  Solver *solver;
+  Internal *internal;
+  External *external;
+  File *file;
+
+  void perr (const char *fmt, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  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, 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:
+  // 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 a parse
+  // error is return. The parsed clauses are added to the solver and the
+  // maximum variable index found is returned 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);
+
+  // Parse a solution file as used in the SAT competition, e.g., with
+  // comment lines 'c ...', a status line 's ...' and value lines 'v ...'.
+  // Returns zero if successful. Otherwise a string is returned describing
+  // the parse error.  The parsed solution is saved in 'solution' and can be
+  // accessed with 'sol (int lit)'.  We use it for checking learned clauses.
+  //
+  const char *parse_solution ();
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/phases.hpp b/src/sat/cadical/phases.hpp
new file mode 100644
index 000000000..98e54d439
--- /dev/null
+++ b/src/sat/cadical/phases.hpp
@@ -0,0 +1,24 @@
+#ifndef _phases_hpp_INCLUDED
+#define _phases_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Phases {
+
+  vector<signed char> best;   // The current largest trail phase.
+  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.
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/profile.hpp b/src/sat/cadical/profile.hpp
new file mode 100644
index 000000000..f3799389b
--- /dev/null
+++ b/src/sat/cadical/profile.hpp
@@ -0,0 +1,280 @@
+#ifndef _profiles_h_INCLUDED
+#define _profiles_h_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+/*------------------------------------------------------------------------*/
+#ifndef CADICAL_QUIET
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+struct Internal;
+
+/*------------------------------------------------------------------------*/
+
+// The solver contains some built in profiling (even for optimized code).
+// The idea is that even without using external tools it is possible to get
+// an overview of where time is spent.  This is enabled with the option
+// 'profile', e.g., you might want to use '--profile=3', or even higher
+// values for more detailed profiling information.  Currently the default is
+// '--profile=2', which should only induce a tiny profiling overhead.
+//
+// Profiling has a Heisenberg effect, since we rely on calling 'getrusage'
+// instead of using profile counters and sampling.  For functions which are
+// executed many times, this overhead is substantial (say 10%-20%).  For
+// functions which are not executed many times there is in essence no
+// overhead in measuring time spent in them.  These get a smaller profiling
+// level, which is the second argument in the 'PROFILE' macro below.  Thus
+// using '--profile=1' for instance should not add any penalty to the
+// run-time, while '--profile=3' and higher levels slow down the solver.
+//
+// To profile say 'foo', just add another line 'PROFILE(foo,LEVEL)' and wrap
+// the code to be profiled within a 'START (foo)' / 'STOP (foo)' block.
+
+/*------------------------------------------------------------------------*/
+
+// Profile counters for functions which are not compiled in should be
+// removed. This is achieved by adding a wrapper macro for them here.
+
+/*------------------------------------------------------------------------*/
+
+#ifdef PROFILE_MODE
+#define MROFILE PROFILE
+#else
+#define MROFILE(...) /**/
+#endif
+
+#define PROFILES \
+  PROFILE (analyze, 3) \
+  MROFILE (analyzestable, 4) \
+  MROFILE (analyzeunstable, 4) \
+  PROFILE (backward, 3) \
+  PROFILE (block, 2) \
+  PROFILE (bump, 4) \
+  PROFILE (checking, 2) \
+  PROFILE (cdcl, 1) \
+  PROFILE (collect, 3) \
+  PROFILE (compact, 3) \
+  PROFILE (condition, 2) \
+  PROFILE (congruence, 2) \
+  PROFILE (congruencemerge, 4) \
+  PROFILE (congruencematching, 4) \
+  PROFILE (connect, 3) \
+  PROFILE (copy, 4) \
+  PROFILE (cover, 2) \
+  PROFILE (decide, 3) \
+  PROFILE (decompose, 3) \
+  PROFILE (definition, 2) \
+  PROFILE (elim, 2) \
+  PROFILE (factor, 2) \
+  PROFILE (fastelim, 2) \
+  PROFILE (extend, 3) \
+  PROFILE (extract, 3) \
+  PROFILE (extractands, 4) \
+  PROFILE (extractbinaries, 4) \
+  PROFILE (extractites, 4) \
+  PROFILE (extractxors, 4) \
+  PROFILE (instantiate, 2) \
+  PROFILE (lucky, 2) \
+  PROFILE (lookahead, 2) \
+  PROFILE (minimize, 4) \
+  PROFILE (shrink, 4) \
+  PROFILE (parse, 0) /* As 'opts.profile' might change in parsing*/ \
+  PROFILE (probe, 2) \
+  PROFILE (deduplicate, 3) \
+  PROFILE (propagate, 4) \
+  MROFILE (propstable, 4) \
+  MROFILE (propunstable, 4) \
+  PROFILE (reduce, 3) \
+  PROFILE (restart, 3) \
+  PROFILE (restore, 2) \
+  PROFILE (search, 1) \
+  PROFILE (solve, 0) \
+  PROFILE (stable, 2) \
+  PROFILE (sweep, 2) \
+  PROFILE (sweepbackbone, 3) \
+  PROFILE (sweepequivalences, 3) \
+  PROFILE (sweepflip, 4) \
+  PROFILE (sweepimplicant, 4) \
+  PROFILE (sweepsolve, 4) \
+  PROFILE (preprocess, 2) \
+  PROFILE (simplify, 1) \
+  PROFILE (subsume, 2) \
+  PROFILE (ternary, 2) \
+  PROFILE (transred, 3) \
+  PROFILE (unstable, 2) \
+  PROFILE (vivify, 2) \
+  PROFILE (walk, 2)
+
+/*------------------------------------------------------------------------*/
+
+// See 'START' and 'STOP' in 'macros.hpp' too.
+
+struct Profile {
+
+  bool active;
+  double value;     // accumulated time
+  double started;   // started time if active
+  const char *name; // name of the profiled function (or 'phase')
+  const int level;  // allows to cheaply test if profiling is enabled
+
+  Profile (const char *n, int l)
+      : active (false), value (0), name (n), level (l) {}
+};
+
+struct Profiles {
+  Internal *internal;
+#define PROFILE(NAME, LEVEL) Profile NAME;
+  PROFILES
+#undef PROFILE
+  Profiles (Internal *);
+};
+
+} // namespace CaDiCaL
+
+#define NON_CADICAL_QUIET_PROFILE_CODE(CODE) CODE
+
+#else // !defined(CADICAL_QUIET)
+
+#define NON_CADICAL_QUIET_PROFILE_CODE(CODE) /**/
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+// Macros for Profiling support and checking and changing the mode.
+
+#define START(P) \
+  do { \
+    NON_CADICAL_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 { \
+    NON_CADICAL_QUIET_PROFILE_CODE ( \
+        if (internal->profiles.P.level <= internal->opts.profile) \
+            internal->stop_profiling (internal->profiles.P, \
+                                      internal->time ());) \
+  } while (0)
+
+#define PROFILE_ACTIVE(P) \
+  ((internal->profiles.P.level <= internal->opts.profile) && \
+   (internal->profiles.P.active))
+
+/*------------------------------------------------------------------------*/
+
+#define START_SIMPLIFIER(S, M) \
+  do { \
+    NON_CADICAL_QUIET_PROFILE_CODE (const double N = time (); \
+                            const int L = internal->opts.profile;) \
+    if (!preprocessing && !lookingahead) { \
+      NON_CADICAL_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); \
+    } \
+    NON_CADICAL_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)
+
+/*------------------------------------------------------------------------*/
+
+#define STOP_SIMPLIFIER(S, M) \
+  do { \
+    NON_CADICAL_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) { \
+      NON_CADICAL_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)
+
+/*------------------------------------------------------------------------*/
+// Used in 'walk' before calling 'walk_round' within the CDCL loop.
+
+#define START_INNER_WALK() \
+  do { \
+    require_mode (SEARCH); \
+    CADICAL_assert (!preprocessing); \
+    NON_CADICAL_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)
+
+/*------------------------------------------------------------------------*/
+// Used in 'walk' after calling 'walk_round' within the CDCL loop.
+
+#define STOP_INNER_WALK() \
+  do { \
+    require_mode (SEARCH); \
+    CADICAL_assert (!preprocessing); \
+    reset_mode (WALK); \
+    NON_CADICAL_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); \
+        internal->profiles.walk.started = (N);) \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+// Used in 'local_search' before calling 'walk_round'.
+
+#define START_OUTER_WALK() \
+  do { \
+    require_mode (SEARCH); \
+    CADICAL_assert (!preprocessing); \
+    NON_CADICAL_QUIET_PROFILE_CODE (START (walk);) \
+    set_mode (WALK); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+// Used in 'local_search' after calling 'walk_round'.
+
+#define STOP_OUTER_WALK() \
+  do { \
+    require_mode (SEARCH); \
+    CADICAL_assert (!preprocessing); \
+    reset_mode (WALK); \
+    NON_CADICAL_QUIET_PROFILE_CODE (STOP (walk);) \
+  } while (0)
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif // ifndef _profiles_h_INCLUDED
diff --git a/src/sat/cadical/proof.hpp b/src/sat/cadical/proof.hpp
new file mode 100644
index 000000000..69be6b080
--- /dev/null
+++ b/src/sat/cadical/proof.hpp
@@ -0,0 +1,120 @@
+#ifndef _proof_h_INCLUDED
+#define _proof_h_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+class File;
+struct Clause;
+struct Internal;
+class Tracer;
+class FileTracer;
+
+/*------------------------------------------------------------------------*/
+
+// Provides proof checking and writing.
+
+class Proof {
+
+  Internal *internal;
+
+  vector<int> clause;          // of external literals
+  vector<int64_t> proof_chain; // LRAT style proof chain of clause
+  int64_t clause_id;           // id of added clause
+  bool redundant;
+
+  // the 'tracers'
+  vector<Tracer *> tracers;          // tracers (ie checker)
+  vector<FileTracer *> file_tracers; // file tracers (ie LRAT tracer)
+
+  void add_literal (int internal_lit); // add to 'clause'
+  void add_literals (Clause *);        // add to 'clause'
+
+  void add_literals (const vector<int> &); // ditto
+
+  void add_original_clause (
+      bool restore = false); // notify observers of original clauses
+  void add_derived_clause ();
+  void add_assumption_clause ();
+  void delete_clause ();
+  void demote_clause ();
+  void weaken_minus ();
+  void strengthen ();
+  void finalize_clause ();
+  void add_assumption ();
+  void add_constraint ();
+
+public:
+  Proof (Internal *);
+  ~Proof ();
+
+  void connect (Tracer *t) { tracers.push_back (t); }
+  void disconnect (Tracer *t);
+  // Add original clauses to the proof (for online proof checking).
+  //
+  void add_original_clause (int64_t, bool, const vector<int> &);
+
+  void add_assumption_clause (int64_t, const vector<int> &,
+                              const vector<int64_t> &);
+  void add_assumption_clause (int64_t, int, const vector<int64_t> &);
+  void add_assumption (int);
+  void add_constraint (const vector<int> &);
+  void reset_assumptions ();
+
+  // Add/delete original clauses to/from the proof using their original
+  //  external literals (from external->eclause)
+  //
+  void add_external_original_clause (int64_t, bool, const vector<int> &,
+                                     bool restore = false);
+  void delete_external_original_clause (int64_t, bool, const vector<int> &);
+
+  // Add derived (such as learned) clauses to the proof.
+  //
+  void add_derived_empty_clause (int64_t, const vector<int64_t> &);
+  void add_derived_unit_clause (int64_t, int unit, const vector<int64_t> &);
+  void add_derived_clause (Clause *c, const vector<int64_t> &);
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &);
+
+  // deletion of clauses. It comes in several variants, depending if the
+  // clause should be restored or not
+  void delete_clause (int64_t, bool, const vector<int> &);
+  void weaken_minus (int64_t, const vector<int> &);
+  void weaken_plus (int64_t, const vector<int> &);
+  void delete_unit_clause (int64_t id, const int lit);
+  void delete_clause (Clause *);
+  void weaken_minus (Clause *);
+  void weaken_plus (Clause *);
+  void strengthen (int64_t);
+
+  void finalize_unit (int64_t, int);
+  void finalize_external_unit (int64_t, int);
+  void finalize_clause (int64_t, const vector<int> &c);
+  void finalize_clause (Clause *);
+
+  void report_status (int, int64_t);
+  void begin_proof (int64_t);
+  void conclude_unsat (ConclusionType, const vector<int64_t> &);
+  void conclude_sat (const vector<int> &model);
+  void conclude_unknown (const vector<int> &trace);
+  void solve_query ();
+  // These two actually pretend to add and remove a clause.
+  //
+  void flush_clause (Clause *); // remove falsified literals
+  void strengthen_clause (Clause *, int, const vector<int64_t> &);
+  void otfs_strengthen_clause (Clause *, const vector<int> &,
+                               const vector<int64_t> &);
+
+  void flush ();
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/queue.hpp b/src/sat/cadical/queue.hpp
new file mode 100644
index 000000000..14e1f2da7
--- /dev/null
+++ b/src/sat/cadical/queue.hpp
@@ -0,0 +1,70 @@
+#ifndef _queue_hpp_INCLUDED
+#define _queue_hpp_INCLUDED
+
+#include "global.h"
+
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// Links for double linked decision queue.
+
+struct Link {
+
+  int prev, next; // variable indices
+
+  // initialized explicitly in 'init_queue'
+};
+
+typedef std::vector<Link> Links;
+
+// Variable move to front (VMTF) decision queue ordered by 'bumped'.  See
+// our SAT'15 paper for an explanation on how this works.
+
+struct Queue {
+
+  // We use integers instead of variable pointers.  This is more compact and
+  // also avoids issues due to moving the variable table during 'resize'.
+
+  int first, last; // anchors (head/tail) for doubly linked list
+  int unassigned;  // all variables after this one are assigned
+  int64_t bumped;  // see 'Internal.update_queue_unassigned'
+
+  Queue () : first (0), last (0), unassigned (0), bumped (0) {}
+
+  // We explicitly provide the mapping of integer indices to links to the
+  // following two (inlined) functions.  This avoids including
+  // 'internal.hpp' and breaks a cyclic dependency, so we can keep their
+  // code here in this header file.  Otherwise they are just ordinary doubly
+  // linked list 'dequeue' and 'enqueue' operations.
+
+  inline void dequeue (Links &links, int idx) {
+    Link &l = links[idx];
+    if (l.prev)
+      links[l.prev].next = l.next;
+    else
+      first = l.next;
+    if (l.next)
+      links[l.next].prev = l.prev;
+    else
+      last = l.prev;
+  }
+
+  inline void enqueue (Links &links, int idx) {
+    Link &l = links[idx];
+    if ((l.prev = last))
+      links[last].next = idx;
+    else
+      first = idx;
+    last = idx;
+    l.next = 0;
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/radix.hpp b/src/sat/cadical/radix.hpp
new file mode 100644
index 000000000..4c4d7b574
--- /dev/null
+++ b/src/sat/cadical/radix.hpp
@@ -0,0 +1,186 @@
+#ifndef _radix_hpp_INCLUDED
+#define _radix_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cassert>
+#include <cstring>
+#include <iterator>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+using namespace std;
+
+// This provides an implementation of a generic radix sort algorithm. The
+// reason for having it is that for certain benchmarks and certain parts of
+// CaDiCaL where sorting is used, the standard sorting algorithm 'sort'
+// turned out to be a hot-spot. Up to 30% of the total running time was for
+// instance used for some benchmarks in sorting variables during bumping
+// to make sure to bump them in 'enqueued' order.
+//
+// Further, in most cases, where we need to sort something, sorting is
+// actually performed on positive numbers (such as the 'enqueued' time stamp
+// during bumping), which allows to use radix sort or variants. At least
+// starting with medium sized arrays to be sorted (say above 1000 elements,
+// but see discussion on 'MSORT' below), radix sort can be way faster.
+//
+// Finally it is stable, which is actually preferred most of the time too.
+//
+// This template algorithm 'rsort' takes as first template parameter the
+// iterator class similar to the standard 'sort' algorithm template, but
+// then as second parameter a function class (similar to the second 'less
+// than' parameter of 'sort') which can obtain a 'rank' from each element,
+// on which they are compared.  The 'rank' should be able to turn an element
+// into a number.  The type of these ranks is determined automatically but
+// should be 'unsigned'.
+
+struct pointer_rank {
+  typedef size_t Type;
+  Type operator() (void *ptr) { return (size_t) ptr; }
+};
+
+template <class I, class Rank> void rsort (I first, I last, Rank rank) {
+  typedef typename iterator_traits<I>::value_type T;
+  typedef typename Rank::Type R;
+
+  CADICAL_assert (first <= last);
+  const size_t n = last - first;
+  if (n <= 1)
+    return;
+
+  const size_t l = 8;        // Radix 8, thus byte-wise.
+  const size_t w = (1 << l); // So many buckets.
+
+  const unsigned mask = w - 1; // Fast mod 'w'.
+
+// Uncomment the following define for large values of 'w' in order to keep
+// the large bucket array 'count' on the heap instead of the stack.
+//
+// #define CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+//
+#ifdef CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+  size_t *count = new size_t[w]; // Put buckets on the heap.
+#else
+  size_t count[w]; // Put buckets on the stack.
+#endif
+
+  I a = first, b = last, c = a;
+  bool initialized = false;
+  std::vector<T> v;
+
+  R upper = 0, lower = ~upper;
+  R shifted = mask;
+  bool bounded = false;
+
+  R masked_lower = 0, masked_upper = mask;
+
+  for (size_t i = 0; i < 8 * sizeof (rank (*first));
+       i += l, shifted <<= l) {
+
+    if (bounded && (lower & shifted) == (upper & shifted))
+      continue;
+
+    memset (count + masked_lower, 0,
+            (masked_upper - masked_lower + 1) * sizeof *count);
+
+    const I end = c + n;
+    bool sorted = true;
+    R last = 0;
+
+    for (I p = c; p != end; p++) {
+      const auto r = rank (*p);
+      if (!bounded)
+        lower &= r, upper |= r;
+      const auto s = r >> i;
+      const auto m = s & mask;
+      if (sorted && last > m)
+        sorted = false;
+      else
+        last = m;
+      count[m]++;
+    }
+
+    masked_lower = (lower >> i) & mask;
+    masked_upper = (upper >> i) & mask;
+
+    if (!bounded) {
+      bounded = true;
+      if ((lower & shifted) == (upper & shifted))
+        continue;
+    }
+
+    if (sorted)
+      continue;
+
+    size_t pos = 0;
+    for (R j = masked_lower; j <= masked_upper; j++) {
+      const size_t delta = count[j];
+      count[j] = pos;
+      pos += delta;
+    }
+
+    if (!initialized) {
+      CADICAL_assert (&*c == &*a); // MS VC++
+      v.resize (n);
+      b = v.begin ();
+      initialized = true;
+    }
+
+    I d = (&*c == &*a) ? b : a; // MS VC++
+
+    for (I p = c; p != end; p++) {
+      const auto r = rank (*p);
+      const auto s = r >> i;
+      const auto m = s & mask;
+      d[count[m]++] = *p;
+    }
+    c = d;
+  }
+
+  if (c == b) {
+    for (size_t i = 0; i < n; i++)
+      a[i] = b[i];
+  }
+
+#ifdef CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+  delete[] count;
+#endif
+
+#ifndef CADICAL_NDEBUG
+  for (I p = first; p + 1 != last; p++)
+    CADICAL_assert (rank (p[0]) <= rank (p[1]));
+#endif
+}
+
+// It turns out that for small number of elements (like '100') and in
+// particular for large value ranges the standard sorting function is
+// considerably faster than our radix sort (like 2.5x). This negative effect
+// vanishes at around 800 elements (sorting integers) and thus we provide a
+// function 'MSORT' which selects between standard sort and radix sort based
+// on the number of elements.  However we failed to put this into proper C++
+// style template code and thus have to use a macro instead.  We also do not
+// use it everywhere instead of 'rsort' since it requires a fourth
+// parameter, which is awkward, particular in those situation where we
+// expect large arrays to be sorted anyhow (such as during sorting the
+// clauses in an arena or the probes during probing).  The first argument
+// is the limit up to which we use the standard sort.  Above the limit we
+// use radix sort.  As usual we do not want to hard code it here (default
+// is '800') in order to make fuzzing and delta debugging more effective.
+
+#define MSORT(LIMIT, FIRST, LAST, RANK, LESS) \
+  do { \
+    const size_t N = LAST - FIRST; \
+    if (N <= (size_t) (LIMIT)) \
+      sort (FIRST, LAST, LESS); \
+    else \
+      rsort (FIRST, LAST, RANK); \
+  } while (0)
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/random.h b/src/sat/cadical/random.h
new file mode 100644
index 000000000..62fe5ed19
--- /dev/null
+++ b/src/sat/cadical/random.h
@@ -0,0 +1,50 @@
+#ifndef _random_h_INCLUDED
+#define _random_h_INCLUDED
+
+#include "global.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+ABC_NAMESPACE_HEADER_START
+
+typedef uint64_t generator;
+
+static inline uint64_t kissat_next_random64 (generator *rng) {
+  *rng *= 6364136223846793005ul;
+  *rng += 1442695040888963407ul;
+  return *rng;
+}
+
+static inline unsigned kissat_next_random32 (generator *rng) {
+  return kissat_next_random64 (rng) >> 32;
+}
+
+static inline unsigned kissat_pick_random (generator *rng, unsigned l,
+                                           unsigned r) {
+  CADICAL_assert (l <= r);
+  if (l == r)
+    return l;
+  const unsigned delta = r - l;
+  const unsigned tmp = kissat_next_random32 (rng);
+  const double fraction = tmp / 4294967296.0;
+  CADICAL_assert (0 <= fraction), CADICAL_assert (fraction < 1);
+  const unsigned scaled = delta * fraction;
+  CADICAL_assert (scaled < delta);
+  const unsigned res = l + scaled;
+  CADICAL_assert (l <= res), CADICAL_assert (res < r);
+  return res;
+}
+
+static inline bool kissat_pick_bool (generator *rng) {
+  return kissat_pick_random (rng, 0, 2);
+}
+
+static inline double kissat_pick_double (generator *rng) {
+  return kissat_next_random32 (rng) / 4294967296.0;
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/random.hpp b/src/sat/cadical/random.hpp
new file mode 100644
index 000000000..a5c78d38a
--- /dev/null
+++ b/src/sat/cadical/random.hpp
@@ -0,0 +1,104 @@
+#ifndef _random_hpp_INCLUDED
+#define _random_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdint>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+// Random number generator.
+
+namespace CaDiCaL {
+
+class Random {
+
+  uint64_t state;
+
+  void add (uint64_t a) {
+    if (!(state += a))
+      state = 1;
+    next ();
+  }
+
+public:
+  // Without argument use a machine, process and time dependent seed.
+  //
+  Random ();
+
+  Random (uint64_t seed) : state (seed) {}
+  void operator= (uint64_t seed) { state = seed; }
+  Random (const Random &other) : state (other.seed ()) {}
+
+  void operator+= (uint64_t a) { add (a); }
+  uint64_t seed () const { return state; }
+
+  uint64_t next () {
+    state *= 6364136223846793005ul;
+    state += 1442695040888963407ul;
+    CADICAL_assert (state);
+    return state;
+  }
+
+  uint32_t generate () {
+    next ();
+    return state >> 32;
+  }
+  int generate_int () { return (int) generate (); }
+  bool generate_bool () { return generate () < 2147483648u; }
+
+  // Generate 'double' value in the range '[0,1]' excluding '1'.
+  //
+  double generate_double () { return generate () / 4294967295.0; }
+
+  // Generate 'int' value in the range '[l,r]'.
+  //
+  int pick_int (int l, int r) {
+    CADICAL_assert (l <= r);
+    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;
+    CADICAL_assert (l <= res);
+    CADICAL_assert (res <= r);
+    return res;
+  }
+
+  int pick_log (int l, int r) {
+    CADICAL_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;
+    CADICAL_assert (l <= res), CADICAL_assert (res <= r);
+    return res;
+  }
+
+  // Generate 'double' value in the range '[l,r]'.
+  //
+  double pick_double (double l, double r) {
+    CADICAL_assert (l <= r);
+    double res = (r - l) * generate_double ();
+    res += l;
+    CADICAL_assert (l <= res);
+    CADICAL_assert (res <= r);
+    return res;
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/range.hpp b/src/sat/cadical/range.hpp
new file mode 100644
index 000000000..7049dab42
--- /dev/null
+++ b/src/sat/cadical/range.hpp
@@ -0,0 +1,105 @@
+#ifndef _range_hpp_INCLUDED
+#define _range_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cassert>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+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, thus 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 CADICAL_assert (n >= 0), iterator (inc (0)); }
+  iterator end () const { return CADICAL_assert (n >= 0), iterator (inc (n)); }
+  Range (int &m) : n (m) { CADICAL_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 CADICAL_assert (n >= 0), iterator (inc (0)); }
+  iterator end () const { return CADICAL_assert (n >= 0), iterator (inc (n)); }
+  Sange (int &m) : n (m) { CADICAL_assert (m >= 0); }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/reap.hpp b/src/sat/cadical/reap.hpp
new file mode 100644
index 000000000..1ea10e6e3
--- /dev/null
+++ b/src/sat/cadical/reap.hpp
@@ -0,0 +1,34 @@
+#ifndef _reap_h_INCLUDED
+#define _reap_h_INCLUDED
+
+#include "global.h"
+
+#include <cstddef>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+class Reap {
+public:
+  Reap ();
+  void init ();
+  void release ();
+  inline bool empty () { return !num_elements; }
+
+  inline size_t size () { return num_elements; }
+
+  void push (unsigned);
+  void clear ();
+  unsigned pop ();
+
+private:
+  size_t num_elements;
+  unsigned last_deleted;
+  unsigned min_bucket;
+  unsigned max_bucket;
+  std::vector<unsigned> buckets[33];
+};
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/reluctant.hpp b/src/sat/cadical/reluctant.hpp
new file mode 100644
index 000000000..495382b56
--- /dev/null
+++ b/src/sat/cadical/reluctant.hpp
@@ -0,0 +1,88 @@
+#ifndef _reluctant_hpp_INCLUDED
+#define _reluctant_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cassert>
+#include <cstdint>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// This is Donald Knuth's version of the Luby restart sequence which he
+// called 'reluctant doubling'.  His bit-twiddling formulation in line (DK)
+// requires to keep two words around which are updated every time the
+// reluctant doubling sequence is advanced.  The original version in the
+// literature uses a complex recursive function which computes the length of
+// the next inactive sub-sequence every time (but is state-less).
+//
+// In our code we incorporate a base interval 'period' and only after period
+// many calls to 'tick' times the current sequence value we update the
+// reluctant doubling sequence value.  The 'tick' call is decoupled from
+// the activation signal of the sequence (the 'bool ()' operator) through
+// 'trigger'.  It is also possible to set an upper limit to the length of an
+// inactive sub-sequence.  If that limit is reached the whole reluctant
+// doubling sequence starts over with the initial values.
+
+class Reluctant {
+
+  uint64_t u, v, limit;
+  uint64_t period, countdown;
+  bool trigger, limited;
+
+public:
+  Reluctant () : period (0), trigger (false) {}
+
+  void enable (int p, int64_t l) {
+    CADICAL_assert (p > 0);
+    u = v = 1;
+    period = countdown = p;
+    trigger = false;
+    if (l <= 0)
+      limited = false;
+    else
+      limited = true, limit = l;
+  };
+
+  void disable () { period = 0, trigger = false; }
+
+  // Increments the count until the 'period' is hit.  Then it performs the
+  // actual increment of reluctant doubling.  This gives the common 'Luby'
+  // sequence with the specified base interval period.  As soon the limit is
+  // reached (countdown goes to zero) we remember this event and then
+  // disable updating the reluctant sequence until the signal is delivered.
+
+  void tick () {
+
+    if (!period)
+      return; // disabled
+    if (trigger)
+      return; // already triggered
+    if (--countdown)
+      return; // not there yet
+
+    if ((u & -u) == v)
+      u = u + 1, v = 1;
+    else
+      v = 2 * v; // (DK)
+
+    if (limited && v >= limit)
+      u = v = 1;
+    countdown = v * period;
+    trigger = true;
+  }
+
+  operator bool () {
+    if (!trigger)
+      return false;
+    trigger = false;
+    return true;
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/resources.hpp b/src/sat/cadical/resources.hpp
new file mode 100644
index 000000000..852668b32
--- /dev/null
+++ b/src/sat/cadical/resources.hpp
@@ -0,0 +1,22 @@
+#ifndef _resources_hpp_INCLUDED
+#define _resources_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdint>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+double absolute_real_time ();
+double absolute_process_time ();
+
+uint64_t maximum_resident_set_size ();
+uint64_t current_resident_set_size ();
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif // ifndef _resources_hpp_INCLUDED
diff --git a/src/sat/cadical/score.hpp b/src/sat/cadical/score.hpp
new file mode 100644
index 000000000..88196121e
--- /dev/null
+++ b/src/sat/cadical/score.hpp
@@ -0,0 +1,22 @@
+#ifndef _score_hpp_INCLUDED
+#define _score_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct score_smaller {
+  Internal *internal;
+  score_smaller (Internal *i) : internal (i) {}
+  bool operator() (unsigned a, unsigned b);
+};
+
+typedef heap<score_smaller> ScoreSchedule;
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/signal.hpp b/src/sat/cadical/signal.hpp
new file mode 100644
index 000000000..1dc2fb3b7
--- /dev/null
+++ b/src/sat/cadical/signal.hpp
@@ -0,0 +1,39 @@
+#ifndef _signal_hpp_INCLUDED
+#define _signal_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// Helper class for handling signals in applications.
+
+class Handler {
+public:
+  Handler () {}
+  virtual ~Handler () {}
+  virtual void catch_signal (int sig) = 0;
+#ifndef WIN32
+  virtual void catch_alarm ();
+#endif
+};
+
+class Signal {
+
+public:
+  static void set (Handler *);
+  static void reset ();
+#ifndef WIN32
+  static void alarm (int seconds);
+  static void reset_alarm ();
+#endif
+
+  static const char *name (int sig);
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/stack.h b/src/sat/cadical/stack.h
new file mode 100644
index 000000000..89f270388
--- /dev/null
+++ b/src/sat/cadical/stack.h
@@ -0,0 +1,116 @@
+#ifndef _stack_h_INCLUDED
+#define _stack_h_INCLUDED
+
+#include "global.h"
+
+#include <stdlib.h>
+
+ABC_NAMESPACE_HEADER_START
+
+#define STACK(TYPE) \
+  struct { \
+    TYPE *begin; \
+    TYPE *end; \
+    TYPE *allocated; \
+  }
+
+#define FULL_STACK(S) ((S).end == (S).allocated)
+#define EMPTY_STACK(S) ((S).begin == (S).end)
+#define SIZE_STACK(S) ((size_t) ((S).end - (S).begin))
+#define CAPACITY_STACK(S) ((size_t) ((S).allocated - (S).begin))
+
+#define INIT_STACK(S) \
+  do { \
+    (S).begin = (S).end = (S).allocated = 0; \
+  } while (0)
+
+#define TOP_STACK(S) (END_STACK (S)[CADICAL_assert (!EMPTY_STACK (S)), -1])
+
+#define PEEK_STACK(S, N) \
+  (BEGIN_STACK (S)[CADICAL_assert ((N) < SIZE_STACK (S)), (N)])
+
+#define POKE_STACK(S, N, E) \
+  do { \
+    PEEK_STACK (S, N) = (E); \
+  } while (0)
+
+#define POP_STACK(S) (CADICAL_assert (!EMPTY_STACK (S)), *--(S).end)
+
+#define PUSH_STACK(S, E) \
+  do { \
+    if (FULL_STACK (S)) \
+      ENLARGE_STACK (S); \
+    *(S).end++ = (E); \
+  } while (0)
+
+#define BEGIN_STACK(S) (S).begin
+
+#define END_STACK(S) (S).end
+
+#define CLEAR_STACK(S) \
+  do { \
+    (S).end = (S).begin; \
+  } while (0)
+
+#define RESIZE_STACK(S, NEW_SIZE) \
+  do { \
+    const size_t TMP_NEW_SIZE = (NEW_SIZE); \
+    CADICAL_assert (TMP_NEW_SIZE <= SIZE_STACK (S)); \
+    (S).end = (S).begin + TMP_NEW_SIZE; \
+  } while (0)
+
+#define SET_END_OF_STACK(S, P) \
+  do { \
+    CADICAL_assert (BEGIN_STACK (S) <= (P)); \
+    CADICAL_assert ((P) <= END_STACK (S)); \
+    if ((P) == END_STACK (S)) \
+      break; \
+    (S).end = (P); \
+  } while (0)
+
+#define RELEASE_STACK(S) \
+  do { \
+    DEALLOC ((S).begin, CAPACITY_STACK (S)); \
+    INIT_STACK (S); \
+  } while (0)
+
+#define REMOVE_STACK(T, S, E) \
+  do { \
+    CADICAL_assert (!EMPTY_STACK (S)); \
+    T *END_REMOVE_STACK = END_STACK (S); \
+    T *P_REMOVE_STACK = BEGIN_STACK (S); \
+    while (*P_REMOVE_STACK != (E)) { \
+      P_REMOVE_STACK++; \
+      CADICAL_assert (P_REMOVE_STACK != END_REMOVE_STACK); \
+    } \
+    P_REMOVE_STACK++; \
+    while (P_REMOVE_STACK != END_REMOVE_STACK) { \
+      P_REMOVE_STACK[-1] = *P_REMOVE_STACK; \
+      P_REMOVE_STACK++; \
+    } \
+    (S).end--; \
+  } while (0)
+
+#define all_stack(T, E, S) \
+  T E, *E##_PTR = BEGIN_STACK (S), *const E##_END = END_STACK (S); \
+  E##_PTR != E##_END && (E = *E##_PTR, true); \
+  ++E##_PTR
+
+#define all_pointers(T, E, S) \
+  T *E, *const *E##_PTR = BEGIN_STACK (S), \
+               *const *const E##_END = END_STACK (S); \
+  E##_PTR != E##_END && (E = *E##_PTR, true); \
+  ++E##_PTR
+
+// clang-format off
+
+typedef STACK (char) chars;
+typedef STACK (int) ints;
+typedef STACK (size_t) sizes;
+typedef STACK (unsigned) unsigneds;
+
+// clang-format on
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/stats.hpp b/src/sat/cadical/stats.hpp
new file mode 100644
index 000000000..4a6afa9c9
--- /dev/null
+++ b/src/sat/cadical/stats.hpp
@@ -0,0 +1,376 @@
+#ifndef _stats_hpp_INCLUDED
+#define _stats_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdint>
+#include <cstdlib>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct Stats {
+
+  Internal *internal;
+
+  int64_t vars = 0; // internal initialized variables
+
+  int64_t conflicts = 0; // generated conflicts in 'propagate'
+  int64_t decisions = 0; // number of decisions in 'decide'
+
+  struct {
+    int64_t cover = 0;       // propagated during covered clause elimination
+    int64_t instantiate = 0; // propagated during variable instantiation
+    int64_t probe = 0;       // propagated during probing
+    int64_t search = 0;      // propagated literals during search
+    int64_t transred = 0;    // propagated during transitive reduction
+    int64_t vivify = 0;      // propagated during vivification
+    int64_t walk = 0;        // propagated during local search
+  } propagations;
+
+  struct {
+    int64_t search[2] = {0};
+    int64_t factor = 0;
+    int64_t probe = 0;
+    int64_t sweep = 0;
+    int64_t ternary = 0;
+    int64_t vivify = 0;
+  } ticks;
+
+  struct {
+    int64_t ext_cb = 0; // number of times any external callback was called
+    int64_t eprop_call = 0; // number of times external_propagate was called
+    int64_t eprop_prop = 0; // number of times external propagate propagated
+    int64_t eprop_conf =
+        0; // number of times ex-propagate was already falsified
+    int64_t eprop_expl =
+        0; // number of times external propagate was explained
+    int64_t elearn_call =
+        0; // number of times external clause learning was tried
+    int64_t elearned =
+        0; // learned external clauses (incl. eprop explanations)
+    int64_t elearn_prop =
+        0; // number of learned and propagating external clauses
+    int64_t elearn_conf =
+        0; // number of learned and conflicting external clauses
+    int64_t echeck_call = 0; // number of checking found complete solutions
+  } ext_prop;
+
+  int64_t condassinit = 0; // initial assigned literals
+  int64_t condassirem = 0; // initial assigned literals for blocked
+  int64_t condassrem = 0;  // remaining assigned literals for blocked
+  int64_t condassvars = 0; // sum of active variables at initial assignment
+  int64_t condautinit = 0; // initial literals in autarky part
+  int64_t condautrem = 0;  // remaining literals in autarky part for blocked
+  int64_t condcands = 0;   // globally blocked candidate clauses
+  int64_t condcondinit = 0; // initial literals in conditional part
+  int64_t condcondrem =
+      0; // remaining literals in conditional part for blocked
+  int64_t conditioned = 0;   // globally blocked clauses eliminated
+  int64_t conditionings = 0; // globally blocked clause eliminations
+  int64_t condprops = 0;     // propagated unassigned literals
+
+  struct {
+    int64_t block = 0;   // block marked literals
+    int64_t elim = 0;    // elim marked variables
+    int64_t subsume = 0; // subsume marked variables
+    int64_t ternary = 0; // ternary marked variables
+    int64_t factor = 0;
+  } mark;
+
+  struct {
+    int64_t total = 0;
+    int64_t redundant = 0;
+    int64_t irredundant = 0;
+  } current, added; // Clauses.
+
+  struct {
+    double process = 0, real = 0;
+  } time;
+
+  struct {
+    int64_t count = 0;      // number of covered clause elimination rounds
+    int64_t asymmetric = 0; // number of asymmetric tautologies in CCE
+    int64_t blocked = 0;    // number of blocked covered tautologies
+    int64_t total = 0;      // total number of eliminated clauses
+  } cover;
+
+  struct {
+    int64_t tried = 0;
+    int64_t succeeded = 0;
+    struct {
+      int64_t one = 0, zero = 0;
+    } constant, forward, backward;
+    struct {
+      int64_t positive = 0, negative = 0;
+    } horn;
+  } lucky;
+
+  struct {
+    int64_t total = 0;    // total number of happened rephases
+    int64_t best = 0;     // how often reset to best phases
+    int64_t flipped = 0;  // how often reset phases by flipping
+    int64_t inverted = 0; // how often reset to inverted phases
+    int64_t original = 0; // how often reset to original phases
+    int64_t random = 0;   // how often randomly reset phases
+    int64_t walk = 0;     // phases improved through random walked
+  } rephased;
+
+  struct {
+    int64_t count = 0;
+    int64_t broken = 0;
+    int64_t flips = 0;
+    int64_t minimum = 0;
+  } walk;
+
+  struct {
+    int64_t count = 0;   // flushings of learned clauses counter
+    int64_t learned = 0; // flushed learned clauses
+    int64_t hyper = 0;   // flushed hyper binary/ternary clauses
+  } flush;
+
+  int64_t compacts = 0;      // number of compactifications
+  int64_t shuffled = 0;      // shuffled queues and scores
+  int64_t restarts = 0;      // actual number of happened restarts
+  int64_t restartlevels = 0; // levels at restart
+  int64_t restartstable = 0; // actual number of happened restarts
+  int64_t stabphases = 0;    // number of stabilization phases
+  int64_t stabconflicts =
+      0;                    // number of search conflicts during stabilizing
+  int64_t rescored = 0;     // number of times scores were rescored
+  int64_t reused = 0;       // number of reused trails
+  int64_t reusedlevels = 0; // reused levels at restart
+  int64_t reusedstable = 0; // number of reused trails during stabilizing
+  int64_t sections = 0;     // 'section' counter
+  int64_t chrono = 0;       // chronological backtracks
+  int64_t backtracks = 0;   // number of backtracks
+  int64_t improvedglue = 0; // improved glue during bumping
+  int64_t promoted1 = 0;    // promoted clauses to tier one
+  int64_t promoted2 = 0;    // promoted clauses to tier two
+  int64_t bumped = 0;       // seen and bumped variables in 'analyze'
+  int64_t recomputed = 0;   // recomputed glues 'recompute_glue'
+  int64_t searched = 0;     // searched decisions in 'decide'
+  int64_t reductions = 0;   // 'reduce' counter
+  int64_t reduced = 0;      // number of reduced clauses
+  int64_t reduced_sqrt = 0;
+  int64_t reduced_prct = 0;
+  int64_t collected = 0;      // number of collected bytes
+  int64_t collections = 0;    // number of garbage collections
+  int64_t hbrs = 0;           // hyper binary resolvents
+  int64_t hbrsizes = 0;       // sum of hyper resolved base clauses
+  int64_t hbreds = 0;         // redundant hyper binary resolvents
+  int64_t hbrsubs = 0;        // subsuming hyper binary resolvents
+  int64_t instried = 0;       // number of tried instantiations
+  int64_t instantiated = 0;   // number of successful instantiations
+  int64_t instrounds = 0;     // number of instantiation rounds
+  int64_t subsumed = 0;       // number of subsumed clauses
+  int64_t deduplicated = 0;   // number of removed duplicated binary clauses
+  int64_t deduplications = 0; // number of deduplication phases
+  int64_t strengthened = 0;   // number of strengthened clauses
+
+  int64_t eliminated_equi =
+      0; // number of successful equivalence eliminations
+  int64_t eliminated_and = 0; // number of successful AND gate eliminations
+  int64_t eliminated_ite = 0; // number of successful ITE gate eliminations
+  int64_t eliminated_xor = 0; // number of successful XOR gate eliminations
+  int64_t eliminated_def =
+      0; // number of successful definition eliminations
+
+  int64_t definitions_checked = 0;
+  int64_t definitions_extracted = 0;
+  int64_t definition_units = 0;
+  int64_t definition_ticks = 0;
+
+  int64_t factor = 0;
+  int64_t factored = 0;
+  int64_t factor_added = 0;
+  int64_t variables_extension = 0;
+  int64_t variables_original = 0;
+  int64_t literals_factored = 0;
+  int64_t clauses_unfactored = 0;
+  int64_t literals_unfactored = 0;
+
+  int64_t elimotfstr =
+      0; // number of on-the-fly strengthened during elimination
+  int64_t subirr = 0;     // number of subsumed irredundant clauses
+  int64_t subred = 0;     // number of subsumed redundant clauses
+  int64_t subtried = 0;   // number of tried subsumptions
+  int64_t subchecks = 0;  // number of pair-wise subsumption checks
+  int64_t subchecks2 = 0; // same but restricted to binary clauses
+  int64_t elimotfsub =
+      0; // number of on-the-fly subsumed during elimination
+  int64_t subsumerounds = 0; // number of subsumption rounds
+  int64_t subsumephases = 0; // number of scheduled subsumption phases
+  int64_t eagertried = 0; // number of traversed eager subsumed candidates
+  int64_t eagersub =
+      0; // number of eagerly subsumed recently learned clauses
+  int64_t elimres = 0;        // number of resolved clauses in BVE
+  int64_t elimrestried = 0;   // number of tried resolved clauses in BVE
+  int64_t elimfastrounds = 0; // number of elimination rounds
+  int64_t elimrounds = 0;     // number of elimination rounds
+  int64_t elimphases = 0;     // number of scheduled elimination phases
+  int64_t elimfastphases = 0; // number of scheduled elimination phases
+  int64_t elimcompleted = 0;  // number complete elimination procedures
+  int64_t elimtried = 0;      // number of variable elimination attempts
+  int64_t elimsubst = 0;  // number of eliminations through substitutions
+  int64_t elimgates = 0;  // number of gates found during elimination
+  int64_t elimequivs = 0; // number of equivalences found during elimination
+  int64_t elimands = 0;   // number of AND gates found during elimination
+  int64_t elimites = 0;   // number of ITE gates found during elimination
+  int64_t elimxors = 0;   // number of XOR gates found during elimination
+  int64_t elimbwsub = 0;  // number of eager backward subsumed clauses
+  int64_t elimbwstr = 0;  // number of eager backward strengthened clauses
+  int64_t ternary = 0;    // number of ternary resolution phases
+  int64_t ternres = 0;    // number of ternary resolutions
+  int64_t htrs = 0;       // number of hyper ternary resolvents
+  int64_t htrs2 = 0;      // number of binary hyper ternary resolvents
+  int64_t htrs3 = 0;      // number of ternary hyper ternary resolvents
+  int64_t decompositions = 0; // number of SCC + ELS
+  int64_t vivifications = 0;  // number of vivifications
+  int64_t vivifychecks = 0;   // checked clauses during vivification
+  int64_t vivifydecs = 0;     // vivification decisions
+  int64_t vivifyreused = 0;   // reused vivification decisions
+  int64_t vivifysched = 0;    // scheduled clauses for vivification
+  int64_t vivifysubs = 0;     // subsumed clauses during vivification
+  int64_t vivifysubred = 0;   // subsumed clauses during vivification
+  int64_t vivifysubirr = 0;   // subsumed clauses during vivification
+  int64_t vivifystrs = 0;     // strengthened clauses during vivification
+  int64_t vivifystrirr = 0;   // strengthened irredundant clause
+  int64_t vivifystred1 = 0;   // strengthened redundant clause (1)
+  int64_t vivifystred2 = 0;   // strengthened redundant clause (2)
+  int64_t vivifystred3 = 0;   // strengthened redundant clause (3)
+  int64_t vivifyunits = 0;    // units during vivification
+  int64_t vivifyimplied = 0;  // implied during vivification
+  int64_t vivifyinst = 0;     // instantiation during vivification
+  int64_t vivifydemote = 0;   // demoting during vivification
+  int64_t transreds = 0;
+  int64_t transitive = 0;
+  struct {
+    int64_t literals = 0;
+    int64_t clauses = 0;
+  } learned;
+  int64_t minimized = 0;    // minimized literals
+  int64_t shrunken = 0;     // shrunken literals
+  int64_t minishrunken = 0; // shrunken during minimization literals
+
+  int64_t irrlits = 0; // literals in irredundant clauses
+  struct {
+    int64_t bytes = 0;
+    int64_t clauses = 0;
+    int64_t literals = 0;
+  } garbage;
+
+  int64_t sweep_units = 0;
+  int64_t sweep_flip_backbone = 0;
+  int64_t sweep_fixed_backbone = 0;
+  int64_t sweep_flipped_backbone = 0;
+  int64_t sweep_solved_backbone = 0;
+  int64_t sweep_sat_backbone = 0;
+  int64_t sweep_unsat_backbone = 0;
+  int64_t sweep_unknown_backbone = 0;
+  int64_t sweep_flip_equivalences = 0;
+  int64_t sweep_flipped_equivalences = 0;
+  int64_t sweep_sat_equivalences = 0;
+  int64_t sweep_unsat_equivalences = 0;
+  int64_t sweep_unknown_equivalences = 0;
+  int64_t sweep_solved_equivalences = 0;
+  int64_t sweep_equivalences = 0;
+  int64_t sweep_variables = 0;
+  int64_t sweep_completed = 0;
+  int64_t sweep_solved = 0;
+  int64_t sweep_sat = 0;
+  int64_t sweep_unsat = 0;
+  int64_t sweep_depth = 0;
+  int64_t sweep_environment = 0;
+  int64_t sweep_clauses = 0;
+  int64_t sweep = 0;
+
+  int64_t units = 0;           // learned unit clauses
+  int64_t binaries = 0;        // learned binary clauses
+  int64_t inprobingphases = 0; // number of scheduled probing phases
+  int64_t probingrounds = 0;   // number of probing rounds
+  int64_t inprobesuccess = 0;  // number successful probing phases
+  int64_t probed = 0;          // number of probed literals
+  int64_t failed = 0;          // number of failed literals
+  int64_t hyperunary = 0;      // hyper unary resolved unit clauses
+  int64_t probefailed = 0;     // failed literals from probing
+  int64_t transredunits = 0;   // units derived in transitive reduction
+  int64_t blockings = 0;       // number of blocked clause eliminations
+  int64_t blocked = 0;         // number of actually blocked clauses
+  int64_t blockres = 0;        // number of resolutions during blocking
+  int64_t blockcands = 0;      // number of clause / pivot pairs tried
+  int64_t blockpured = 0; // number of clauses blocked through pure literals
+  int64_t blockpurelits = 0; // number of pure literals
+  int64_t extensions = 0;    // number of extended witnesses
+  int64_t extended = 0;      // number of flipped literals during extension
+  int64_t weakened = 0;      // number of clauses pushed to extension stack
+  int64_t weakenedlen = 0;   // lengths of weakened clauses
+  int64_t restorations = 0;  // number of restore calls
+  int64_t restored = 0;      // number of restored clauses
+  int64_t reactivated = 0;   // number of reactivated clauses
+  int64_t restoredlits = 0;  // number of restored literals
+
+  int64_t preprocessings = 0;
+
+  int64_t ilbtriggers = 0;
+  int64_t ilbsuccess = 0;
+  int64_t levelsreused = 0;
+  int64_t literalsreused = 0;
+  int64_t assumptionsreused = 0;
+  int64_t tierecomputed = 0; // number of tier recomputation;
+
+  struct {
+    int64_t fixed = 0;          // number of top level assigned variables
+    int64_t eliminated = 0;     // number of eliminated variables
+    int64_t fasteliminated = 0; // number of fast eliminated variables only
+    int64_t substituted = 0;    // number of substituted variables
+    int64_t pure = 0;           // number of pure literals
+  } all, now;
+
+  struct {
+    int64_t strengthened = 0; // number of clauses strengthened during OTFS
+    int64_t subsumed = 0;     // number of clauses subsumed by OTFS
+  } otfs;
+
+  int64_t unused = 0;   // number of unused variables
+  int64_t active = 0;   // number of active variables
+  int64_t inactive = 0; // number of inactive variables
+  std::vector<uint64_t> bump_used = {0, 0};
+  std::vector<std::vector<uint64_t>> used; // used clauses in focused mode
+
+  struct {
+    int64_t gates = 0;
+    int64_t ands = 0;
+    int64_t ites = 0;
+    int64_t xors = 0;
+    int64_t units = 0;
+    int64_t congruent = 0;
+    int64_t rounds = 0;
+    int64_t unary_and = 0;
+    int64_t unaries = 0;
+    int64_t rewritten_ands = 0;
+    int64_t simplified = 0;
+    int64_t simplified_ands = 0;
+    int64_t simplified_xors = 0;
+    int64_t simplified_ites = 0;
+    int64_t subsumed = 0;
+    int64_t trivial_ite = 0;
+    int64_t unary_ites = 0;
+  } congruence;
+
+  Stats ();
+
+  void print (Internal *);
+};
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/sweep.hpp b/src/sat/cadical/sweep.hpp
new file mode 100644
index 000000000..ad093e070
--- /dev/null
+++ b/src/sat/cadical/sweep.hpp
@@ -0,0 +1,67 @@
+#ifndef _sweep_hpp_INCLUDED
+#define _sweep_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct sweep_proof_clause {
+  unsigned sweep_id; // index for sweeper.clauses
+  int64_t cad_id;    // cadical id
+  unsigned kit_id;   // cadical_kitten id
+  bool learned;
+  vector<int> literals;
+  vector<unsigned> chain; // lrat
+};
+
+struct sweep_blocked_clause {
+  int blit;
+  int64_t id;
+  vector<int> literals;
+};
+
+struct sweep_binary {
+  int lit;
+  int other;
+  int64_t id;
+};
+
+struct Sweeper {
+  Sweeper (Internal *internal);
+  ~Sweeper ();
+  Internal *internal;
+  Random random;
+  vector<unsigned> depths;
+  int *reprs;
+  vector<int> next, prev;
+  int first, last, blit;
+  unsigned encoded;
+  unsigned save;
+  vector<int> vars;
+  vector<Clause *> clauses;
+  vector<sweep_blocked_clause> blocked_clauses;
+  bool flush_blocked_clauses;
+  vector<int> blockable;
+  vector<int> clause;
+  vector<int> propagate;
+  vector<int> backbone;
+  vector<int> partition;
+  vector<bool> prev_units;
+  vector<sweep_binary> binaries;
+  vector<sweep_proof_clause> core[2];
+  uint64_t current_ticks;
+  struct {
+    uint64_t ticks;
+    unsigned clauses, depth, vars;
+  } limit;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/terminal.hpp b/src/sat/cadical/terminal.hpp
new file mode 100644
index 000000000..a99346b7c
--- /dev/null
+++ b/src/sat/cadical/terminal.hpp
@@ -0,0 +1,104 @@
+#ifndef _terminal_hpp_INCLUDED
+#define _terminal_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+class Terminal {
+
+  FILE *file;         // 'stdout' or 'stderr'
+  bool connected;     // Connected to terminal.
+  bool use_colors;    // Use colors.
+  bool reset_on_exit; // Reset on exit.
+
+  void escape () {
+    CADICAL_assert (connected);
+    fputs ("\033[", file);
+  }
+
+  void color (int color, bool bright) {
+    if (!use_colors)
+      return;
+    CADICAL_assert (connected);
+    escape ();
+    fputc (bright ? '1' : '0', file);
+    fprintf (file, ";%dm", color);
+    fflush (file);
+  }
+
+  void code (const char *str) {
+    if (!use_colors)
+      return;
+    if (!connected)
+      return;
+    escape ();
+    fputs (str, file);
+    fflush (file);
+  }
+
+public:
+  Terminal (FILE *file);
+  ~Terminal ();
+
+  void disable (); // Assume disconnected in any case.
+  void force_colors ();
+  void force_no_colors ();
+  void force_reset_on_exit ();
+
+  bool colors () { return use_colors; }
+
+  operator bool () const { return connected; }
+
+  void red (bool bright = false) { color (31, bright); }
+  void green (bool bright = false) { color (32, bright); }
+  void yellow (bool bright = false) { color (33, bright); }
+  void blue (bool bright = false) { color (34, bright); }
+  void magenta (bool bright = false) { color (35, bright); }
+  void black (bool bright = false) { color (90, bright); }
+  void cyan (bool bright = false) { color (96, bright); }
+
+  void bold () { code ("1m"); }
+  void normal () { code ("0m"); }
+  void inverse () { code ("7m"); }
+  void underline () { code ("4m"); }
+
+#define MODIFY(CODE) (use_colors ? "\033[" CODE "m" : "")
+
+  const char *bright_magenta_code () { return MODIFY ("1;35"); }
+  const char *magenta_code () { return MODIFY ("0;35"); }
+  const char *blue_code () { return MODIFY ("0;34"); }
+  const char *bright_blue_code () { return MODIFY ("1;34"); }
+  const char *yellow_code () { return MODIFY ("0;33"); }
+  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"); }
+
+  void cursor (bool on) { code (on ? "?25h" : "?25l"); }
+
+  void erase_until_end_of_line () { code ("K"); }
+
+  void erase_line_if_connected_otherwise_new_line () {
+    if (connected)
+      code ("1G");
+    else
+      fputc ('\n', file), fflush (file);
+  }
+
+  void reset ();
+};
+
+extern Terminal tout; // Terminal of 'stdout' (file descriptor '1')
+extern Terminal terr; // Terminal of 'stderr' (file descriptor '2')
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/testing.hpp b/src/sat/cadical/testing.hpp
new file mode 100644
index 000000000..f90569e5c
--- /dev/null
+++ b/src/sat/cadical/testing.hpp
@@ -0,0 +1,30 @@
+#ifndef _testing_hpp_INCLUDED
+#define _testing_hpp_INCLUDED
+
+#include "global.h"
+
+// This class provides access to 'internal' which should only be used for
+// internal testing and not for any other purpose as 'internal' is supposed
+// to be hidden.
+
+#include "cadical.hpp"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+class Testing {
+  Solver *solver;
+
+public:
+  Testing (Solver &s) : solver (&s) {}
+  Testing (Solver *s) : solver (s) {}
+  Internal *internal () { return solver->internal; }
+  External *external () { return solver->external; }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/tracer.hpp b/src/sat/cadical/tracer.hpp
new file mode 100644
index 000000000..d1a9f1137
--- /dev/null
+++ b/src/sat/cadical/tracer.hpp
@@ -0,0 +1,183 @@
+#ifndef _tracer_hpp_INCLUDED
+#define _tracer_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cstdint>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Internal;
+
+enum ConclusionType { CONFLICT = 1, ASSUMPTIONS = 2, CONSTRAINT = 4 };
+
+// Proof tracer class to observer all possible proof events,
+// such as added or deleted clauses.
+// An implementation can decide on which events to act.
+//
+class Tracer {
+
+public:
+  Tracer () {}
+  virtual ~Tracer () {}
+
+  /*------------------------------------------------------------------------*/
+  /*                                                                        */
+  /*                            Basic Events */
+  /*                                                                        */
+  /*------------------------------------------------------------------------*/
+
+  // Notify the tracer that a original clause has been added.
+  // Includes ID and whether the clause is redundant or irredundant
+  // Arguments: ID, redundant, clause, restored
+  //
+  virtual void add_original_clause (int64_t, bool, const std::vector<int> &,
+                                    bool = false) {}
+
+  // Notify the observer that a new clause has been derived.
+  // Includes ID and whether the clause is redundant or irredundant
+  // If antecedents are derived they will be included here.
+  // Arguments: ID, redundant, clause, antecedents
+  //
+  virtual void add_derived_clause (int64_t, bool, const std::vector<int> &,
+                                   const std::vector<int64_t> &) {}
+
+  // Notify the observer that a clause is deleted.
+  // Includes ID and redundant/irredundant
+  // Arguments: ID, redundant, clause
+  //
+  virtual void delete_clause (int64_t, bool, const std::vector<int> &) {}
+
+  // Notify the observer that a clause is deleted.
+  // Includes ID and redundant/irredundant
+  // Arguments: ID, redundant, clause
+  //
+  virtual void demote_clause (uint64_t, const std::vector<int> &) {}
+
+  // Notify the observer to remember that the clause might be restored later
+  // Arguments: ID, clause
+  //
+  virtual void weaken_minus (int64_t, const std::vector<int> &) {}
+
+  // Notify the observer that a clause is strengthened
+  // Arguments: ID
+  //
+  virtual void strengthen (int64_t) {}
+
+  // Notify the observer that the solve call ends with status StatusType
+  // If the status is UNSAT and an empty clause has been derived, the second
+  // argument will contain its id.
+  // Note that the empty clause is already added through add_derived_clause
+  // and finalized with finalize_clause
+  // Arguments: int, ID
+  //
+  virtual void report_status (int, int64_t) {}
+
+  /*------------------------------------------------------------------------*/
+  /*                                                                        */
+  /*                   Specifically non-incremental */
+  /*                                                                        */
+  /*------------------------------------------------------------------------*/
+
+  // Notify the observer that a clause is finalized.
+  // Arguments: ID, clause
+  //
+  virtual void finalize_clause (int64_t, const std::vector<int> &) {}
+
+  // Notify the observer that the proof begins with a set of reserved ids
+  // for original clauses. Given ID is the first derived clause ID.
+  // Arguments: ID
+  //
+  virtual void begin_proof (int64_t) {}
+
+  /*------------------------------------------------------------------------*/
+  /*                                                                        */
+  /*                      Specifically incremental */
+  /*                                                                        */
+  /*------------------------------------------------------------------------*/
+
+  // Notify the observer that an assumption has been added
+  // Arguments: assumption_literal
+  //
+  virtual void solve_query () {}
+
+  // Notify the observer that an assumption has been added
+  // Arguments: assumption_literal
+  //
+  virtual void add_assumption (int) {}
+
+  // Notify the observer that a constraint has been added
+  // Arguments: constraint_clause
+  //
+  virtual void add_constraint (const std::vector<int> &) {}
+
+  // Notify the observer that assumptions and constraints are reset
+  //
+  virtual void reset_assumptions () {}
+
+  // Notify the observer that this clause could be derived, which
+  // is the negation of a core of failing assumptions/constraints.
+  // If antecedents are derived they will be included here.
+  // Arguments: ID, clause, antecedents
+  //
+  virtual void add_assumption_clause (int64_t, const std::vector<int> &,
+                                      const std::vector<int64_t> &) {}
+
+  // Notify the observer that conclude unsat was requested.
+  // will give either the id of the empty clause, the id of a failing
+  // assumption clause or the ids of the failing constrain clauses
+  // Arguments: conclusion_type, clause_ids
+  //
+  virtual void conclude_unsat (ConclusionType,
+                               const std::vector<int64_t> &) {}
+
+  // Notify the observer that conclude sat was requested.
+  // will give the complete model as a vector.
+  //
+  virtual void conclude_sat (const std::vector<int> &) {}
+
+  // Notify the observer that conclude unknown was requested.
+  // will give the current trail as a vector.
+  //
+  virtual void conclude_unknown (const std::vector<int> &) {}
+};
+
+/*--------------------------------------------------------------------------*/
+
+// Following tracers for internal use.
+
+struct InternalTracer : public Tracer {
+public:
+  InternalTracer () {}
+  virtual ~InternalTracer () {}
+
+  virtual void connect_internal (Internal *) {}
+};
+
+class StatTracer : public InternalTracer {
+public:
+  StatTracer () {}
+  virtual ~StatTracer () {}
+
+  virtual void print_stats () {}
+};
+
+class FileTracer : public InternalTracer {
+
+public:
+  FileTracer () {}
+  virtual ~FileTracer () {}
+
+  virtual bool closed () = 0;
+  virtual void close (bool print = false) = 0;
+  virtual void flush (bool print = false) = 0;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/util.hpp b/src/sat/cadical/util.hpp
new file mode 100644
index 000000000..3882c6ede
--- /dev/null
+++ b/src/sat/cadical/util.hpp
@@ -0,0 +1,173 @@
+#ifndef _util_hpp_INCLUDED
+#define _util_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cassert>
+#include <cstdint>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+using namespace std;
+
+// Common simple utility functions independent from 'Internal'.
+
+/*------------------------------------------------------------------------*/
+
+inline double relative (double a, double b) { return b ? a / b : 0; }
+inline double percent (double a, double b) { return relative (100 * a, b); }
+inline int sign (int lit) { return (lit > 0) - (lit < 0); }
+inline unsigned bign (int lit) { return 1 + (lit < 0); }
+
+/*------------------------------------------------------------------------*/
+
+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 &);
+
+/*------------------------------------------------------------------------*/
+
+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) {
+  CADICAL_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;
+  CADICAL_assert (is_power_of_two (alignment));
+  const size_t mask = alignment - 1;
+  if (res & mask)
+    res = (res | mask) + 1;
+  CADICAL_assert (aligned (res, alignment));
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline bool parity (unsigned a) {
+  CADICAL_assert (sizeof a == 4);
+  unsigned tmp = a;
+  tmp ^= (tmp >> 16);
+  tmp ^= (tmp >> 8);
+  tmp ^= (tmp >> 4);
+  tmp ^= (tmp >> 2);
+  tmp ^= (tmp >> 1);
+  return tmp & 1;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The standard 'Effective STL' way (though not guaranteed) to clear a
+// vector and reduce its capacity to zero, thus deallocating all its
+// internal memory.  This is quite important for keeping the actual
+// allocated size of watched and occurrence lists small particularly during
+// bounded variable elimination where many clauses are added and removed.
+
+template <class T> void erase_vector (std::vector<T> &v) {
+  if (v.capacity ()) {
+    std::vector<T> ().swap (v);
+  }
+  CADICAL_assert (!v.capacity ()); // not guaranteed though
+}
+
+// The standard 'Effective STL' way (though not guaranteed) to shrink the
+// capacity of a vector to its size thus kind of releasing all the internal
+// excess memory not needed at the moment any more.
+
+template <class T> void shrink_vector (std::vector<T> &v) {
+  if (v.capacity () > v.size ()) {
+    std::vector<T> (v).swap (v);
+  }
+  CADICAL_assert (v.capacity () == v.size ()); // not guaranteed though
+}
+
+template <class T>
+static void enlarge_init (vector<T> &v, size_t N, const T &i) {
+  if (v.size () < N)
+    v.resize (N, i);
+}
+
+template <class T> static void enlarge_only (vector<T> &v, size_t N) {
+  if (v.size () < N)
+    v.resize (N, T ());
+}
+
+template <class T> static void enlarge_zero (vector<T> &v, size_t N) {
+  enlarge_init (v, N, (const T &) 0);
+}
+
+// Clean-up class for bad_alloc error safety.
+
+template <typename T> struct DeferDeleteArray {
+  T *data;
+  DeferDeleteArray (T *t) : data (t) {}
+  ~DeferDeleteArray () { delete[] data; }
+  void release () { data = nullptr; }
+  void free () {
+    delete[] data;
+    data = nullptr;
+  }
+};
+
+template <typename T> struct DeferDeletePtr {
+  T *data;
+  DeferDeletePtr (T *t) : data (t) {}
+  ~DeferDeletePtr () { delete data; }
+  void release () { data = nullptr; }
+  void free () {
+    delete data;
+    data = nullptr;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+template <class T> inline void clear_n (T *base, size_t n) {
+  memset (base, 0, sizeof (T) * n);
+}
+
+/*------------------------------------------------------------------------*/
+
+// These are options both to 'cadical' and 'mobical'.  After wasting some
+// on not remembering the spelling (British vs American), nor singular vs
+// plural and then wanted to use '--color=false', and '--colours=0' too, I
+// just factored this out into these two utility functions.
+
+bool is_color_option (const char *arg);    // --color, --colour, ...
+bool is_no_color_option (const char *arg); // --no-color, --no-colour, ...
+
+/*------------------------------------------------------------------------*/
+
+uint64_t hash_string (const char *str);
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/var.hpp b/src/sat/cadical/var.hpp
new file mode 100644
index 000000000..8793afbc4
--- /dev/null
+++ b/src/sat/cadical/var.hpp
@@ -0,0 +1,28 @@
+#ifndef _var_hpp_INCLUDED
+#define _var_hpp_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Clause;
+
+// This structure captures data associated with an assigned variable.
+
+struct Var {
+
+  // Note that none of these members is valid unless the variable is
+  // assigned.  During unassigning a variable we do not reset it.
+
+  int level;      // decision level
+  int trail;      // trail height at assignment
+  Clause *reason; // implication graph edge during search
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/veripbtracer.hpp b/src/sat/cadical/veripbtracer.hpp
new file mode 100644
index 000000000..b9c47362f
--- /dev/null
+++ b/src/sat/cadical/veripbtracer.hpp
@@ -0,0 +1,108 @@
+#ifndef _veripbtracer_h_INCLUDED
+#define _veripbtracer_h_INCLUDED
+
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+class FileTracer;
+
+namespace CaDiCaL {
+
+struct HashId {
+  HashId *next;  // collision chain link for hash table
+  uint64_t hash; // previously computed full 64-bit hash
+  int64_t id;    // id of clause
+};
+
+class VeripbTracer : public FileTracer {
+
+  Internal *internal;
+  File *file;
+#ifndef CADICAL_NDEBUG
+  bool binary;
+#endif
+  bool with_antecedents;
+  bool checked_deletions;
+
+  // hash table for checked deletions
+  //
+  uint64_t num_clauses;  // number of clauses in hash table
+  uint64_t size_clauses; // size of clause hash table
+  HashId **clauses;      // hash table of clauses
+
+  static const unsigned num_nonces = 4;
+
+  uint64_t nonces[num_nonces]; // random numbers for hashing
+  uint64_t last_hash;          // last computed hash value of clause
+  int64_t last_id;             // id of the last added clause
+  HashId *last_clause;
+  uint64_t compute_hash (int64_t); // compute and save hash value of clause
+
+  HashId *new_clause ();
+  void delete_clause (HashId *);
+
+  // Reduce hash value to the actual size.
+  //
+  static uint64_t reduce_hash (uint64_t hash, uint64_t size);
+
+  void enlarge_clauses (); // enlarge hash table for clauses
+  void insert ();          // insert clause in hash table
+  bool
+  find_and_delete (const int64_t); // find clause position in hash table
+
+#ifndef CADICAL_QUIET
+  int64_t added, deleted;
+#endif
+  vector<int64_t> delete_ids;
+
+  void put_binary_zero ();
+  void put_binary_lit (int external_lit);
+  void put_binary_id (int64_t id, bool = false);
+
+  // support veriPB
+  void veripb_add_derived_clause (int64_t, bool redundant,
+                                  const vector<int> &clause,
+                                  const vector<int64_t> &chain);
+  void veripb_add_derived_clause (int64_t, bool redundant,
+                                  const vector<int> &clause);
+  void veripb_begin_proof (int64_t reserved_ids);
+  void veripb_delete_clause (int64_t id, bool redundant);
+  void veripb_report_status (bool unsat, int64_t conflict_id);
+  void veripb_strengthen (int64_t);
+
+public:
+  // own and delete 'file'
+  VeripbTracer (Internal *, File *file, bool, bool, bool);
+  ~VeripbTracer ();
+
+  void connect_internal (Internal *i) override;
+  void begin_proof (int64_t) override;
+
+  void add_original_clause (int64_t, bool, const vector<int> &,
+                            bool = false) override {} // skip
+
+  void add_derived_clause (int64_t, bool, const vector<int> &,
+                           const vector<int64_t> &) override;
+
+  void delete_clause (int64_t, bool, const vector<int> &) override;
+  void finalize_clause (int64_t, const vector<int> &) override {} // skip
+
+  void report_status (int, int64_t) override;
+
+  void weaken_minus (int64_t, const vector<int> &) override;
+  void strengthen (int64_t) override;
+
+#ifndef CADICAL_QUIET
+  void print_statistics ();
+#endif
+  bool closed () override;
+  void close (bool) override;
+  void flush (bool) override;
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/version.hpp b/src/sat/cadical/version.hpp
new file mode 100644
index 000000000..d63aefa35
--- /dev/null
+++ b/src/sat/cadical/version.hpp
@@ -0,0 +1,19 @@
+#include "global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+const char *version ();
+const char *copyright ();
+const char *authors ();
+const char *affiliations ();
+const char *signature ();
+const char *identifier ();
+const char *compiler ();
+const char *date ();
+const char *flags ();
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
diff --git a/src/sat/cadical/vivify.hpp b/src/sat/cadical/vivify.hpp
new file mode 100644
index 000000000..a5c6c0e10
--- /dev/null
+++ b/src/sat/cadical/vivify.hpp
@@ -0,0 +1,68 @@
+#ifndef _vivify_hpp_INCLUDED
+#define _vivify_hpp_INCLUDED
+
+#include "global.h"
+
+#include "util.hpp"
+
+#include <array>
+#include <cstdint>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+struct Clause;
+
+enum class Vivify_Mode { TIER1, TIER2, TIER3, IRREDUNDANT };
+
+#define COUNTREF_COUNTS 2
+
+struct vivify_ref {
+  bool vivify;
+  std::size_t size;
+  uint64_t count[COUNTREF_COUNTS];
+  Clause *clause;
+};
+
+// In the vivifier structure, we put the schedules in an array in order to
+// be able to iterate over them, but we provide the reference to them to
+// make sure that you do need to remember the order.
+struct Vivifier {
+  std::array<std::vector<vivify_ref>, 4> refs_schedules;
+  std::vector<vivify_ref> &refs_schedule_tier1, &refs_schedule_tier2,
+      &refs_schedule_tier3, &refs_schedule_irred;
+  std::array<std::vector<Clause *>, 4> schedules;
+  std::vector<Clause *> &schedule_tier1, &schedule_tier2, &schedule_tier3,
+      &schedule_irred;
+  std::vector<int> sorted;
+  Vivify_Mode tier;
+  char tag;
+  int tier1_limit;
+  int tier2_limit;
+  int64_t ticks;
+  std::vector<std::tuple<int, Clause *, bool>> lrat_stack;
+  Vivifier (Vivify_Mode mode_tier)
+      : refs_schedule_tier1 (refs_schedules[0]),
+        refs_schedule_tier2 (refs_schedules[1]),
+        refs_schedule_tier3 (refs_schedules[2]),
+        refs_schedule_irred (refs_schedules[3]),
+        schedule_tier1 (schedules[0]), schedule_tier2 (schedules[1]),
+        schedule_tier3 (schedules[2]), schedule_irred (schedules[3]),
+        tier (mode_tier) {}
+
+  void erase () {
+    erase_vector (refs_schedule_tier1);
+    erase_vector (refs_schedule_tier2);
+    erase_vector (refs_schedule_tier3);
+    erase_vector (refs_schedule_irred);
+    erase_vector (sorted);
+  }
+};
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/cadical/watch.hpp b/src/sat/cadical/watch.hpp
new file mode 100644
index 000000000..1acab094b
--- /dev/null
+++ b/src/sat/cadical/watch.hpp
@@ -0,0 +1,78 @@
+#ifndef _watch_hpp_INCLUDED
+#define _watch_hpp_INCLUDED
+
+#include "global.h"
+
+#include <cassert>
+#include <vector>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace CaDiCaL {
+
+// Watch lists for CDCL search.  The blocking literal (see also comments
+// related to 'propagate') is a must and thus combining that with a 64 bit
+// pointer will give a 16 byte (8 byte aligned) structure anyhow, which
+// means the additional 4 bytes for the size come for free.  As alternative
+// one could use a 32-bit reference instead of the pointer which would
+// however limit the number of clauses to '2^32 - 1'.  One would also need
+// to use at least one more bit (either taken away from the variable space
+// or the clauses) to denote whether the watch is binary.
+
+// in fashion of Intel Sat 10.4230/LIPIcs.SAT.2022.8 we try to
+// guarantee the following invariant:
+// For both watches:
+// if     the watched literal is negatively assigned
+// either it will be propagated in the future
+// or     the corresponding blocking literal is positively assigned
+// and    its level is smaller than the level of the watched literal
+//
+
+struct Clause;
+
+struct Watch {
+
+  Clause *clause;
+  int blit;
+  int size;
+
+  Watch (int b, Clause *c) : clause (c), blit (b), size (c->size) {}
+  Watch () {}
+
+  bool binary () const { return size == 2; }
+};
+
+typedef vector<Watch> Watches; // of one literal
+
+typedef Watches::iterator watch_iterator;
+typedef Watches::const_iterator const_watch_iterator;
+
+inline void remove_watch (Watches &ws, Clause *clause) {
+  const auto end = ws.end ();
+  auto i = ws.begin ();
+  for (auto j = i; j != end; j++) {
+    const Watch &w = *i++ = *j;
+    if (w.clause == clause)
+      i--;
+  }
+  CADICAL_assert (i + 1 == end);
+  ws.resize (i - ws.begin ());
+}
+
+// search for the clause and updates the size marked in the watch lists
+inline void update_watch_size (Watches &ws, int blit, Clause *conflict) {
+  bool found = false;
+  const int size = conflict->size;
+  for (Watch &w : ws) {
+    if (w.clause == conflict)
+      w.size = size, w.blit = blit, found = true;
+    CADICAL_assert (w.clause->garbage || w.size == 2 || w.clause->size != 2);
+  }
+  CADICAL_assert (found), (void) found;
+}
+
+} // namespace CaDiCaL
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/LICENSE b/src/sat/kissat/LICENSE
new file mode 100644
index 000000000..f26cea22a
--- /dev/null
+++ b/src/sat/kissat/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2021-2024 Armin Biere, University of Freiburg, Germany
+Copyright (c) 2019-2021 Armin Biere, 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/sat/kissat/VERSION b/src/sat/kissat/VERSION
new file mode 100644
index 000000000..4d54daddb
--- /dev/null
+++ b/src/sat/kissat/VERSION
@@ -0,0 +1 @@
+4.0.2
diff --git a/src/sat/kissat/allocate.c b/src/sat/kissat/allocate.c
new file mode 100644
index 000000000..61f8c202f
--- /dev/null
+++ b/src/sat/kissat/allocate.c
@@ -0,0 +1,165 @@
+#include "allocate.h"
+#include "error.h"
+#include "internal.h"
+#include "logging.h"
+
+#undef LOGPREFIX
+#define LOGPREFIX "ALLOCATE"
+
+#include <string.h>
+
+#ifdef LOGGING
+#include <inttypes.h>
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+static void inc_bytes (kissat *solver, size_t bytes) {
+#ifdef METRICS
+  if (!solver)
+    return;
+  ADD (allocated_current, bytes);
+  LOG5 ("allocated_current = %s",
+        FORMAT_BYTES (solver->statistics.allocated_current));
+  if (solver->statistics.allocated_current >=
+      solver->statistics.allocated_max) {
+    solver->statistics.allocated_max = solver->statistics.allocated_current;
+    LOG5 ("allocated_max = %s",
+          FORMAT_BYTES (solver->statistics.allocated_max));
+  }
+#else
+  (void) solver;
+  (void) bytes;
+#endif
+}
+
+static void dec_bytes (kissat *solver, size_t bytes) {
+#ifdef METRICS
+  if (!solver)
+    return;
+  SUB (allocated_current, bytes);
+  LOG5 ("allocated_current = %s",
+        FORMAT_BYTES (solver->statistics.allocated_current));
+#else
+  (void) solver;
+  (void) bytes;
+#endif
+}
+
+void *kissat_malloc (kissat *solver, size_t bytes) {
+  void *res;
+  if (!bytes)
+    return 0;
+  res = malloc (bytes);
+  LOG4 ("malloc (%zu) = %p", bytes, res);
+  if (!res)
+    kissat_fatal ("out-of-memory allocating %zu bytes", bytes);
+  inc_bytes (solver, bytes);
+  return res;
+}
+
+void kissat_free (kissat *solver, void *ptr, size_t bytes) {
+  if (ptr) {
+    LOG4 ("free (%p[%zu])", ptr, bytes);
+    dec_bytes (solver, bytes);
+    free (ptr);
+  } else
+    KISSAT_assert (!bytes);
+}
+
+char *kissat_strdup (kissat *solver, const char *str) {
+  char *res = (char*)kissat_malloc (solver, strlen (str) + 1);
+  return strcpy (res, str);
+}
+
+void kissat_freestr (struct kissat *solver, char *str) {
+  KISSAT_assert (str);
+  kissat_free (solver, str, strlen (str) + 1);
+}
+
+void *kissat_nalloc (kissat *solver, size_t n, size_t size) {
+  void *res;
+  if (!n || !size)
+    return 0;
+  if (MAX_SIZE_T / size < n)
+    kissat_fatal ("invalid 'kissat_nalloc (..., %zu, %zu)' call", n, size);
+  const size_t bytes = n * size;
+  res = malloc (bytes);
+  LOG4 ("nalloc (%zu, %zu) = %p", n, size, res);
+  if (!res)
+    kissat_fatal ("out-of-memory allocating "
+                  "%zu = %zu x %zu bytes",
+                  bytes, n, size);
+  inc_bytes (solver, bytes);
+  return res;
+}
+
+void *kissat_calloc (kissat *solver, size_t n, size_t size) {
+  void *res;
+  if (!n || !size)
+    return 0;
+  if (MAX_SIZE_T / size < n)
+    kissat_fatal ("invalid 'kissat_calloc (..., %zu, %zu)' call", n, size);
+  res = calloc (n, size);
+  LOG4 ("calloc (%zu, %zu) = %p", n, size, res);
+  const size_t bytes = n * size;
+  if (!res)
+    kissat_fatal ("out-of-memory allocating "
+                  "%zu = %zu x %zu bytes",
+                  bytes, n, size);
+  inc_bytes (solver, bytes);
+  return res;
+}
+
+void kissat_dealloc (kissat *solver, void *ptr, size_t n, size_t size) {
+  if (!n || !size)
+    return;
+  if (MAX_SIZE_T / size < n)
+    kissat_fatal ("invalid 'kissat_dealloc (..., %zu, %zu)' call", n, size);
+  const size_t bytes = n * size;
+  kissat_free (solver, ptr, bytes);
+}
+
+void *kissat_realloc (kissat *solver, void *p, size_t old_bytes,
+                      size_t new_bytes) {
+  if (old_bytes == new_bytes)
+    return p;
+  if (!new_bytes) {
+    kissat_free (solver, p, old_bytes);
+    return 0;
+  }
+  dec_bytes (solver, old_bytes);
+#ifdef LOGGING
+  if (GET_OPTION (log) > 3)
+    kissat_begin_logging (solver, LOGPREFIX, "realloc (%p[%zu, %zu) = ", p,
+                          old_bytes, new_bytes);
+#endif
+  void *res = realloc (p, new_bytes);
+#ifdef LOGGING
+  if (GET_OPTION (log) > 3) {
+    printf ("%p", res);
+    kissat_end_logging ();
+  }
+#endif
+  if (new_bytes && !res)
+    kissat_fatal ("out-of-memory reallocating from %zu to %zu bytes",
+                  old_bytes, new_bytes);
+  inc_bytes (solver, new_bytes);
+  return res;
+}
+
+void *kissat_nrealloc (kissat *solver, void *p, size_t o, size_t n,
+                       size_t size) {
+  if (!size) {
+    KISSAT_assert (!p);
+    KISSAT_assert (!o);
+    return 0;
+  }
+  const size_t max = MAX_SIZE_T / size;
+  if (max < o || max < n)
+    kissat_fatal ("invalid 'kissat_nrealloc (..., %zu, %zu, %zu)' call", o,
+                  n, size);
+  return kissat_realloc (solver, p, o * size, n * size);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/allocate.h b/src/sat/kissat/allocate.h
new file mode 100644
index 000000000..bdac75bd2
--- /dev/null
+++ b/src/sat/kissat/allocate.h
@@ -0,0 +1,41 @@
+#ifndef _allocate_h_INCLUDED
+#define _allocate_h_INCLUDED
+
+#include <stdlib.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void *kissat_malloc (struct kissat *, size_t bytes);
+void kissat_free (struct kissat *, void *, size_t bytes);
+
+char *kissat_strdup (struct kissat *, const char *);
+void kissat_freestr (struct kissat *, char *);
+
+void *kissat_calloc (struct kissat *, size_t n, size_t size);
+void *kissat_nalloc (struct kissat *, size_t n, size_t size);
+void kissat_dealloc (struct kissat *, void *ptr, size_t n, size_t size);
+
+void *kissat_realloc (struct kissat *, void *, size_t old, size_t bytes);
+void *kissat_nrealloc (struct kissat *, void *, size_t o, size_t n, size_t);
+
+#define NALLOC(T, P, N)                          \
+  do { \
+    (P) = (T*) kissat_nalloc (solver, (N), sizeof *(P)); \
+  } while (0)
+
+#define CALLOC(T, P, N)                          \
+  do { \
+    (P) = (T*) kissat_calloc (solver, (N), sizeof *(P));     \
+  } while (0)
+
+#define DEALLOC(P, N) \
+  do { \
+    kissat_dealloc (solver, (P), (N), sizeof *(P)); \
+  } while (0)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/analyze.c b/src/sat/kissat/analyze.c
new file mode 100644
index 000000000..70a68ae0e
--- /dev/null
+++ b/src/sat/kissat/analyze.c
@@ -0,0 +1,583 @@
+#include "analyze.h"
+#include "backtrack.h"
+#include "bump.h"
+#include "deduce.h"
+#include "inline.h"
+#include "learn.h"
+#include "minimize.h"
+#include "print.h"
+#include "rank.h"
+#include "shrink.h"
+#include "sort.h"
+#include "tiers.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static bool one_literal_on_conflict_level (kissat *solver, clause *conflict,
+                                           unsigned *conflict_level_ptr) {
+  KISSAT_assert (conflict);
+  KISSAT_assert (conflict->size > 1);
+
+  unsigned jump_level = INVALID_LEVEL;
+  unsigned conflict_level = INVALID_LEVEL;
+  unsigned literals_on_conflict_level = 0;
+  unsigned forced_lit = INVALID_LIT;
+
+  assigned *all_assigned = solver->assigned;
+
+  unsigned *lits = conflict->lits;
+  const unsigned conflict_size = conflict->size;
+  const unsigned *const end_of_lits = lits + conflict_size;
+
+  for (const unsigned *p = lits; p != end_of_lits; p++) {
+    const unsigned lit = *p;
+    KISSAT_assert (VALUE (lit) < 0);
+    const unsigned idx = IDX (lit);
+    const unsigned lit_level = all_assigned[idx].level;
+    if (conflict_level == INVALID_LEVEL || conflict_level < lit_level) {
+      literals_on_conflict_level = 1;
+      jump_level = conflict_level;
+      conflict_level = lit_level;
+      forced_lit = lit;
+    } else {
+      if (jump_level == INVALID_LEVEL || jump_level < lit_level)
+        jump_level = lit_level;
+      if (conflict_level == lit_level)
+        literals_on_conflict_level++;
+    }
+    if (literals_on_conflict_level > 1 && conflict_level == solver->level)
+      break;
+  }
+  KISSAT_assert (conflict_level != INVALID_LEVEL);
+  KISSAT_assert (literals_on_conflict_level);
+
+  LOG ("found %u literals on conflict level %u", literals_on_conflict_level,
+       conflict_level);
+  *conflict_level_ptr = conflict_level;
+
+  if (!conflict_level) {
+    solver->inconsistent = true;
+    LOG ("learned empty clause from conflict at conflict level zero");
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    return false;
+  }
+
+  if (conflict_level < solver->level) {
+    LOG ("forced backtracking due to conflict level %u < level %u",
+         conflict_level, solver->level);
+    kissat_backtrack_after_conflict (solver, conflict_level);
+  }
+
+  if (conflict_size > 2) {
+    for (unsigned i = 0; i < 2; i++) {
+      const unsigned lit = lits[i];
+      const unsigned lit_idx = IDX (lit);
+      unsigned highest_position = i;
+      unsigned highest_literal = lit;
+      unsigned highest_level = all_assigned[lit_idx].level;
+      for (unsigned j = i + 1; j < conflict_size; j++) {
+        const unsigned other = lits[j];
+        const unsigned other_idx = IDX (other);
+        const unsigned level = all_assigned[other_idx].level;
+        if (highest_level >= level)
+          continue;
+        highest_literal = other;
+        highest_position = j;
+        highest_level = level;
+        if (highest_level == conflict_level)
+          break;
+      }
+      if (highest_position == i)
+        continue;
+      reference ref = INVALID_REF;
+      if (highest_position > 1) {
+        ref = kissat_reference_clause (solver, conflict);
+        kissat_unwatch_blocking (solver, lit, ref);
+      }
+      lits[highest_position] = lit;
+      lits[i] = highest_literal;
+      if (highest_position > 1)
+        kissat_watch_blocking (solver, lits[i], lits[!i], ref);
+    }
+  }
+
+  if (literals_on_conflict_level > 1)
+    return false;
+
+  KISSAT_assert (literals_on_conflict_level == 1);
+  KISSAT_assert (forced_lit != INVALID_LIT);
+  KISSAT_assert (jump_level != INVALID_LEVEL);
+  KISSAT_assert (jump_level < conflict_level);
+
+  LOG ("reusing conflict as driving clause of %s", LOGLIT (forced_lit));
+
+  unsigned new_level = kissat_determine_new_level (solver, jump_level);
+  kissat_backtrack_after_conflict (solver, new_level);
+
+  if (conflict_size == 2) {
+    KISSAT_assert (conflict == &solver->conflict);
+    const unsigned other = lits[0] ^ lits[1] ^ forced_lit;
+    kissat_assign_binary (solver, forced_lit, other);
+  } else {
+    const reference ref = kissat_reference_clause (solver, conflict);
+    kissat_assign_reference (solver, forced_lit, ref, conflict);
+  }
+
+  return true;
+}
+
+static inline void mark_reason_side_literal (kissat *solver,
+                                             assigned *all_assigned,
+                                             unsigned lit) {
+  const unsigned idx = IDX (lit);
+  const assigned *a = all_assigned + idx;
+  if (a->level && !a->analyzed)
+    kissat_push_analyzed (solver, all_assigned, idx);
+}
+
+static inline void analyze_reason_side_literal (kissat *solver,
+                                                size_t limit, ward *arena,
+                                                assigned *all_assigned,
+                                                unsigned lit) {
+  const unsigned idx = IDX (lit);
+  const assigned *a = all_assigned + idx;
+  KISSAT_assert (a->level);
+  KISSAT_assert (a->analyzed);
+  KISSAT_assert (a->reason != UNIT_REASON);
+  if (a->reason == DECISION_REASON)
+    return;
+  if (a->binary) {
+    const unsigned other = a->reason;
+    mark_reason_side_literal (solver, all_assigned, other);
+  } else {
+    const reference ref = a->reason;
+    KISSAT_assert (ref < SIZE_STACK (solver->arena));
+    clause *c = (clause *) (arena + ref);
+    const unsigned not_lit = NOT (lit);
+    INC (search_ticks);
+    for (all_literals_in_clause (other, c))
+      if (other != not_lit) {
+        KISSAT_assert (other != lit);
+        mark_reason_side_literal (solver, all_assigned, other);
+        if (SIZE_STACK (solver->analyzed) > limit)
+          break;
+      }
+  }
+}
+
+static void analyze_reason_side_literals (kissat *solver) {
+  if (!GET_OPTION (bump))
+    return;
+  if (!GET_OPTION (bumpreasons))
+    return;
+  if (solver->probing)
+    return;
+  if (DELAYING (bumpreasons))
+    return;
+  const double decision_rate = AVERAGE (decision_rate);
+  const int decision_rate_limit = GET_OPTION (bumpreasonsrate);
+  if (decision_rate >= decision_rate_limit) {
+    LOG ("decision rate %g >= limit %d", decision_rate,
+         decision_rate_limit);
+    return;
+  }
+  assigned *all_assigned = solver->assigned;
+#ifndef KISSAT_NDEBUG
+  for (all_stack (unsigned, lit, solver->clause))
+    KISSAT_assert (all_assigned[IDX (lit)].analyzed);
+#endif
+  LOG ("trying to bump reason side literals too");
+  const size_t saved = SIZE_STACK (solver->analyzed);
+  const size_t limit = GET_OPTION (bumpreasonslimit) * saved;
+  LOG ("analyzed already %zu literals thus limit %zu", saved, limit);
+  ward *arena = BEGIN_STACK (solver->arena);
+  for (all_stack (unsigned, lit, solver->clause)) {
+    analyze_reason_side_literal (solver, limit, arena, all_assigned, lit);
+    if (SIZE_STACK (solver->analyzed) > limit)
+      break;
+  }
+  if (SIZE_STACK (solver->analyzed) > limit) {
+    LOG ("too many additional reason side literals");
+    while (SIZE_STACK (solver->analyzed) > saved) {
+      const unsigned idx = POP_STACK (solver->analyzed);
+      struct assigned *a = all_assigned + idx;
+      LOG ("marking %s as not analyzed", LOGVAR (idx));
+      KISSAT_assert (a->analyzed);
+      a->analyzed = false;
+    }
+    BUMP_DELAY (bumpreasons);
+  } else
+    REDUCE_DELAY (bumpreasons);
+}
+
+#define RADIX_SORT_LEVELS_LIMIT 32
+
+#define RANK_LEVEL(A) (A)
+#define SMALLER_LEVEL(A, B) (RANK_LEVEL (A) < RANK_LEVEL (B))
+
+static void sort_levels (kissat *solver) {
+  unsigneds *levels = &solver->levels;
+  size_t glue = SIZE_STACK (*levels);
+  if (glue < RADIX_SORT_LEVELS_LIMIT)
+    SORT_STACK (unsigned, *levels, SMALLER_LEVEL);
+  else
+    RADIX_STACK (unsigned, unsigned, *levels, RANK_LEVEL);
+  LOG ("sorted %zu levels", glue);
+}
+
+static void sort_deduced_clause (kissat *solver) {
+  sort_levels (solver);
+#ifndef KISSAT_NDEBUG
+  const size_t size_frames = SIZE_STACK (solver->frames);
+#endif
+  frame *frames = BEGIN_STACK (solver->frames);
+  unsigned pos = 1;
+  const unsigned *const begin_levels = BEGIN_STACK (solver->levels);
+  const unsigned *const end_levels = END_STACK (solver->levels);
+  unsigned const *p = end_levels;
+  while (p != begin_levels) {
+    const unsigned level = *--p;
+    KISSAT_assert (level < size_frames);
+    frame *f = frames + level;
+    const unsigned used = f->used;
+#ifndef KISSAT_NDEBUG
+    f->saved = used;
+#endif
+    KISSAT_assert (used > 0);
+    KISSAT_assert (UINT_MAX - used >= pos);
+    f->used = pos;
+    pos += used;
+  }
+  unsigneds *clause = &solver->clause;
+  const size_t size_clause = SIZE_STACK (*clause);
+#ifndef KISSAT_NDEBUG
+  KISSAT_assert (pos == size_clause);
+#endif
+  unsigned const *begin_clause = BEGIN_STACK (*clause);
+  const unsigned *const end_clause = END_STACK (*clause);
+  KISSAT_assert (begin_clause < end_clause);
+
+  unsigneds *shadow = &solver->shadow;
+  while (SIZE_STACK (*shadow) < size_clause)
+    PUSH_STACK (*shadow, INVALID_LIT);
+
+  const unsigned not_uip = *begin_clause++;
+  POKE_STACK (*shadow, 0, not_uip);
+
+  const assigned *const assigned = solver->assigned;
+
+  for (const unsigned *p = begin_clause; p != end_clause; p++) {
+    const unsigned lit = *p;
+    const unsigned idx = IDX (lit);
+    const struct assigned *a = assigned + idx;
+    const unsigned level = a->level;
+    KISSAT_assert (level < size_frames);
+    frame *f = frames + level;
+    const unsigned pos = f->used++;
+    POKE_STACK (*shadow, pos, lit);
+  }
+
+  KISSAT_assert (size_clause == SIZE_STACK (*shadow));
+  SWAP (unsigneds, *clause, *shadow);
+
+  pos = 1;
+  p = end_levels;
+  while (p != begin_levels) {
+    const unsigned level = *--p;
+    KISSAT_assert (level < size_frames);
+    frame *f = frames + level;
+    const unsigned end = f->used;
+    KISSAT_assert (pos < end);
+    f->used = end - pos;
+    KISSAT_assert (f->used == f->saved);
+    pos = end;
+  }
+
+  CLEAR_STACK (*shadow);
+  LOGTMP ("level sorted deduced");
+
+#ifndef KISSAT_NDEBUG
+  unsigned prev_level = solver->level;
+  for (all_stack (unsigned, lit, solver->clause)) {
+    const unsigned idx = IDX (lit);
+    const unsigned lit_level = assigned[idx].level;
+    KISSAT_assert (prev_level >= lit_level);
+    prev_level = lit_level;
+  }
+#endif
+}
+
+static void reset_levels (kissat *solver) {
+  LOG ("reset %zu marked levels", SIZE_STACK (solver->levels));
+  frame *frames = BEGIN_STACK (solver->frames);
+#ifndef KISSAT_NDEBUG
+  const size_t size_frames = SIZE_STACK (solver->frames);
+#endif
+  for (all_stack (unsigned, level, solver->levels)) {
+    KISSAT_assert (level < size_frames);
+    frame *f = frames + level;
+    KISSAT_assert (f->used > 0);
+    f->used = 0;
+  }
+  CLEAR_STACK (solver->levels);
+}
+
+void kissat_reset_only_analyzed_literals (kissat *solver) {
+  LOG ("reset %zu analyzed variables", SIZE_STACK (solver->analyzed));
+  assigned *assigned = solver->assigned;
+  for (all_stack (unsigned, idx, solver->analyzed)) {
+    KISSAT_assert (idx < VARS);
+    struct assigned *a = assigned + idx;
+    KISSAT_assert (!a->poisoned);
+    KISSAT_assert (!a->removable);
+    KISSAT_assert (!a->shrinkable);
+    a->analyzed = false;
+  }
+  CLEAR_STACK (solver->analyzed);
+}
+
+static void reset_removable (kissat *solver) {
+  LOG ("reset %zu removable variables", SIZE_STACK (solver->removable));
+  assigned *assigned = solver->assigned;
+#ifndef KISSAT_NDEBUG
+  unsigned not_removable = 0;
+#endif
+  for (all_stack (unsigned, idx, solver->removable)) {
+    KISSAT_assert (idx < VARS);
+    struct assigned *a = assigned + idx;
+    KISSAT_assert (a->removable || !not_removable++);
+    a->removable = false;
+  }
+  CLEAR_STACK (solver->removable);
+}
+
+static void reset_analysis_but_not_analyzed_literals (kissat *solver) {
+  reset_removable (solver);
+  reset_levels (solver);
+  LOG ("reset %zu learned literals", SIZE_STACK (solver->clause));
+  CLEAR_STACK (solver->clause);
+}
+
+static void update_trail_average (kissat *solver) {
+  KISSAT_assert (!solver->probing);
+#if defined(LOGGING) || !defined(KISSAT_QUIET)
+  const unsigned size = SIZE_ARRAY (solver->trail);
+  const unsigned assigned = size - solver->unflushed;
+  const unsigned active = solver->active;
+  const double filled = kissat_percent (assigned, active);
+#else
+  (void) solver;
+#endif
+  LOG ("trail filled %.0f%% (size %u, unflushed %u, active %u)", filled,
+       size, solver->unflushed, active);
+#ifndef KISSAT_QUIET
+  UPDATE_AVERAGE (trail, filled);
+#endif
+}
+
+static void update_decision_rate_average (kissat *solver) {
+  KISSAT_assert (!solver->probing);
+  const uint64_t current = DECISIONS;
+  const uint64_t previous =
+      solver->averages[solver->stable].saved_decisions;
+  KISSAT_assert (previous <= current);
+  const uint64_t decisions = current - previous;
+  solver->averages[solver->stable].saved_decisions = current;
+  UPDATE_AVERAGE (decision_rate, decisions);
+}
+
+static void analyze_failed_literal (kissat *solver, clause *conflict) {
+  KISSAT_assert (solver->level == 1);
+  const unsigned failed = FRAME (1).decision;
+
+  LOGCLS (conflict, "analyzing failed literal %s conflict",
+          LOGLIT (failed));
+
+  unsigneds *units = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*units));
+  KISSAT_assert (EMPTY_STACK (solver->analyzed));
+
+  const unsigned not_failed = NOT (failed);
+  assigned *all_assigned = solver->assigned;
+#ifndef KISSAT_NDEBUG
+  const value *const values = solver->values;
+#endif
+  unsigned const *t = END_ARRAY (solver->trail);
+  unsigned unresolved = 0;
+  unsigned unit = INVALID_LIT;
+
+  for (all_literals_in_clause (lit, conflict)) {
+    KISSAT_assert (lit != failed);
+    if (lit == not_failed) {
+      LOG ("negation %s of failed literal %s occurs in conflict",
+           LOGLIT (not_failed), LOGLIT (failed));
+      goto DONE;
+    }
+    KISSAT_assert (values[lit] < 0);
+    const unsigned idx = IDX (lit);
+    assigned *a = all_assigned + idx;
+    if (!a->level)
+      continue;
+    KISSAT_assert (a->level == 1);
+    LOG ("analyzing conflict literal %s", LOGLIT (lit));
+    kissat_push_analyzed (solver, all_assigned, idx);
+    unresolved++;
+  }
+
+  for (;;) {
+    unsigned lit;
+    assigned *a;
+    do {
+      KISSAT_assert (t > BEGIN_ARRAY (solver->trail));
+      lit = *--t;
+      KISSAT_assert (values[lit] > 0);
+      const unsigned idx = IDX (lit);
+      a = all_assigned + idx;
+    } while (!a->analyzed);
+    if (unresolved == 1) {
+      unit = NOT (lit);
+      LOG ("learning additional unit %s", LOGLIT (unit));
+      PUSH_STACK (*units, unit);
+    }
+    if (a->binary) {
+      const unsigned other = a->reason;
+      LOGBINARY (lit, other, "resolving %s reason", LOGLIT (lit));
+      KISSAT_assert (other != failed);
+      KISSAT_assert (other != unit);
+      KISSAT_assert (values[other] < 0);
+      if (other == not_failed) {
+        LOG ("negation %s of failed literal %s in reason",
+             LOGLIT (not_failed), LOGLIT (failed));
+        goto DONE;
+      }
+      const unsigned idx = IDX (other);
+      assigned *b = all_assigned + idx;
+      KISSAT_assert (b->level == 1);
+      if (!b->analyzed) {
+        LOG ("analyzing reason literal %s", LOGLIT (other));
+        kissat_push_analyzed (solver, all_assigned, idx);
+        unresolved++;
+      }
+    } else {
+      KISSAT_assert (a->reason != UNIT_REASON);
+      KISSAT_assert (a->reason != DECISION_REASON);
+      const reference ref = a->reason;
+      LOGREF (ref, "resolving %s reason", LOGLIT (lit));
+      clause *reason = kissat_dereference_clause (solver, ref);
+      for (all_literals_in_clause (other, reason)) {
+        KISSAT_assert (other != NOT (lit));
+        KISSAT_assert (other != failed);
+        if (other == lit)
+          continue;
+        if (other == unit)
+          continue;
+        if (other == not_failed) {
+          LOG ("negation %s of failed literal %s occurs in reason",
+               LOGLIT (not_failed), LOGLIT (failed));
+          goto DONE;
+        }
+        KISSAT_assert (values[other] < 0);
+        const unsigned idx = IDX (other);
+        assigned *b = all_assigned + idx;
+        if (!b->level)
+          continue;
+        KISSAT_assert (b->level == 1);
+        if (b->analyzed)
+          continue;
+        LOG ("analyzing reason literal %s", LOGLIT (other));
+        kissat_push_analyzed (solver, all_assigned, idx);
+        unresolved++;
+      }
+    }
+    KISSAT_assert (unresolved > 0);
+    unresolved--;
+    LOG ("after resolving %s there are %u unresolved literals",
+         LOGLIT (lit), unresolved);
+  }
+DONE:
+  LOG ("learning negated failed literal %s", LOGLIT (not_failed));
+  PUSH_STACK (*units, not_failed);
+
+  if (!solver->probing)
+    kissat_update_learned (solver, 0, 1);
+
+  LOG ("failed literal %s produced %zu units", LOGLIT (failed),
+       SIZE_STACK (*units));
+
+  kissat_backtrack_without_updating_phases (solver, 0);
+
+  for (all_stack (unsigned, lit, *units))
+    kissat_learned_unit (solver, lit);
+  CLEAR_STACK (*units);
+  if (!solver->probing) {
+    solver->iterating = true;
+    INC (iterations);
+  }
+}
+
+static void update_tier_limits (kissat *solver) {
+  INC (retiered);
+  kissat_compute_and_set_tier_limits (solver);
+  if (solver->limits.glue.interval < (1u << 16))
+    solver->limits.glue.interval *= 2;
+  solver->limits.glue.conflicts = CONFLICTS + solver->limits.glue.interval;
+}
+
+int kissat_analyze (kissat *solver, clause *conflict) {
+  if (solver->inconsistent) {
+    KISSAT_assert (!solver->level);
+    return 20;
+  }
+
+  START (analyze);
+  if (!solver->probing) {
+    update_trail_average (solver);
+    update_decision_rate_average (solver);
+#ifndef KISSAT_QUIET
+    UPDATE_AVERAGE (level, solver->level);
+#endif
+  }
+  int res;
+  do {
+    LOGCLS (conflict, "analyzing conflict %" PRIu64, CONFLICTS);
+    unsigned conflict_level;
+    if (one_literal_on_conflict_level (solver, conflict, &conflict_level))
+      res = 1;
+    else if (!conflict_level)
+      res = -1;
+    else if (conflict_level == 1) {
+      analyze_failed_literal (solver, conflict);
+      res = 1;
+    } else if ((conflict =
+                    kissat_deduce_first_uip_clause (solver, conflict))) {
+      reset_analysis_but_not_analyzed_literals (solver);
+      INC (conflicts);
+      if (CONFLICTS > solver->limits.glue.conflicts)
+        update_tier_limits (solver);
+      res = 0; // And continue with new conflict analysis.
+    } else {
+      if (GET_OPTION (minimize)) {
+        sort_deduced_clause (solver);
+        kissat_minimize_clause (solver);
+        if (GET_OPTION (shrink))
+          kissat_shrink_clause (solver);
+      }
+      analyze_reason_side_literals (solver);
+      kissat_learn_clause (solver);
+      reset_analysis_but_not_analyzed_literals (solver);
+      res = 1;
+    }
+    if (!EMPTY_STACK (solver->analyzed)) {
+      if (!solver->probing && GET_OPTION (bump))
+        kissat_bump_analyzed (solver);
+      kissat_reset_only_analyzed_literals (solver);
+    }
+  } while (!res);
+  STOP (analyze);
+  return res > 0 ? 0 : 20;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/analyze.h b/src/sat/kissat/analyze.h
new file mode 100644
index 000000000..ec0b2af4e
--- /dev/null
+++ b/src/sat/kissat/analyze.h
@@ -0,0 +1,17 @@
+#ifndef _analyze_h_INCLUDED
+#define _analyze_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct clause;
+struct kissat;
+
+int kissat_analyze (struct kissat *, struct clause *);
+void kissat_reset_only_analyzed_literals (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/ands.c b/src/sat/kissat/ands.c
new file mode 100644
index 000000000..bd53b9489
--- /dev/null
+++ b/src/sat/kissat/ands.c
@@ -0,0 +1,92 @@
+#include "ands.h"
+#include "eliminate.h"
+#include "gates.h"
+#include "inline.h"
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_find_and_gate (kissat *solver, unsigned lit,
+                           unsigned negative) {
+  if (!GET_OPTION (ands))
+    return false;
+  size_t marked = kissat_mark_binaries (solver, lit);
+  if (!marked)
+    return false;
+  if (marked < 2) {
+    kissat_unmark_binaries (solver, lit);
+    return false;
+  }
+
+  unsigned not_lit = NOT (lit);
+  watches *not_watches = &WATCHES (not_lit);
+
+  ward *const arena = BEGIN_STACK (solver->arena);
+  value *marks = solver->marks;
+  const value *const values = solver->values;
+
+  clause *base = 0;
+  for (all_binary_large_watches (watch, *not_watches)) {
+    if (watch.type.binary)
+      continue;
+    const reference ref = watch.large.ref;
+    KISSAT_assert (ref < SIZE_STACK (solver->arena));
+    clause *c = (clause *) (arena + ref);
+    KISSAT_assert (!c->garbage);
+    base = c;
+    for (all_literals_in_clause (other, c)) {
+      if (other == not_lit)
+        continue;
+      const value value = values[other];
+      if (value > 0) {
+        kissat_eliminate_clause (solver, c, INVALID_LIT);
+        base = 0;
+        break;
+      }
+      if (value < 0)
+        continue;
+      const unsigned not_other = NOT (other);
+      signed char mark = marks[not_other];
+      if (mark)
+        continue;
+      base = 0;
+      break;
+    }
+    if (base)
+      break;
+  }
+  if (!base) {
+    kissat_unmark_binaries (solver, lit);
+    return false;
+  }
+  LOGCLS (base, "found and gate %s base clause", LOGLIT (not_lit));
+  for (all_literals_in_clause (other, base)) {
+    if (other == not_lit)
+      continue;
+    if (values[other])
+      continue;
+    const unsigned not_other = NOT (other);
+    KISSAT_assert (marks[not_other]);
+    marks[not_other] = 0;
+  }
+  watch tmp = kissat_binary_watch (0);
+  watches *watches = &WATCHES (lit);
+  for (all_binary_large_watches (watch, *watches)) {
+    if (!watch.type.binary)
+      continue;
+    const unsigned other = watch.binary.lit;
+    KISSAT_assert (!solver->values[other]);
+    if (marks[other]) {
+      marks[other] = 0;
+      continue;
+    }
+    tmp.binary.lit = other;
+    PUSH_STACK (solver->gates[negative], tmp);
+  }
+  tmp = kissat_large_watch (kissat_reference_clause (solver, base));
+  PUSH_STACK (solver->gates[!negative], tmp);
+  solver->gate_eliminated = GATE_ELIMINATED (ands);
+  INC (ands_extracted);
+  return true;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/ands.h b/src/sat/kissat/ands.h
new file mode 100644
index 000000000..4780d1138
--- /dev/null
+++ b/src/sat/kissat/ands.h
@@ -0,0 +1,16 @@
+#ifndef _ands_h_INCLUDED
+#define _ands_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_find_and_gate (struct kissat *, unsigned lit,
+                           unsigned negative);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/application.h b/src/sat/kissat/application.h
new file mode 100644
index 000000000..25c23f178
--- /dev/null
+++ b/src/sat/kissat/application.h
@@ -0,0 +1,13 @@
+#ifndef _application_h_INCLUDED
+#define _application_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+int kissat_application (struct kissat *, int argc, char **argv);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/arena.c b/src/sat/kissat/arena.c
new file mode 100644
index 000000000..2ee25018f
--- /dev/null
+++ b/src/sat/kissat/arena.c
@@ -0,0 +1,112 @@
+#include "error.h"
+#include "internal.h"
+#include "logging.h"
+#include "print.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static void report_resized (kissat *solver, const char *mode,
+                            arena before) {
+#ifndef KISSAT_QUIET
+  ward *const old_begin = BEGIN_STACK (before);
+  ward *const new_begin = BEGIN_STACK (solver->arena);
+  const bool moved = (new_begin != old_begin);
+  const uint64_t capacity = CAPACITY_STACK (solver->arena);
+  const uint64_t bytes = capacity * sizeof (ward);
+  kissat_phase (solver, "arena", GET (arena_resized),
+                "%s to %s %d-byte-words %s (%s)", mode,
+                FORMAT_COUNT (capacity), (int) sizeof (ward),
+                FORMAT_BYTES (bytes), (moved ? "moved" : "in place"));
+#else
+  (void) solver;
+  (void) mode;
+  (void) before;
+#endif
+}
+
+reference kissat_allocate_clause (kissat *solver, size_t size) {
+  KISSAT_assert (size <= UINT_MAX);
+  const size_t res = SIZE_STACK (solver->arena);
+  KISSAT_assert (res <= MAX_REF);
+  const size_t bytes = kissat_bytes_of_clause (size);
+  KISSAT_assert (kissat_aligned_word (bytes));
+  const size_t needed = bytes / sizeof (ward);
+  KISSAT_assert (needed <= UINT_MAX);
+  size_t capacity = CAPACITY_STACK (solver->arena);
+  KISSAT_assert (kissat_is_power_of_two (MAX_ARENA));
+  KISSAT_assert (capacity <= MAX_ARENA);
+  size_t available = capacity - res;
+  if (needed > available) {
+    const arena before = solver->arena;
+    do {
+      KISSAT_assert (kissat_is_zero_or_power_of_two (capacity));
+      if (capacity == MAX_ARENA)
+        kissat_fatal ("maximum arena capacity "
+                      "of 2^%u %zu-byte-words %s exhausted"
+#ifdef KISSAT_COMPACT
+                      " (consider a configuration without '--compact')"
+#endif
+                      ,
+                      LD_MAX_ARENA, sizeof (ward),
+                      FORMAT_BYTES (MAX_ARENA * sizeof (ward)));
+      kissat_stack_enlarge (solver, (chars *) &solver->arena,
+                            sizeof (ward));
+      capacity = CAPACITY_STACK (solver->arena);
+      available = capacity - res;
+    } while (needed > available);
+    INC (arena_resized);
+    INC (arena_enlarged);
+    report_resized (solver, "enlarged", before);
+    KISSAT_assert (capacity <= MAX_ARENA);
+  }
+  solver->arena.end += needed;
+  LOG ("allocated clause[%zu] of size %zu bytes %s", res, size,
+       FORMAT_BYTES (bytes));
+  return (reference) res;
+}
+
+void kissat_shrink_arena (kissat *solver) {
+  const arena before = solver->arena;
+  const size_t capacity = CAPACITY_STACK (before);
+  const size_t size = SIZE_STACK (before);
+#ifndef KISSAT_QUIET
+  const size_t capacity_bytes = capacity * sizeof (ward);
+  kissat_phase (solver, "arena", GET (arena_resized),
+                "capacity of %s %d-byte-words %s", FORMAT_COUNT (capacity),
+                (int) sizeof (ward), FORMAT_BYTES (capacity_bytes));
+  const size_t size_bytes = size * sizeof (ward);
+  kissat_phase (solver, "arena", GET (arena_resized),
+                "filled %.0f%% with %s %d-byte-words %s",
+                kissat_percent (size, capacity), FORMAT_COUNT (size),
+                (int) sizeof (ward), FORMAT_BYTES (size_bytes));
+#endif
+  if (size > capacity / 4) {
+    kissat_phase (solver, "arena", GET (arena_resized),
+                  "not shrinking since more than 25%% filled");
+    return;
+  }
+  INC (arena_resized);
+  INC (arena_shrunken);
+  SHRINK_STACK (solver->arena);
+  report_resized (solver, "shrunken", before);
+}
+
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+
+bool kissat_clause_in_arena (const kissat *solver, const clause *c) {
+  if (!kissat_aligned_pointer (c))
+    return false;
+  const char *p = (char *) c;
+  const char *begin = (char *) BEGIN_STACK (solver->arena);
+  const char *end = (char *) END_STACK (solver->arena);
+  if (p < begin)
+    return false;
+  const size_t bytes = kissat_bytes_of_clause (c->size);
+  if (end < p + bytes)
+    return false;
+  return true;
+}
+
+#endif
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/arena.h b/src/sat/kissat/arena.h
new file mode 100644
index 000000000..8e1750ce7
--- /dev/null
+++ b/src/sat/kissat/arena.h
@@ -0,0 +1,51 @@
+#ifndef _arena_h_INCLUDED
+#define _arena_h_INCLUDED
+
+#include "reference.h"
+#include "stack.h"
+#include "utilities.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifdef KISSAT_COMPACT
+typedef word ward;
+#else
+typedef w2rd ward;
+#endif
+
+#define LD_MAX_ARENA_32 (29 - (unsigned) sizeof (ward) / 4)
+
+#define LD_MAX_ARENA ((sizeof (word) == 4) ? LD_MAX_ARENA_32 : LD_MAX_REF)
+
+#define MAX_ARENA ((size_t) 1 << LD_MAX_ARENA)
+
+// clang-format off
+
+typedef STACK (ward) arena;
+
+// clang-format on
+
+struct clause;
+struct kissat;
+
+reference kissat_allocate_clause (struct kissat *, size_t size);
+void kissat_shrink_arena (struct kissat *);
+
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+
+bool kissat_clause_in_arena (const struct kissat *, const struct clause *);
+
+#endif
+
+static inline word kissat_align_ward (word w) {
+#ifdef KISSAT_COMPACT
+  return kissat_align_word (w);
+#else
+  return kissat_align_w2rd (w);
+#endif
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/array.h b/src/sat/kissat/array.h
new file mode 100644
index 000000000..a3a71d202
--- /dev/null
+++ b/src/sat/kissat/array.h
@@ -0,0 +1,63 @@
+#ifndef _array_h_INCLUDED
+#define _array_h_INCLUDED
+
+#include "allocate.h"
+#include "stack.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define ARRAY(TYPE) \
+  struct { \
+    TYPE *begin; \
+    TYPE *end; \
+  }
+
+#define ALLOCATE_ARRAY(A, N) \
+  do { \
+    const size_t TMP_N = (N); \
+    (A).begin = (A).end = \
+        kissat_nalloc (solver, TMP_N, sizeof *(A).begin); \
+  } while (0)
+
+#define EMPTY_ARRAY EMPTY_STACK
+#define SIZE_ARRAY SIZE_STACK
+
+#define PUSH_ARRAY(A, E) \
+  do { \
+    *(A).end++ = (E); \
+  } while (0)
+
+#define REALLOCATE_ARRAY(T, A, O, N)             \
+  do { \
+    const size_t SIZE = SIZE_ARRAY (A); \
+    (A).begin = \
+      (T*) kissat_nrealloc (solver, (A).begin, (O), (N), sizeof *(A).begin); \
+    (A).end = (A).begin + SIZE; \
+  } while (0)
+
+#define RELEASE_ARRAY(A, N) \
+  do { \
+    const size_t TMP_NIZE = (N); \
+    DEALLOC ((A).begin, TMP_NIZE); \
+  } while (0)
+
+#define CLEAR_ARRAY CLEAR_STACK
+#define TOP_ARRAY TOP_STACK
+#define PEEK_ARRAY PEEK_STACK
+#define POKE_ARRAY POKE_STACK
+#define POP_ARRAY POP_STACK
+#define BEGIN_ARRAY BEGIN_STACK
+#define END_ARRAY END_STACK
+#define RESIZE_ARRAY RESIZE_STACK
+#define SET_END_OF_ARRAY SET_END_OF_STACK
+
+// clang-format off
+
+typedef ARRAY (unsigned) unsigned_array;
+
+// clang-format on
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/assign.c b/src/sat/kissat/assign.c
new file mode 100644
index 000000000..c2fb61b4b
--- /dev/null
+++ b/src/sat/kissat/assign.c
@@ -0,0 +1,63 @@
+#include "assign.h"
+#include "inline.h"
+#include "inlineassign.h"
+#include "logging.h"
+
+#include <limits.h>
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_assign_unit (kissat *solver, unsigned lit, const char *reason) {
+  kissat_assign (solver, solver->probing, 0, false, lit, UNIT_REASON);
+  LOGUNARY (lit, "assign %s %s", LOGLIT (lit), reason);
+#ifndef LOGGING
+  (void) reason;
+#endif
+}
+
+void kissat_learned_unit (kissat *solver, unsigned lit) {
+  kissat_assign_unit (solver, lit, "learned reason");
+  CHECK_AND_ADD_UNIT (lit);
+  ADD_UNIT_TO_PROOF (lit);
+}
+
+void kissat_original_unit (kissat *solver, unsigned lit) {
+  kissat_assign_unit (solver, lit, "original reason");
+}
+
+void kissat_assign_decision (kissat *solver, unsigned lit) {
+  kissat_assign (solver, solver->probing, solver->level, false, lit,
+                 DECISION_REASON);
+  LOG ("assign %s decision", LOGLIT (lit));
+}
+
+void kissat_assign_binary (kissat *solver, unsigned lit, unsigned other) {
+  KISSAT_assert (VALUE (other) < 0);
+  assigned *assigned = solver->assigned;
+  const unsigned other_idx = IDX (other);
+  struct assigned *a = assigned + other_idx;
+  unsigned level = a->level;
+  if (GET_OPTION (jumpreasons) && level && a->binary) {
+    LOGBINARY (lit, other, "jumping %s reason", LOGLIT (lit));
+    INC (jumped_reasons);
+    other = a->reason;
+  }
+  kissat_assign (solver, solver->probing, a->level, true, lit, other);
+  LOGBINARY (lit, other, "assign %s reason", LOGLIT (lit));
+}
+
+void kissat_assign_reference (kissat *solver, unsigned lit, reference ref,
+                              clause *reason) {
+  KISSAT_assert (reason == kissat_dereference_clause (solver, ref));
+  assigned *assigned = solver->assigned;
+  value *values = solver->values;
+  const unsigned level =
+      kissat_assignment_level (solver, values, assigned, lit, reason);
+  KISSAT_assert (level <= solver->level);
+  KISSAT_assert (ref != DECISION_REASON);
+  KISSAT_assert (ref != UNIT_REASON);
+  kissat_assign (solver, solver->probing, level, false, lit, ref);
+  LOGREF (ref, "assign %s reason", LOGLIT (lit));
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/assign.h b/src/sat/kissat/assign.h
new file mode 100644
index 000000000..d063d17f6
--- /dev/null
+++ b/src/sat/kissat/assign.h
@@ -0,0 +1,64 @@
+#ifndef _assign_h_INCLUDED
+#define _assign_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define DECISION_REASON UINT_MAX
+#define UNIT_REASON (DECISION_REASON - 1)
+
+#define INVALID_LEVEL UINT_MAX
+#define INVALID_TRAIL UINT_MAX
+
+typedef struct assigned assigned;
+struct clause;
+
+struct assigned {
+  unsigned level;
+  unsigned trail;
+
+  bool analyzed : 1;
+  bool binary : 1;
+  bool poisoned : 1;
+  bool removable : 1;
+  bool shrinkable : 1;
+
+  unsigned reason;
+};
+
+#define ASSIGNED(LIT) \
+  (KISSAT_assert (VALID_INTERNAL_LITERAL (LIT)), solver->assigned + IDX (LIT))
+
+#define LEVEL(LIT) (ASSIGNED (LIT)->level)
+#define TRAIL(LIT) (ASSIGNED (LIT)->trail)
+#define REASON(LIT) (ASSIGNED (LIT)->reason)
+
+#ifndef FAST_ASSIGN
+
+ABC_NAMESPACE_HEADER_END
+
+#include "reference.h"
+
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+struct clause;
+
+void kissat_assign_unit (struct kissat *, unsigned lit, const char *);
+void kissat_learned_unit (struct kissat *, unsigned lit);
+void kissat_original_unit (struct kissat *, unsigned lit);
+
+void kissat_assign_decision (struct kissat *, unsigned lit);
+
+void kissat_assign_binary (struct kissat *, unsigned, unsigned);
+
+void kissat_assign_reference (struct kissat *, unsigned lit, reference,
+                              struct clause *);
+
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/attribute.h b/src/sat/kissat/attribute.h
new file mode 100644
index 000000000..4e43ac83f
--- /dev/null
+++ b/src/sat/kissat/attribute.h
@@ -0,0 +1,19 @@
+#ifndef _attribute_h_INCLUDED
+#define _attribute_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+/* #define ATTRIBUTE_FORMAT(FORMAT_POSITION, VARIADIC_ARGUMENT_POSITION) \ */
+/*   __attribute__ (( \ */
+/*       format (printf, FORMAT_POSITION, VARIADIC_ARGUMENT_POSITION))) */
+
+#define ATTRIBUTE_FORMAT(FORMAT_POSITION, VARIADIC_ARGUMENT_POSITION)
+
+/* #define ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline)) */
+
+#define ATTRIBUTE_ALWAYS_INLINE
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/averages.c b/src/sat/kissat/averages.c
new file mode 100644
index 000000000..c59a6c2ed
--- /dev/null
+++ b/src/sat/kissat/averages.c
@@ -0,0 +1,21 @@
+#include "internal.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_init_averages (kissat *solver, averages *averages) {
+  if (averages->initialized)
+    return;
+#define INIT_EMA(EMA, WINDOW) \
+  kissat_init_smooth (solver, &averages->EMA, WINDOW, #EMA)
+#ifndef KISSAT_QUIET
+  INIT_EMA (level, GET_OPTION (emaslow));
+  INIT_EMA (size, GET_OPTION (emaslow));
+  INIT_EMA (trail, GET_OPTION (emaslow));
+#endif
+  INIT_EMA (fast_glue, GET_OPTION (emafast));
+  INIT_EMA (slow_glue, GET_OPTION (emaslow));
+  INIT_EMA (decision_rate, GET_OPTION (emaslow));
+  averages->initialized = true;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/averages.h b/src/sat/kissat/averages.h
new file mode 100644
index 000000000..b793e0b69
--- /dev/null
+++ b/src/sat/kissat/averages.h
@@ -0,0 +1,38 @@
+#ifndef _averages_h_INCLUDED
+#define _averages_h_INCLUDED
+
+#include "smooth.h"
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct averages averages;
+
+struct averages {
+  bool initialized;
+  smooth fast_glue, slow_glue;
+#ifndef KISSAT_QUIET
+  smooth level, size, trail;
+#endif
+  smooth decision_rate;
+  uint64_t saved_decisions;
+};
+
+struct kissat;
+
+void kissat_init_averages (struct kissat *, averages *);
+
+#define AVERAGES (solver->averages[solver->stable])
+
+#define EMA(NAME) (AVERAGES.NAME)
+
+#define AVERAGE(NAME) (EMA (NAME).value)
+
+#define UPDATE_AVERAGE(NAME, VALUE) \
+  kissat_update_smooth (solver, &EMA (NAME), VALUE)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/backbone.c b/src/sat/kissat/backbone.c
new file mode 100644
index 000000000..6db42d77a
--- /dev/null
+++ b/src/sat/kissat/backbone.c
@@ -0,0 +1,602 @@
+#include "backbone.h"
+#include "allocate.h"
+#include "analyze.h"
+#include "backtrack.h"
+#include "decide.h"
+#include "inline.h"
+#include "internal.h"
+#include "logging.h"
+#include "print.h"
+#include "proprobe.h"
+#include "report.h"
+#include "terminate.h"
+#include "trail.h"
+#include "utilities.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static void schedule_backbone_candidates (kissat *solver,
+                                          unsigneds *candidates) {
+  flags *flags = solver->flags;
+  unsigned not_rescheduled = 0;
+  for (all_variables (idx)) {
+    const struct flags *f = flags + idx;
+    if (!f->active)
+      continue;
+    const unsigned lit = LIT (idx);
+    if (f->backbone0) {
+      PUSH_STACK (*candidates, lit);
+      LOG ("rescheduling backbone literal candidate %s", LOGLIT (lit));
+    } else
+      not_rescheduled++;
+    if (f->backbone1) {
+      const unsigned not_lit = NOT (lit);
+      PUSH_STACK (*candidates, not_lit);
+      LOG ("rescheduling backbone literal candidate %s", LOGLIT (not_lit));
+    } else
+      not_rescheduled++;
+  }
+#ifndef KISSAT_QUIET
+  const size_t rescheduled = SIZE_STACK (*candidates);
+  const unsigned active_literals = 2u * solver->active;
+  kissat_very_verbose (
+      solver, "rescheduled %zu backbone candidate literals %.0f%%",
+      rescheduled, kissat_percent (rescheduled, active_literals));
+#endif
+  if (not_rescheduled) {
+    for (all_variables (idx)) {
+      struct flags *f = flags + idx;
+      if (!f->active)
+        continue;
+      const unsigned lit = LIT (idx);
+      if (!f->backbone0) {
+        LOG ("scheduling backbone literal candidate %s", LOGLIT (lit));
+        PUSH_STACK (*candidates, lit);
+      }
+      if (!f->backbone1) {
+        const unsigned not_lit = NOT (lit);
+        LOG ("scheduling backbone literal candidate %s", LOGLIT (not_lit));
+        PUSH_STACK (*candidates, not_lit);
+      }
+    }
+  }
+#ifndef KISSAT_QUIET
+  const size_t total = SIZE_STACK (*candidates);
+  kissat_very_verbose (solver,
+                       "scheduled %zu backbone candidate literals %.0f%%"
+                       " in total",
+                       total, kissat_percent (total, active_literals));
+#endif
+}
+
+static void keep_backbone_candidates (kissat *solver,
+                                      unsigneds *candidates) {
+  flags *flags = solver->flags;
+  size_t prioritized = 0;
+  size_t remain = 0;
+  for (all_stack (unsigned, lit, *candidates)) {
+    const unsigned idx = IDX (lit);
+    const struct flags *f = flags + idx;
+    if (!f->active)
+      continue;
+    remain++;
+    if (NEGATED (lit))
+      prioritized += f->backbone1;
+    else
+      prioritized += f->backbone0;
+  }
+  KISSAT_assert (prioritized <= remain);
+  if (!remain) {
+    kissat_very_verbose (solver, "no backbone candidates remain");
+#ifndef KISSAT_NDEBUG
+    for (all_variables (idx)) {
+      const struct flags *f = flags + idx;
+      if (!f->active)
+        continue;
+      KISSAT_assert (!f->backbone0);
+      KISSAT_assert (!f->backbone1);
+    }
+#endif
+    return;
+  }
+#ifndef KISSAT_QUIET
+  const size_t active_literals = 2u * solver->active;
+#endif
+  if (prioritized == remain)
+    kissat_very_verbose (solver,
+                         "keeping all remaining %zu backbone "
+                         "candidates %.0f%% prioritized (all were)",
+                         remain, kissat_percent (remain, active_literals));
+  else if (!prioritized) {
+    for (all_stack (unsigned, lit, *candidates)) {
+      const unsigned idx = IDX (lit);
+      struct flags *f = flags + idx;
+      if (!f->active)
+        continue;
+      if (NEGATED (lit)) {
+        KISSAT_assert (!f->backbone1);
+        f->backbone1 = true;
+      } else {
+        KISSAT_assert (!f->backbone0);
+        f->backbone0 = true;
+      }
+    }
+    kissat_very_verbose (solver,
+                         "keeping all remaining %zu backbone "
+                         "candidates %.0f%% prioritized (none was)",
+                         remain, kissat_percent (remain, active_literals));
+  } else {
+    kissat_very_verbose (solver,
+                         "keeping %zu backbone candidates %.0f%% "
+                         "prioritized (%.0f%% of remaining %zu)",
+                         prioritized,
+                         kissat_percent (prioritized, active_literals),
+                         kissat_percent (prioritized, remain), remain);
+  }
+}
+
+static inline void backbone_assign (kissat *solver, unsigned_array *trail,
+                                    value *values, assigned *assigned,
+                                    unsigned lit, unsigned reason) {
+  const unsigned not_lit = NOT (lit);
+  KISSAT_assert (!values[lit]);
+  KISSAT_assert (!values[not_lit]);
+  values[lit] = 1;
+  values[not_lit] = -1;
+  PUSH_ARRAY (*trail, lit);
+  const unsigned idx = IDX (lit);
+  struct assigned *a = assigned + idx;
+  a->reason = reason;
+  a->level = solver->level;
+}
+
+static inline clause *
+backbone_propagate_literal (kissat *solver, const bool stop_early,
+                            const watches *const all_watches,
+                            unsigned_array *trail, value *values,
+                            assigned *assigned, unsigned lit) {
+  LOG ("backbone propagating %s", LOGLIT (lit));
+  KISSAT_assert (VALID_INTERNAL_LITERAL (lit));
+  KISSAT_assert (values[lit] > 0);
+
+  const unsigned not_lit = NOT (lit);
+  KISSAT_assert (values[not_lit] < 0);
+
+  KISSAT_assert (not_lit < LITS);
+  const watches *const watches = all_watches + not_lit;
+
+  const watch *const begin_watches = BEGIN_CONST_WATCHES (*watches);
+  const watch *const end_watches = END_CONST_WATCHES (*watches);
+  const watch *p = begin_watches;
+
+  while (p != end_watches) {
+    const watch watch = *p++;
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      KISSAT_assert (VALID_INTERNAL_LITERAL (other));
+      const value value = values[other];
+      if (value > 0)
+        continue;
+      if (value < 0)
+        return kissat_binary_conflict (solver, not_lit, other);
+      KISSAT_assert (!value);
+      backbone_assign (solver, trail, values, assigned, other, lit);
+      LOG ("backbone assign %s reason binary clause %s %s", LOGLIT (other),
+           LOGLIT (other), LOGLIT (not_lit));
+    } else {
+      if (stop_early) {
+#ifndef KISSAT_NDEBUG
+        for (const union watch *q = p + 1; q != end_watches; q++) {
+          const union watch watch = *q++;
+          KISSAT_assert (!watch.type.binary);
+        }
+#endif
+        break;
+      }
+
+      p++;
+    }
+  }
+
+  const size_t touched = p - begin_watches;
+  solver->ticks += 1 + kissat_cache_lines (touched, sizeof (watch));
+
+  return 0;
+}
+
+static inline clause *backbone_propagate (kissat *solver,
+                                          unsigned_array *trail,
+                                          value *values,
+                                          assigned *assigned) {
+  const bool stop_early =
+      solver->large_clauses_watched_after_binary_clauses;
+
+  clause *conflict = 0;
+  solver->ticks = 0;
+
+  const watches *const watches = solver->watches;
+  unsigned *propagate = solver->propagate;
+
+  while (!conflict && propagate != END_ARRAY (*trail))
+    conflict = backbone_propagate_literal (
+        solver, stop_early, watches, trail, values, assigned, *propagate++);
+
+  KISSAT_assert (solver->propagate <= propagate);
+  const unsigned propagated = propagate - solver->propagate;
+  solver->propagate = propagate;
+
+  ADD (backbone_propagations, propagated);
+  ADD (probing_propagations, propagated);
+  ADD (propagations, propagated);
+
+  const uint64_t ticks = solver->ticks;
+
+  ADD (backbone_ticks, ticks);
+  ADD (probing_ticks, ticks);
+  ADD (ticks, ticks);
+
+  return conflict;
+}
+
+static inline void backbone_backtrack (kissat *solver,
+                                       unsigned_array *trail, value *values,
+                                       unsigned *saved,
+                                       unsigned decision_level) {
+  KISSAT_assert (decision_level <= solver->level);
+  unsigned *end_trail = END_ARRAY (*trail);
+  KISSAT_assert (saved != end_trail);
+  LOG ("backbone backtracking to trail level %zu and decision level %u",
+       (size_t) (saved - BEGIN_ARRAY (*trail)), decision_level);
+  while (saved != end_trail) {
+    const unsigned lit = *--end_trail;
+    const unsigned not_lit = NOT (lit);
+    LOG ("backbone unassign %s", LOGLIT (lit));
+    KISSAT_assert (values[lit] > 0);
+    KISSAT_assert (values[not_lit] < 0);
+    values[lit] = values[not_lit] = 0;
+  }
+  SET_END_OF_ARRAY (solver->trail, saved);
+  solver->level = decision_level;
+  solver->propagate = saved;
+}
+
+static unsigned backbone_analyze (kissat *solver, clause *conflict) {
+  KISSAT_assert (conflict);
+  LOGCLS (conflict, "backbone analyzing");
+  KISSAT_assert (conflict->size == 2);
+
+  assigned *const assigned = solver->assigned;
+
+  kissat_push_analyzed (solver, assigned, IDX (conflict->lits[0]));
+  kissat_push_analyzed (solver, assigned, IDX (conflict->lits[1]));
+
+  const unsigned *t = END_ARRAY (solver->trail);
+
+  for (;;) {
+    KISSAT_assert (t > BEGIN_ARRAY (solver->trail));
+
+    unsigned lit = *--t;
+
+    const unsigned lit_idx = IDX (lit);
+    const struct assigned *a = assigned + lit_idx;
+    if (!a->analyzed)
+      continue;
+
+    LOG ("backbone analyzing %s", LOGLIT (lit));
+    const unsigned reason = a->reason;
+    KISSAT_assert (reason != UNIT_REASON);
+    KISSAT_assert (reason != DECISION_REASON);
+    const unsigned reason_idx = IDX (reason);
+    const struct assigned *b = assigned + reason_idx;
+    if (!b->analyzed) {
+      LOG ("reason %s of %s not yet analyzed", LOGLIT (reason),
+           LOGLIT (lit));
+      kissat_push_analyzed (solver, assigned, reason_idx);
+    } else {
+      LOG ("backbone UIP %s", LOGLIT (reason));
+      kissat_reset_only_analyzed_literals (solver);
+      return reason;
+    }
+  }
+}
+
+#ifndef KISSAT_NDEBUG
+
+static void
+check_large_clauses_watched_after_binary_clauses (kissat *solver) {
+  for (all_literals (lit)) {
+    bool large = false;
+    for (all_binary_blocking_watches (watch, WATCHES (lit)))
+      if (watch.type.binary)
+        KISSAT_assert (!large);
+      else
+        large = true;
+  }
+}
+
+#endif
+
+static unsigned compute_backbone (kissat *solver) {
+#ifndef KISSAT_NDEBUG
+  if (solver->large_clauses_watched_after_binary_clauses)
+    check_large_clauses_watched_after_binary_clauses (solver);
+#endif
+  size_t failed = 0;
+  unsigneds units;
+  unsigneds candidates;
+  INIT_STACK (candidates);
+  INIT_STACK (units);
+  schedule_backbone_candidates (solver, &candidates);
+#ifndef KISSAT_QUIET
+  const size_t scheduled = SIZE_STACK (candidates);
+#endif
+#if defined(METRICS) && (!defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG))
+  const uint64_t implied_before = solver->statistics_.backbone_implied;
+#endif
+  unsigned_array *trail = &solver->trail;
+  value *values = solver->values;
+  flags *flags = solver->flags;
+  assigned *assigned = solver->assigned;
+
+  KISSAT_assert (kissat_propagated (solver));
+  KISSAT_assert (kissat_trail_flushed (solver));
+
+  unsigned inconsistent = INVALID_LIT;
+
+  SET_EFFORT_LIMIT (ticks_limit, backbone, backbone_ticks);
+  size_t round_limit = GET_OPTION (backbonerounds);
+  KISSAT_assert (solver->statistics_.backbone_computations);
+  round_limit *= solver->statistics_.backbone_computations;
+  const size_t max_rounds = GET_OPTION (backbonemaxrounds);
+  if (round_limit > max_rounds)
+    round_limit = max_rounds;
+
+  size_t round = 0;
+
+  for (;;) {
+    if (round >= round_limit) {
+      kissat_very_verbose (solver, "backbone round limit %zu hit", round);
+      break;
+    }
+    const uint64_t ticks = solver->statistics_.backbone_ticks;
+    if (ticks > ticks_limit) {
+      kissat_very_verbose (solver,
+                           "backbone ticks limit %" PRIu64 " hit "
+                           "after %" PRIu64 " ticks",
+                           ticks_limit, ticks);
+      break;
+    }
+    size_t previous = failed;
+    KISSAT_assert (!solver->inconsistent);
+    if (TERMINATED (backbone_terminated_1))
+      break;
+    round++;
+    INC (backbone_rounds);
+    LOG ("starting backbone round %zu", round);
+    unsigned *const begin_candidates = BEGIN_STACK (candidates);
+    KISSAT_assert (!solver->level);
+#if !defined(KISSAT_QUIET) && defined(METRICS)
+    size_t decisions = 0;
+    uint64_t propagated = solver->statistics_.backbone_propagations;
+#endif
+    unsigned active_before = solver->active;
+    {
+      unsigned *q = begin_candidates;
+      const unsigned *p = begin_candidates;
+      const unsigned *const end_candidates = END_STACK (candidates);
+      while (p != end_candidates) {
+        KISSAT_assert (!solver->inconsistent);
+        const unsigned probe = *q++ = *p++;
+        const value value = values[probe];
+        if (value > 0) {
+          q--;
+          LOG ("removing satisfied backbone probe %s", LOGLIT (probe));
+          const unsigned idx = IDX (probe);
+          struct flags *f = flags + idx;
+          if (NEGATED (probe))
+            f->backbone1 = false;
+          else
+            f->backbone0 = false;
+          continue;
+        }
+        if (value < 0) {
+          const unsigned idx = IDX (probe);
+          struct assigned *a = assigned + idx;
+          if (a->level)
+            LOG ("skipping falsified backbone probe %s", LOGLIT (probe));
+          else {
+            LOG ("removing root-level falsified backbone probe %s",
+                 LOGLIT (probe));
+            q--;
+          }
+          continue;
+        }
+        if (solver->statistics_.backbone_ticks > ticks_limit)
+          break;
+        if (TERMINATED (backbone_terminated_2))
+          break;
+        const unsigned level = solver->level;
+        unsigned *const saved = END_ARRAY (*trail);
+        KISSAT_assert (level != UINT_MAX);
+#if !defined(KISSAT_QUIET) && defined(METRICS)
+        decisions++;
+#endif
+        solver->level = level + 1;
+        INC (backbone_probes);
+        backbone_assign (solver, trail, values, assigned, probe,
+                         DECISION_REASON);
+        LOG ("backbone assume %s", LOGLIT (probe));
+        clause *conflict =
+            backbone_propagate (solver, trail, values, assigned);
+        if (!conflict) {
+          LOG ("propagating backbone probe %s successful", LOGLIT (probe));
+          continue;
+        }
+
+        failed++;
+        INC (backbone_units);
+        q--;
+
+        LOG ("propagating backbone probe %s failed", LOGLIT (probe));
+        unsigned uip = backbone_analyze (solver, conflict);
+        unsigned not_uip = NOT (uip);
+        backbone_backtrack (solver, trail, values, saved, level);
+
+        PUSH_STACK (units, not_uip);
+        backbone_assign (solver, trail, values, assigned, not_uip,
+                         UNIT_REASON);
+        LOG ("backbone forced assign %s", LOGLIT (not_uip));
+        KISSAT_assert (failed == SIZE_STACK (units));
+
+        conflict = backbone_propagate (solver, trail, values, assigned);
+        if (conflict) {
+          LOG ("propagating backbone forced %s failed", LOGLIT (not_uip));
+          inconsistent = not_uip;
+          break;
+        }
+
+        LOG ("propagating backbone forced %s successful", LOGLIT (not_uip));
+      }
+#ifndef KISSAT_QUIET
+      size_t remain = end_candidates - p;
+      if (remain)
+        kissat_extremely_verbose (solver,
+                                  "backbone round %zu aborted with "
+                                  "%zu candidates %.0f%% remaining",
+                                  round, remain,
+                                  kissat_percent (remain, scheduled));
+      else
+        kissat_extremely_verbose (solver,
+                                  "backbone round %zu completed with "
+                                  "all %zu scheduled candidates tried",
+                                  round, scheduled);
+#endif
+      while (p != end_candidates)
+        *q++ = *p++;
+
+      SET_END_OF_STACK (candidates, q);
+    }
+    if (inconsistent == INVALID_LIT) {
+      LOG ("flushing satisfied probe candidates");
+      unsigned *q = begin_candidates;
+      const unsigned *p = begin_candidates;
+      const unsigned *const end_candidates = END_STACK (candidates);
+      while (p != end_candidates) {
+        const unsigned probe = *q++ = *p++;
+        const value value = values[probe];
+        if (value > 0) {
+          q--;
+          LOG ("removing satisfied backbone probe %s", LOGLIT (probe));
+          const unsigned idx = IDX (probe);
+          struct flags *f = flags + idx;
+          if (NEGATED (probe))
+            f->backbone1 = false;
+          else
+            f->backbone0 = false;
+          continue;
+        }
+        if (value < 0) {
+          LOG ("keeping falsified probe %s", LOGLIT (probe));
+          continue;
+        }
+        KISSAT_assert (!value);
+        LOG ("keeping unassigned probe %s", LOGLIT (probe));
+      }
+      LOG ("flushed %zu probe candidates",
+           (size_t) (q - BEGIN_STACK (candidates)));
+      SET_END_OF_STACK (candidates, q);
+    }
+    if (!EMPTY_ARRAY (*trail))
+      backbone_backtrack (solver, trail, values, BEGIN_ARRAY (*trail), 0);
+    if (inconsistent == INVALID_LIT && previous < failed) {
+      for (size_t i = previous; i < failed; i++) {
+        const unsigned unit = PEEK_STACK (units, i);
+        LOG ("assigning backbone unit %s", LOGLIT (unit));
+        kissat_learned_unit (solver, unit);
+      }
+      if (kissat_probing_propagate (solver, 0, true))
+        break;
+    }
+    KISSAT_assert (solver->active <= active_before);
+    unsigned implied = active_before - solver->active;
+    KISSAT_assert (failed <= failed);
+    ADD (backbone_implied, implied);
+#ifndef KISSAT_QUIET
+#ifdef METRICS
+    propagated = solver->statistics_.backbone_propagations - propagated;
+    kissat_very_verbose (solver,
+                         "backbone round %zu with %zu decisions "
+                         "(%.2f propagations per decision)",
+                         round, decisions,
+                         kissat_average (propagated, decisions));
+#endif
+    size_t left = SIZE_STACK (candidates);
+    kissat_very_verbose (solver,
+                         "backbone round %zu produced %zu failed literals"
+                         " %u implied (%zu candidates left %.0f%%)",
+                         round, failed - previous, implied, left,
+                         kissat_percent (left, scheduled));
+#endif
+    if (inconsistent != INVALID_LIT)
+      break;
+    if (EMPTY_STACK (candidates))
+      break;
+  }
+
+  if (inconsistent != INVALID_LIT && !solver->inconsistent) {
+    LOG ("assuming forced unit %s", LOGLIT (inconsistent));
+    kissat_learned_unit (solver, inconsistent);
+    (void) kissat_probing_propagate (solver, 0, true);
+    KISSAT_assert (solver->inconsistent);
+  }
+  RELEASE_STACK (units);
+  if (solver->inconsistent)
+    kissat_phase (solver, "backbone", GET (backbone_computations),
+                  "inconsistent binary clauses");
+  else {
+    keep_backbone_candidates (solver, &candidates);
+#if defined(METRICS) && (!defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG))
+    KISSAT_assert (implied_before <= solver->statistics_.backbone_implied);
+#endif
+#if defined(METRICS) && !defined(KISSAT_QUIET)
+    const uint64_t total_implied =
+        solver->statistics_.backbone_implied - implied_before;
+    kissat_phase (solver, "backbone", GET (backbone_computations),
+                  "found %zu backbone literals %" PRIu64
+                  " implied in %zu rounds",
+                  failed, total_implied, round);
+#endif
+  }
+  RELEASE_STACK (candidates);
+  return failed;
+}
+
+void kissat_binary_clauses_backbone (kissat *solver) {
+  if (solver->inconsistent)
+    return;
+  if (!GET_OPTION (backbone))
+    return;
+  if (TERMINATED (backbone_terminated_3))
+    return;
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (solver->probing);
+  KISSAT_assert (!solver->level);
+  START (backbone);
+  INC (backbone_computations);
+#if !defined(KISSAT_NDEBUG) || defined(METRICS)
+  KISSAT_assert (!solver->backbone_computing);
+  solver->backbone_computing = true;
+#endif
+#ifndef KISSAT_QUIET
+  const unsigned failed =
+#endif
+      compute_backbone (solver);
+  REPORT (!failed, 'b');
+#if !defined(KISSAT_NDEBUG) || defined(METRICS)
+  KISSAT_assert (solver->backbone_computing);
+  solver->backbone_computing = false;
+#endif
+  STOP (backbone);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/backbone.h b/src/sat/kissat/backbone.h
new file mode 100644
index 000000000..4cb189c9d
--- /dev/null
+++ b/src/sat/kissat/backbone.h
@@ -0,0 +1,14 @@
+#ifndef _backbone_h_INCLUDED
+#define _backbone_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+void kissat_binary_clauses_backbone (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/backtrack.c b/src/sat/kissat/backtrack.c
new file mode 100644
index 000000000..ef33f1010
--- /dev/null
+++ b/src/sat/kissat/backtrack.c
@@ -0,0 +1,181 @@
+#include "backtrack.h"
+#include "analyze.h"
+#include "inline.h"
+#include "inlineheap.h"
+#include "inlinequeue.h"
+#include "print.h"
+#include "proprobe.h"
+#include "propsearch.h"
+#include "trail.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static inline void unassign (kissat *solver, value *values, unsigned lit) {
+  LOG ("unassign %s", LOGLIT (lit));
+  KISSAT_assert (values[lit] > 0);
+  const unsigned not_lit = NOT (lit);
+  values[lit] = values[not_lit] = 0;
+  KISSAT_assert (solver->unassigned < VARS);
+  solver->unassigned++;
+}
+
+static inline void add_unassigned_variable_back_to_queue (kissat *solver,
+                                                          links *links,
+                                                          unsigned lit) {
+  KISSAT_assert (!solver->stable);
+  const unsigned idx = IDX (lit);
+  if (links[idx].stamp > solver->queue.search.stamp)
+    kissat_update_queue (solver, links, idx);
+}
+
+static inline void add_unassigned_variable_back_to_heap (kissat *solver,
+                                                         heap *scores,
+                                                         unsigned lit) {
+  KISSAT_assert (solver->stable);
+  const unsigned idx = IDX (lit);
+  if (!kissat_heap_contains (scores, idx))
+    kissat_push_heap (solver, scores, idx);
+}
+
+static void kissat_update_target_and_best_phases (kissat *solver) {
+  if (solver->probing)
+    return;
+
+  if (!solver->stable)
+    return;
+
+  const unsigned assigned = kissat_assigned (solver);
+#ifdef LOGGING
+  LOG ("updating target and best phases");
+  LOG ("currently %u variables assigned", assigned);
+#endif
+
+  if (solver->target_assigned < assigned) {
+    kissat_extremely_verbose (solver,
+                              "updating target assigned "
+                              "trail height from %u to %u",
+                              solver->target_assigned, assigned);
+    solver->target_assigned = assigned;
+    kissat_save_target_phases (solver);
+    INC (target_saved);
+  }
+
+  if (solver->best_assigned < assigned) {
+    kissat_extremely_verbose (solver,
+                              "updating best assigned "
+                              "trail height from %u to %u",
+                              solver->best_assigned, assigned);
+    solver->best_assigned = assigned;
+    kissat_save_best_phases (solver);
+    INC (best_saved);
+  }
+}
+
+void kissat_backtrack_without_updating_phases (kissat *solver,
+                                               unsigned new_level) {
+  KISSAT_assert (solver->level >= new_level);
+  if (solver->level == new_level)
+    return;
+
+  LOG ("backtracking to decision level %u", new_level);
+
+  frame *new_frame = &FRAME (new_level + 1);
+  SET_END_OF_STACK (solver->frames, new_frame);
+
+  value *values = solver->values;
+  unsigned *trail = BEGIN_ARRAY (solver->trail);
+  unsigned *new_end = trail + new_frame->trail;
+  assigned *assigned = solver->assigned;
+
+  unsigned *old_end = END_ARRAY (solver->trail);
+  unsigned unassigned = 0, reassigned = 0;
+
+  unsigned *q = new_end;
+  if (solver->stable) {
+    heap *scores = SCORES;
+    for (const unsigned *p = q; p != old_end; p++) {
+      const unsigned lit = *p;
+      const unsigned idx = IDX (lit);
+      KISSAT_assert (idx < VARS);
+      struct assigned *a = assigned + idx;
+      const unsigned level = a->level;
+      if (level <= new_level) {
+        const unsigned new_trail = q - trail;
+        KISSAT_assert (new_trail <= a->trail);
+        a->trail = new_trail;
+        *q++ = lit;
+        LOG ("reassign %s", LOGLIT (lit));
+        reassigned++;
+      } else {
+        unassign (solver, values, lit);
+        add_unassigned_variable_back_to_heap (solver, scores, lit);
+        unassigned++;
+      }
+    }
+  } else {
+    links *links = solver->links;
+    for (const unsigned *p = q; p != old_end; p++) {
+      const unsigned lit = *p;
+      const unsigned idx = IDX (lit);
+      KISSAT_assert (idx < VARS);
+      struct assigned *a = assigned + idx;
+      const unsigned level = a->level;
+      if (level <= new_level) {
+        const unsigned new_trail = q - trail;
+        KISSAT_assert (new_trail <= a->trail);
+        a->trail = new_trail;
+        *q++ = lit;
+        LOG ("reassign %s", LOGLIT (lit));
+        reassigned++;
+      } else {
+        unassign (solver, values, lit);
+        add_unassigned_variable_back_to_queue (solver, links, lit);
+        unassigned++;
+      }
+    }
+  }
+  SET_END_OF_ARRAY (solver->trail, q);
+
+  solver->level = new_level;
+  LOG ("unassigned %u literals", unassigned);
+  LOG ("reassigned %u literals", reassigned);
+  (void) unassigned, (void) reassigned;
+
+  KISSAT_assert (new_end <= END_ARRAY (solver->trail));
+  LOG ("propagation will resume at trail position %zu",
+       (size_t) (new_end - trail));
+  solver->propagate = new_end;
+
+  KISSAT_assert (!solver->extended);
+}
+
+void kissat_backtrack_in_consistent_state (kissat *solver,
+                                           unsigned new_level) {
+  kissat_update_target_and_best_phases (solver);
+  kissat_backtrack_without_updating_phases (solver, new_level);
+}
+
+void kissat_backtrack_after_conflict (kissat *solver, unsigned new_level) {
+  if (solver->level)
+    kissat_backtrack_without_updating_phases (solver, solver->level - 1);
+  kissat_update_target_and_best_phases (solver);
+  kissat_backtrack_without_updating_phases (solver, new_level);
+}
+
+void kissat_backtrack_propagate_and_flush_trail (kissat *solver) {
+  if (solver->level) {
+    KISSAT_assert (solver->watching);
+    kissat_backtrack_in_consistent_state (solver, 0);
+#ifndef KISSAT_NDEBUG
+    clause *conflict =
+#endif
+        solver->probing ? kissat_probing_propagate (solver, 0, true)
+                        : kissat_search_propagate (solver);
+    KISSAT_assert (!conflict);
+  }
+
+  KISSAT_assert (kissat_propagated (solver));
+  KISSAT_assert (kissat_trail_flushed (solver));
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/backtrack.h b/src/sat/kissat/backtrack.h
new file mode 100644
index 000000000..0df13f8b8
--- /dev/null
+++ b/src/sat/kissat/backtrack.h
@@ -0,0 +1,16 @@
+#ifndef _backtrack_h_INCLUDED
+#define _backtrack_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_backtrack_without_updating_phases (struct kissat *, unsigned);
+void kissat_backtrack_in_consistent_state (struct kissat *, unsigned);
+void kissat_backtrack_after_conflict (struct kissat *, unsigned);
+void kissat_backtrack_propagate_and_flush_trail (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/build.c b/src/sat/kissat/build.c
new file mode 100644
index 000000000..d1f21e937
--- /dev/null
+++ b/src/sat/kissat/build.c
@@ -0,0 +1,85 @@
+#include "build.h"
+#include "colors.h"
+#include "kissat.h"
+#include "print.h"
+
+#include <stdio.h>
+
+ABC_NAMESPACE_IMPL_START
+
+const char *kissat_signature (void) { return "kissat-" VERSION; }
+
+const char *kissat_id (void) { return ID; }
+
+const char *kissat_compiler (void) { return COMPILER; }
+
+static const char *copyright_lines[] = {
+    "Copyright (c) 2021-2024 Armin Biere University of Freiburg",
+    "Copyright (c) 2019-2021 Armin Biere Johannes Kepler University Linz",
+    0};
+
+const char **kissat_copyright (void) { return copyright_lines; }
+
+const char *kissat_version (void) { return VERSION; }
+
+#define PREFIX(COLORS) \
+  do { \
+    if (prefix) \
+      fputs (prefix, stdout); \
+    COLOR (COLORS); \
+  } while (0)
+
+#define NL() \
+  do { \
+    fputs ("\n", stdout); \
+    COLOR (NORMAL); \
+  } while (0)
+
+void kissat_build (const char *prefix) {
+  TERMINAL (stdout, 1);
+  if (!prefix)
+    connected_to_terminal = false;
+
+  PREFIX (MAGENTA);
+  if (ID)
+    printf ("Version %s %s", VERSION, ID);
+  else
+    printf ("Version %s", VERSION);
+  NL ();
+
+  PREFIX (MAGENTA);
+  printf ("%s", COMPILER);
+  NL ();
+
+  PREFIX (MAGENTA);
+  printf ("%s", BUILD);
+  NL ();
+}
+
+void kissat_banner (const char *prefix, const char *name) {
+  TERMINAL (stdout, 1);
+  if (!prefix)
+    connected_to_terminal = false;
+
+  PREFIX (BOLD MAGENTA);
+  printf ("%s", name);
+  NL ();
+
+  PREFIX (BOLD MAGENTA);
+  NL ();
+
+  for (const char **p = kissat_copyright (), *line; (line = *p); p++) {
+    PREFIX (BOLD MAGENTA);
+    fputs (line, stdout);
+    NL ();
+  }
+
+  if (prefix) {
+    PREFIX ("");
+    NL ();
+  }
+
+  kissat_build (prefix);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/build.h b/src/sat/kissat/build.h
new file mode 100644
index 000000000..cd418ecfd
--- /dev/null
+++ b/src/sat/kissat/build.h
@@ -0,0 +1,10 @@
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define VERSION ""
+#define COMPILER ""
+#define ID ""
+#define BUILD ""
+#define DIR ""
+
+ABC_NAMESPACE_HEADER_END
diff --git a/src/sat/kissat/bump.c b/src/sat/kissat/bump.c
new file mode 100644
index 000000000..5dc365f51
--- /dev/null
+++ b/src/sat/kissat/bump.c
@@ -0,0 +1,124 @@
+#include "bump.h"
+#include "analyze.h"
+#include "inlineheap.h"
+#include "inlinequeue.h"
+#include "inlinevector.h"
+#include "internal.h"
+#include "logging.h"
+#include "print.h"
+#include "rank.h"
+#include "sort.h"
+
+ABC_NAMESPACE_IMPL_START
+
+#define RANK(A) ((A).rank)
+#define SMALLER(A, B) (RANK (A) < RANK (B))
+
+#define RADIX_SORT_BUMP_LIMIT 32
+
+static void sort_bump (kissat *solver) {
+  const size_t size = SIZE_STACK (solver->analyzed);
+  if (size < RADIX_SORT_BUMP_LIMIT) {
+    LOG ("quick sorting %zu analyzed variables", size);
+    SORT_STACK (datarank, solver->ranks, SMALLER);
+  } else {
+    LOG ("radix sorting %zu analyzed variables", size);
+    RADIX_STACK (datarank, unsigned, solver->ranks, RANK);
+  }
+}
+
+void kissat_rescale_scores (kissat *solver) {
+  INC (rescaled);
+  heap *scores = &solver->scores;
+  const double max_score = kissat_max_score_on_heap (scores);
+  kissat_phase (solver, "rescale", GET (rescaled),
+                "maximum score %g increment %g", max_score, solver->scinc);
+  const double rescale = MAX (max_score, solver->scinc);
+  KISSAT_assert (rescale > 0);
+  const double factor = 1.0 / rescale;
+  kissat_rescale_heap (solver, scores, factor);
+  solver->scinc *= factor;
+  kissat_phase (solver, "rescale", GET (rescaled), "rescaled by factor %g",
+                factor);
+}
+
+void kissat_bump_score_increment (kissat *solver) {
+  const double old_scinc = solver->scinc;
+  const double decay = GET_OPTION (decay) * 1e-3;
+  KISSAT_assert (0 <= decay), KISSAT_assert (decay <= 0.5);
+  const double factor = 1.0 / (1.0 - decay);
+  const double new_scinc = old_scinc * factor;
+  LOG ("new score increment %g = %g * %g", new_scinc, factor, old_scinc);
+  solver->scinc = new_scinc;
+  if (new_scinc > MAX_SCORE)
+    kissat_rescale_scores (solver);
+}
+
+static inline void bump_analyzed_variable_score (kissat *solver,
+                                                 unsigned idx) {
+  heap *scores = &solver->scores;
+  const double old_score = kissat_get_heap_score (scores, idx);
+  const double inc = solver->scinc;
+  const double new_score = old_score + inc;
+  LOG ("new score[%u] = %g = %g + %g", idx, new_score, old_score, inc);
+  kissat_update_heap (solver, scores, idx, new_score);
+  if (new_score > MAX_SCORE)
+    kissat_rescale_scores (solver);
+}
+
+void kissat_bump_variable (kissat *solver, unsigned idx) {
+  bump_analyzed_variable_score (solver, idx);
+}
+
+static void bump_analyzed_variable_scores (kissat *solver) {
+  flags *flags = solver->flags;
+
+  for (all_stack (unsigned, idx, solver->analyzed))
+    if (flags[idx].active)
+      bump_analyzed_variable_score (solver, idx);
+
+  kissat_bump_score_increment (solver);
+}
+
+static void move_analyzed_variables_to_front_of_queue (kissat *solver) {
+  KISSAT_assert (EMPTY_STACK (solver->ranks));
+  const links *const links = solver->links;
+  for (all_stack (unsigned, idx, solver->analyzed)) {
+    // clang-format off
+    const datarank rank = { .data = idx, .rank = links[idx].stamp };
+    // clang-format on
+    PUSH_STACK (solver->ranks, rank);
+  }
+
+  sort_bump (solver);
+
+  flags *flags = solver->flags;
+  unsigned idx;
+
+  for (all_stack (datarank, rank, solver->ranks))
+    if (flags[idx = rank.data].active)
+      kissat_move_to_front (solver, idx);
+
+  CLEAR_STACK (solver->ranks);
+}
+
+void kissat_bump_analyzed (kissat *solver) {
+  START (bump);
+  const size_t bumped = SIZE_STACK (solver->analyzed);
+  if (!solver->stable)
+    move_analyzed_variables_to_front_of_queue (solver);
+  else
+    bump_analyzed_variable_scores (solver);
+  ADD (literals_bumped, bumped);
+  STOP (bump);
+}
+
+void kissat_update_scores (kissat *solver) {
+  KISSAT_assert (solver->stable);
+  heap *scores = SCORES;
+  for (all_variables (idx))
+    if (ACTIVE (idx) && !kissat_heap_contains (scores, idx))
+      kissat_push_heap (solver, scores, idx);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/bump.h b/src/sat/kissat/bump.h
new file mode 100644
index 000000000..036324502
--- /dev/null
+++ b/src/sat/kissat/bump.h
@@ -0,0 +1,21 @@
+#ifndef _bump_h_INCLUDED
+#define _bump_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_bump_analyzed (struct kissat *);
+void kissat_update_scores (struct kissat *);
+void kissat_rescale_scores (struct kissat *);
+void kissat_bump_variable (struct kissat *, unsigned idx);
+void kissat_bump_score_increment (struct kissat *);
+
+#define MAX_SCORE 1e150
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/check.c b/src/sat/kissat/check.c
new file mode 100644
index 000000000..e4b7988da
--- /dev/null
+++ b/src/sat/kissat/check.c
@@ -0,0 +1,1050 @@
+#include "global.h"
+
+#ifndef KISSAT_NDEBUG
+
+#include "check.h"
+#include "error.h"
+#include "internal.h"
+#include "literal.h"
+#include "logging.h"
+#include "print.h"
+
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+
+#undef LOGPREFIX
+#define LOGPREFIX "CHECK"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_check_satisfying_assignment (kissat *solver) {
+  LOG ("checking satisfying assignment");
+  const int *const begin = BEGIN_STACK (solver->original);
+  const int *const end = END_STACK (solver->original);
+#ifdef LOGGING
+  size_t count = 0;
+#endif
+  for (const int *p = begin, *q; p != end; p = q + 1) {
+    bool satisfied = false;
+    int lit, other;
+    for (q = p; (lit = *q); q++)
+      if (!satisfied && kissat_value (solver, lit) == lit)
+        satisfied = true;
+#ifdef LOGGING
+    count++;
+#endif
+    if (satisfied)
+      continue;
+    for (q = p; (lit = *q); q++)
+      for (const int *r = q + 1; (other = *r); r++)
+        if (lit == -other)
+          satisfied = true;
+    if (satisfied)
+      continue;
+    kissat_fatal_message_start ();
+    fputs ("unsatisfied clause:\n", stderr);
+    for (q = p; (lit = *q); q++)
+      fprintf (stderr, "%d ", lit);
+    fputs ("0\n", stderr);
+    fflush (stderr);
+    kissat_abort ();
+  }
+  LOG ("assignment satisfies all %zu original clauses", count);
+}
+
+ABC_NAMESPACE_IMPL_END
+
+#include "allocate.h"
+#include "inline.h"
+#include "sort.h"
+
+ABC_NAMESPACE_IMPL_START
+
+typedef struct hash hash;
+typedef struct bucket bucket;
+
+// clang-format off
+
+typedef STACK (bucket*) buckets_;
+
+// clang-format on
+
+struct bucket {
+  bucket *next;
+  unsigned size;
+  unsigned hash;
+  unsigned lits[];
+};
+
+struct checker {
+  bool inconsistent;
+
+  unsigned vars;
+  unsigned size;
+
+  unsigned buckets;
+  unsigned hashed;
+
+  bucket **table;
+
+  buckets_ *watches;
+  bool *marks;
+  bool *large;
+  bool *used;
+  signed char *values;
+
+  bool marked;
+  unsigneds imported;
+
+  unsigneds trail;
+  unsigned propagated;
+
+  unsigned nonces[32];
+
+  uint64_t added;
+  uint64_t blocked;
+  uint64_t checked;
+  uint64_t collisions;
+  uint64_t decisions;
+  uint64_t propagations;
+  uint64_t pure;
+  uint64_t removed;
+  uint64_t satisfied;
+  uint64_t searches;
+  uint64_t unchecked;
+};
+
+#define LOGIMPORTED3(...) \
+  LOGUNSIGNEDS3 (SIZE_STACK (checker->imported), \
+                 BEGIN_STACK (checker->imported), __VA_ARGS__)
+
+#define LOGLINE3(...) \
+  LOGUNSIGNEDS3 (bucket->size, bucket->lits, __VA_ARGS__)
+
+#define MAX_NONCES (sizeof checker->nonces / sizeof *checker->nonces)
+
+static inline bool less_unsigned (unsigned a, unsigned b) { return a < b; }
+
+static void sort_line (kissat *solver, checker *checker) {
+  SORT_STACK (unsigned, checker->imported, less_unsigned);
+  LOGIMPORTED3 ("sorted checker");
+}
+
+static unsigned hash_line (checker *checker) {
+  unsigned res = 0, pos = 0;
+  for (all_stack (unsigned, lit, checker->imported)) {
+    res += checker->nonces[pos++] * lit;
+    if (pos == MAX_NONCES)
+      pos = 0;
+  }
+  return res;
+}
+
+static size_t bytes_line (unsigned size) {
+  return sizeof (bucket) + size * sizeof (unsigned);
+}
+
+static void init_nonces (kissat *solver, checker *checker) {
+  generator random = 42;
+  for (unsigned i = 0; i < MAX_NONCES; i++)
+    checker->nonces[i] = 1 | kissat_next_random32 (&random);
+  LOG3 ("initialized %zu checker nonces", MAX_NONCES);
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+void kissat_init_checker (kissat *solver) {
+  LOG ("initializing internal proof checker");
+  checker *checker = (struct checker*)kissat_calloc (solver, 1, sizeof (struct checker));
+  solver->checker = checker;
+  init_nonces (solver, checker);
+}
+
+static void release_hash (kissat *solver, checker *checker) {
+  for (unsigned h = 0; h < checker->hashed; h++) {
+    for (bucket *bucket = checker->table[h], *next; bucket; bucket = next) {
+      next = bucket->next;
+      kissat_free (solver, bucket, bytes_line (bucket->size));
+    }
+  }
+  kissat_dealloc (solver, checker->table, checker->hashed,
+                  sizeof (bucket *));
+}
+
+static void release_watches (kissat *solver, checker *checker) {
+  const unsigned lits = 2 * checker->vars;
+  for (unsigned i = 0; i < lits; i++)
+    RELEASE_STACK (checker->watches[i]);
+  kissat_dealloc (solver, checker->watches, 2 * checker->size,
+                  sizeof (buckets_));
+}
+
+void kissat_release_checker (kissat *solver) {
+  LOG ("releasing internal proof checker");
+  checker *checker = solver->checker;
+  release_hash (solver, checker);
+  RELEASE_STACK (checker->imported);
+  RELEASE_STACK (checker->trail);
+  kissat_free (solver, checker->marks, 2 * checker->size * sizeof (bool));
+  kissat_free (solver, checker->used, 2 * checker->size * sizeof (bool));
+  kissat_free (solver, checker->large, 2 * checker->size * sizeof (bool));
+  kissat_free (solver, checker->values, 2 * checker->size);
+  release_watches (solver, checker);
+  kissat_free (solver, checker, sizeof (struct checker));
+}
+
+#ifndef KISSAT_QUIET
+
+ABC_NAMESPACE_IMPL_END
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#define PERCENT_ADDED(NAME) kissat_percent (checker->NAME, checker->added)
+#define PERCENT_CHECKED(NAME) \
+  kissat_percent (checker->NAME, checker->checked)
+
+void kissat_print_checker_statistics (kissat *solver, bool verbose) {
+  checker *checker = solver->checker;
+  PRINT_STAT ("checker_added", checker->added, 100, "%", "");
+  if (verbose)
+    PRINT_STAT ("checker_blocked", checker->blocked,
+                PERCENT_CHECKED (blocked), "%", "checked");
+  PRINT_STAT ("checker_checked", checker->checked, PERCENT_ADDED (checked),
+              "%", "added");
+  if (verbose) {
+    PRINT_STAT ("checker_collisions", checker->collisions,
+                kissat_percent (checker->collisions, checker->searches),
+                "%", "per search");
+    PRINT_STAT ("checker_decisions", checker->decisions,
+                kissat_average (checker->decisions, checker->checked), "",
+                "per check");
+    PRINT_STAT ("checker_propagations", checker->propagations,
+                kissat_average (checker->propagations, checker->checked),
+                "", "per check");
+    PRINT_STAT ("checker_pure", checker->pure, PERCENT_CHECKED (pure), "%",
+                "checked");
+  }
+  PRINT_STAT ("checker_removed", checker->removed, PERCENT_ADDED (removed),
+              "%", "added");
+  if (verbose) {
+    PRINT_STAT ("checker_satisfied", checker->satisfied,
+                PERCENT_CHECKED (satisfied), "%", "checked");
+    PRINT_STAT ("checker_unchecked", checker->unchecked,
+                PERCENT_ADDED (unchecked), "%", "added");
+  }
+}
+
+#endif
+
+#define MAX_VARS (1u << 29)
+#define MAX_SIZE (1u << 30)
+
+static unsigned reduce_hash (unsigned hash, unsigned mod) {
+  if (mod < 2)
+    return 0;
+  KISSAT_assert (mod);
+  unsigned res = hash;
+  for (unsigned shift = 16, mask = 0xffff; res >= mod;
+       mask >>= (shift >>= 1))
+    res = (res >> shift) & mask;
+  KISSAT_assert (res < mod);
+  return res;
+}
+
+static void resize_hash (kissat *solver, checker *checker) {
+  const unsigned old_hashed = checker->hashed;
+  KISSAT_assert (old_hashed < MAX_SIZE);
+  const unsigned new_hashed = old_hashed ? 2 * old_hashed : 1;
+  bucket **table = (bucket**) kissat_calloc (solver, new_hashed, sizeof (bucket *));
+  bucket **old_table = checker->table;
+  for (unsigned i = 0; i < old_hashed; i++) {
+    for (bucket *bucket = old_table[i], *next; bucket; bucket = next) {
+      next = bucket->next;
+      const unsigned reduced = reduce_hash (bucket->hash, new_hashed);
+      bucket->next = table[reduced];
+      table[reduced] = bucket;
+    }
+  }
+  kissat_dealloc (solver, checker->table, old_hashed, sizeof (bucket *));
+  checker->hashed = new_hashed;
+  checker->table = table;
+}
+
+static bucket *new_line (kissat *solver, checker *checker, unsigned size,
+                         unsigned hash) {
+  bucket *res = (bucket*)kissat_malloc (solver, bytes_line (size));
+  res->next = 0;
+  res->size = size;
+  res->hash = hash;
+  memcpy (res->lits, BEGIN_STACK (checker->imported),
+          size * sizeof *res->lits);
+  return res;
+}
+
+#define CHECKER_LITS (2 * (checker)->vars)
+#define VALID_CHECKER_LIT(LIT) ((LIT) < CHECKER_LITS)
+
+static bucket decision_line;
+static bucket unit_line;
+
+static void checker_assign (kissat *solver, checker *checker, unsigned lit,
+                            bucket *bucket) {
+#ifdef LOGGING
+  if (bucket == &decision_line)
+    LOG3 ("checker assign %u (decision)", lit);
+  else if (bucket == &unit_line)
+    LOG3 ("checker assign %u (unit)", lit);
+  else
+    LOGLINE3 ("checker assign %u reason", lit);
+#else
+  (void) bucket;
+#endif
+  KISSAT_assert (VALID_CHECKER_LIT (lit));
+  const unsigned not_lit = lit ^ 1;
+  signed char *values = checker->values;
+  KISSAT_assert (!values[lit]);
+  KISSAT_assert (!values[not_lit]);
+  values[lit] = 1;
+  values[not_lit] = -1;
+  PUSH_STACK (checker->trail, lit);
+}
+
+static buckets_ *checker_watches (checker *checker, unsigned lit) {
+  KISSAT_assert (VALID_CHECKER_LIT (lit));
+  return checker->watches + lit;
+}
+
+static void watch_checker_literal (kissat *solver, checker *checker,
+                                   bucket *bucket, unsigned lit) {
+  LOGLINE3 ("checker watches %u in", lit);
+  buckets_ *buckets = checker_watches (checker, lit);
+  PUSH_STACK (*buckets, bucket);
+}
+
+static void unwatch_checker_literal (kissat *solver, checker *checker,
+                                     bucket *bucket, unsigned lit) {
+  LOGLINE3 ("checker unwatches %u in", lit);
+  buckets_ *buckets = checker_watches (checker, lit);
+  REMOVE_STACK (struct bucket *, *buckets, bucket);
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+static void unwatch_line (kissat *solver, checker *checker,
+                          bucket *bucket) {
+  KISSAT_assert (bucket->size > 1);
+  const unsigned *const lits = bucket->lits;
+  unwatch_checker_literal (solver, checker, bucket, lits[0]);
+  unwatch_checker_literal (solver, checker, bucket, lits[1]);
+}
+
+static bool satisfied_or_trivial_imported (kissat *solver,
+                                           checker *checker) {
+  const unsigned *const lits = BEGIN_STACK (checker->imported);
+  const unsigned *const end_of_lits = END_STACK (checker->imported);
+  const signed char *values = checker->values;
+  bool *marks = checker->marks;
+  unsigned const *p;
+  bool res = false;
+  for (p = lits; !res && p != end_of_lits; p++) {
+    const unsigned lit = *p;
+    if (marks[lit])
+      continue;
+    marks[lit] = true;
+    const unsigned not_lit = lit ^ 1;
+    if (marks[not_lit]) {
+      LOGIMPORTED3 ("trivial by %u and %u imported checker", not_lit, lit);
+      res = true;
+    } else if (values[lit] > 0) {
+      LOGIMPORTED3 ("satisfied by %u imported checker", lit);
+      res = true;
+    }
+  }
+  for (const unsigned *q = lits; q != p; q++)
+    marks[*q] = 0;
+#ifndef LOGGING
+  (void) solver;
+#endif
+  return res;
+}
+
+static void mark_line (checker *checker) {
+  bool *marks = checker->marks;
+  for (all_stack (unsigned, lit, checker->imported))
+    marks[lit] = 1;
+  checker->marked = true;
+}
+
+static void unmark_line (checker *checker) {
+  bool *marks = checker->marks;
+  for (all_stack (unsigned, lit, checker->imported))
+    marks[lit] = 0;
+  checker->marked = false;
+}
+
+static bool simplify_imported (kissat *solver, checker *checker) {
+  if (checker->inconsistent) {
+    LOG3 ("skipping addition since checker already inconsistent");
+    return true;
+  }
+  unsigned non_false = 0;
+#ifdef LOGGING
+  unsigned num_false = 0;
+#endif
+  const unsigned *const end_of_lits = END_STACK (checker->imported);
+  unsigned *lits = BEGIN_STACK (checker->imported);
+  const signed char *values = checker->values;
+  bool *marks = checker->marks;
+  bool res = false;
+  unsigned *p;
+  for (p = lits; !res && p != end_of_lits; p++) {
+    const unsigned lit = *p;
+    if (marks[lit])
+      continue;
+    marks[lit] = true;
+    const unsigned not_lit = lit ^ 1;
+    if (marks[not_lit]) {
+      LOG3 ("simplified checker clause trivial (contains %u and %u)",
+            not_lit, lit);
+      res = true;
+    } else {
+      signed char lit_value = values[lit];
+      if (lit_value < 0) {
+#ifdef LOGGING
+        num_false++;
+#endif
+      } else if (lit_value > 0) {
+        LOG3 ("simplified checker clause satisfied by %u", lit);
+        res = true;
+      } else {
+        if (!non_false)
+          SWAP (unsigned, *p, lits[0]);
+        else if (non_false == 1)
+          SWAP (unsigned, *p, lits[1]);
+        non_false++;
+      }
+    }
+  }
+  for (const unsigned *q = lits; q != p; q++)
+    marks[*q] = 0;
+  if (!res) {
+    if (!non_false) {
+      LOG3 ("simplified checker clause inconsistent");
+      checker->inconsistent = true;
+      res = true;
+    } else if (non_false == 1) {
+      LOG3 ("simplified checker clause unit");
+      checker_assign (solver, checker, lits[0], &unit_line);
+      res = true;
+    }
+  }
+  if (!res) {
+    LOG3 ("non-trivial and non-satisfied imported checker clause "
+          "has %u false and %u non-false literals",
+          num_false, non_false);
+    LOGIMPORTED3 ("simplified checker");
+  }
+  return res;
+}
+
+static void use_literal (kissat *solver, checker *checker, unsigned lit) {
+  if (checker->used[lit])
+    return;
+  checker->used[lit] = true;
+#ifdef LOGGING
+  LOG3 ("used checker literal %u", lit);
+#else
+  (void) solver;
+#endif
+}
+
+static void large_literal (kissat *solver, checker *checker, unsigned lit) {
+  if (checker->large[lit])
+    return;
+  checker->large[lit] = true;
+#ifdef LOGGING
+  LOG3 ("large checker literal %u", lit);
+#else
+  (void) solver;
+#endif
+}
+
+static void use_line (kissat *solver, checker *checker) {
+  bool large = (SIZE_STACK (checker->imported) > 2);
+  for (all_stack (unsigned, lit, checker->imported)) {
+    use_literal (solver, checker, lit);
+    if (large)
+      large_literal (solver, checker, lit);
+  }
+}
+
+static void insert_imported (kissat *solver, checker *checker,
+                             unsigned hash) {
+  size_t size = SIZE_STACK (checker->imported);
+  KISSAT_assert (size <= UINT_MAX);
+  if (checker->buckets == checker->hashed)
+    resize_hash (solver, checker);
+  bucket *bucket = new_line (solver, checker, size, hash);
+  const unsigned reduced = reduce_hash (hash, checker->hashed);
+  struct bucket **p = checker->table + reduced;
+  bucket->next = *p;
+  *p = bucket;
+  LOGLINE3 ("inserted checker");
+  const unsigned *const lits = BEGIN_STACK (checker->imported);
+  const signed char *values = checker->values;
+  KISSAT_assert (!values[lits[0]]);
+  KISSAT_assert (!values[lits[1]]);
+  watch_checker_literal (solver, checker, bucket, lits[0]);
+  watch_checker_literal (solver, checker, bucket, lits[1]);
+  checker->buckets++;
+  checker->added++;
+}
+
+static void insert_imported_if_not_simplified (kissat *solver,
+                                               checker *checker) {
+  sort_line (solver, checker);
+  const unsigned hash = hash_line (checker);
+  if (!simplify_imported (solver, checker)) {
+    insert_imported (solver, checker, hash);
+    use_line (solver, checker);
+  }
+}
+
+static bool match_line (checker *checker, unsigned size, unsigned hash,
+                        bucket *bucket) {
+  if (bucket->size != size)
+    return false;
+  if (bucket->hash != hash)
+    return false;
+  if (!checker->marked)
+    mark_line (checker);
+  const unsigned *const lits = bucket->lits;
+  const unsigned *const end_of_lits = lits + bucket->size;
+  const bool *const marks = checker->marks;
+  for (const unsigned *p = lits; p != end_of_lits; p++)
+    if (!marks[*p])
+      return false;
+  return true;
+}
+
+static void resize_checker (kissat *solver, checker *checker,
+                            unsigned new_vars) {
+  const unsigned vars = checker->vars;
+  const unsigned size = checker->size;
+  if (new_vars > size) {
+    KISSAT_assert (new_vars <= MAX_SIZE);
+    unsigned new_size = size ? 2 * size : 1;
+    while (new_size < new_vars)
+      new_size *= 2;
+    KISSAT_assert (new_size <= MAX_SIZE);
+    LOG3 ("resizing checker form %u to %u", size, new_size);
+    const unsigned size2 = 2 * size;
+    const unsigned new_size2 = 2 * new_size;
+    checker->marks = (bool*)kissat_realloc (solver, checker->marks, size2,
+                                     new_size2 * sizeof (bool));
+    checker->used = (bool*)kissat_realloc (solver, checker->used, size2,
+                                    new_size2 * sizeof (bool));
+    checker->large = (bool*)kissat_realloc (solver, checker->large, size2,
+                                     new_size2 * sizeof (bool));
+    checker->values =
+      (signed char *)kissat_realloc (solver, checker->values, size2, new_size2);
+    checker->watches = (buckets_*)kissat_realloc (
+        solver, checker->watches, size2 * sizeof *checker->watches,
+        new_size2 * sizeof *checker->watches);
+    checker->size = new_size;
+  }
+  const unsigned delta = new_vars - vars;
+  if (delta == 1)
+    LOG3 ("initializing one checker variable %u", vars);
+  else
+    LOG3 ("initializing %u checker variables from %u to %u", delta, vars,
+          new_vars - 1);
+  const unsigned vars2 = 2 * vars;
+  const unsigned new_vars2 = 2 * new_vars;
+  const unsigned delta2 = 2 * delta;
+  KISSAT_assert (delta2 == new_vars2 - vars2);
+  memset (checker->watches + vars2, 0, delta2 * sizeof *checker->watches);
+  memset (checker->marks + vars2, 0, delta2);
+  memset (checker->used + vars2, 0, delta2);
+  memset (checker->large + vars2, 0, delta2);
+  memset (checker->values + vars2, 0, delta2);
+  checker->vars = new_vars;
+}
+
+static inline unsigned
+import_external_checker (kissat *solver, checker *checker, int elit) {
+  KISSAT_assert (elit);
+  const unsigned var = ABS (elit) - 1;
+  if (var >= checker->vars)
+    resize_checker (solver, checker, var + 1);
+  KISSAT_assert (var < checker->vars);
+  return 2 * var + (elit < 0);
+}
+
+static inline unsigned
+import_internal_checker (kissat *solver, checker *checker, unsigned ilit) {
+  const int elit = kissat_export_literal (solver, ilit);
+  return import_external_checker (solver, checker, elit);
+}
+
+static inline int export_checker (checker *checker, unsigned ilit) {
+  KISSAT_assert (ilit <= 2 * checker->vars);
+  return (1 + (ilit >> 1)) * ((ilit & 1) ? -1 : 1);
+}
+
+static bucket *find_line (kissat *solver, checker *checker, size_t size,
+                          bool remove) {
+  if (!checker->hashed)
+    return 0;
+  sort_line (solver, checker);
+  checker->searches++;
+  const unsigned hash = hash_line (checker);
+  const unsigned reduced = reduce_hash (hash, checker->hashed);
+  struct bucket **p, *bucket;
+  for (p = checker->table + reduced;
+       (bucket = *p) && !match_line (checker, size, hash, bucket);
+       p = &bucket->next)
+    checker->collisions++;
+  if (checker->marked)
+    unmark_line (checker);
+  if (bucket && remove)
+    *p = bucket->next;
+  return bucket;
+}
+
+static void remove_line (kissat *solver, checker *checker, size_t size) {
+  bucket *bucket = find_line (solver, checker, size, true);
+  if (!bucket) {
+    kissat_fatal_message_start ();
+    fputs ("trying to remove non-existing clause:\n", stderr);
+    for (all_stack (unsigned, lit, checker->imported))
+      fprintf (stderr, "%d ", export_checker (checker, lit));
+    fputs ("0\n", stderr);
+    fflush (stderr);
+    kissat_abort ();
+  }
+  unwatch_line (solver, checker, bucket);
+  LOGLINE3 ("removed checker");
+  kissat_free (solver, bucket, bytes_line (size));
+  KISSAT_assert (checker->buckets > 0);
+  checker->buckets--;
+  checker->removed++;
+}
+
+static void import_external_literals (kissat *solver, checker *checker,
+                                      size_t size, const int *elits) {
+  if (size > UINT_MAX)
+    kissat_fatal ("can not check handle original clause of size %zu", size);
+  CLEAR_STACK (checker->imported);
+  for (size_t i = 0; i < size; i++) {
+    const unsigned lit =
+        import_external_checker (solver, checker, elits[i]);
+    PUSH_STACK (checker->imported, lit);
+  }
+  LOGIMPORTED3 ("checker imported external");
+}
+
+static void import_internal_literals (kissat *solver, checker *checker,
+                                      size_t size, const unsigned *ilits) {
+  KISSAT_assert (size <= UINT_MAX);
+  CLEAR_STACK (checker->imported);
+  for (size_t i = 0; i < size; i++) {
+    const unsigned ilit = ilits[i];
+    const unsigned lit = import_internal_checker (solver, checker, ilit);
+    PUSH_STACK (checker->imported, lit);
+  }
+  LOGIMPORTED3 ("checker imported internal");
+}
+
+static void import_clause (kissat *solver, checker *checker, clause *c) {
+  import_internal_literals (solver, checker, c->size, c->lits);
+  LOGIMPORTED3 ("checker imported clause");
+}
+
+static void import_binary (kissat *solver, checker *checker, unsigned a,
+                           unsigned b) {
+  CLEAR_STACK (checker->imported);
+  const unsigned c = import_internal_checker (solver, checker, a);
+  const unsigned d = import_internal_checker (solver, checker, b);
+  PUSH_STACK (checker->imported, c);
+  PUSH_STACK (checker->imported, d);
+  LOGIMPORTED3 ("checker imported binary");
+}
+
+static void import_internal_unit (kissat *solver, checker *checker,
+                                  unsigned a) {
+  CLEAR_STACK (checker->imported);
+  const unsigned b = import_internal_checker (solver, checker, a);
+  PUSH_STACK (checker->imported, b);
+  LOGIMPORTED3 ("checker imported unit");
+}
+
+static bool checker_propagate (kissat *solver, checker *checker) {
+  unsigned propagated = checker->propagated;
+  signed char *values = checker->values;
+  bool res = true;
+  while (res && propagated < SIZE_STACK (checker->trail)) {
+    const unsigned lit = PEEK_STACK (checker->trail, propagated);
+    const unsigned not_lit = lit ^ 1;
+    LOG3 ("checker propagate %u", lit);
+    KISSAT_assert (values[lit] > 0);
+    KISSAT_assert (values[not_lit] < 0);
+    propagated++;
+    buckets_ *buckets = checker_watches (checker, not_lit);
+    bucket **begin_of_lines = BEGIN_STACK (*buckets), **q = begin_of_lines;
+    bucket *const *end_of_lines = END_STACK (*buckets), *const *p = q;
+    while (p != end_of_lines) {
+      bucket *bucket = *q++ = *p++;
+      if (!res)
+        continue;
+      unsigned *lits = bucket->lits;
+      const unsigned other = not_lit ^ lits[0] ^ lits[1];
+      const signed char other_value = values[other];
+      if (other_value > 0)
+        continue;
+      const unsigned *const end_of_lits = lits + bucket->size;
+      unsigned replacement;
+      signed char replacement_value = -1;
+      unsigned *r;
+      for (r = lits + 2; r != end_of_lits; r++) {
+        replacement = *r;
+        if (replacement == other)
+          continue;
+        if (replacement == not_lit)
+          continue;
+        replacement_value = values[replacement];
+        if (replacement_value >= 0)
+          break;
+      }
+      if (replacement_value >= 0) {
+        lits[0] = other;
+        lits[1] = replacement;
+        *r = not_lit;
+        LOGLINE3 ("checker unwatching %u in", not_lit);
+        watch_checker_literal (solver, checker, bucket, replacement);
+        q--;
+      } else if (other_value < 0) {
+        LOGLINE3 ("checker conflict");
+        res = false;
+      } else
+        checker_assign (solver, checker, other, bucket);
+    }
+    SET_END_OF_STACK (*buckets, q);
+  }
+  checker->propagations += propagated - checker->propagated;
+  checker->propagated = propagated;
+  return res;
+}
+
+static bool bucket_redundant (kissat *solver, checker *checker,
+                              size_t size) {
+  if (!checker_propagate (solver, checker)) {
+    LOG3 ("root level checker unit propagations leads to conflict");
+    LOG2 ("checker becomes inconsistent");
+    checker->inconsistent = true;
+    return true;
+  }
+  if (checker->inconsistent) {
+    LOG3 ("skipping removal since checker already inconsistent");
+    return true;
+  }
+  if (!size)
+    kissat_fatal ("checker can not remove empty checker clause");
+  if (size == 1) {
+    const unsigned unit = PEEK_STACK (checker->imported, 0);
+    const signed char value = checker->values[unit];
+    if (value < 0 && !checker->inconsistent)
+      kissat_fatal ("consistent checker can not remove falsified unit %d",
+                    export_checker (checker, unit));
+    if (!value)
+      kissat_fatal ("checker can not remove unassigned unit %d",
+                    export_checker (checker, unit));
+    LOG3 ("checker skips removal of satisfied unit %u", unit);
+    return true;
+  } else if (satisfied_or_trivial_imported (solver, checker)) {
+    LOGIMPORTED3 ("satisfied imported checker");
+    return true;
+  } else
+    return false;
+}
+
+static void remove_line_if_not_redundant (kissat *solver,
+                                          checker *checker) {
+  size_t size = SIZE_STACK (checker->imported);
+  if (!bucket_redundant (solver, checker, size))
+    remove_line (solver, checker, size);
+}
+
+static void checker_backtrack (checker *checker, unsigned saved) {
+  unsigned *begin = BEGIN_STACK (checker->trail) + saved;
+  unsigned *p = END_STACK (checker->trail);
+  signed char *values = checker->values;
+  while (p != begin) {
+    const unsigned lit = *--p;
+    KISSAT_assert (VALID_CHECKER_LIT (lit));
+    const unsigned not_lit = lit ^ 1;
+    KISSAT_assert (values[lit] > 0);
+    KISSAT_assert (values[not_lit] < 0);
+    values[lit] = values[not_lit] = 0;
+  }
+  checker->propagated = saved;
+  SET_END_OF_STACK (checker->trail, begin);
+}
+
+static bool checker_blocked_literal (kissat *solver, checker *checker,
+                                     unsigned lit) {
+  signed char *values = checker->values;
+  KISSAT_assert (values[lit] < 0);
+  const unsigned not_lit = lit ^ 1;
+  if (checker->large[not_lit])
+    return false;
+  buckets_ *buckets = checker_watches (checker, not_lit);
+  bucket *const *const begin_of_lines = BEGIN_STACK (*buckets);
+  bucket *const *const end_of_lines = END_STACK (*buckets);
+  bucket *const *p = begin_of_lines;
+  while (p != end_of_lines) {
+    bucket *bucket = *p++;
+    const unsigned *const lits = bucket->lits;
+    const unsigned *const end_of_lits = lits + bucket->size;
+    const unsigned *l = lits;
+    while (l != end_of_lits) {
+      const unsigned other = *l++;
+      if (other == not_lit)
+        continue;
+      if (values[other] > 0)
+        goto CONTINUE_WITH_NEXT_BUCKET;
+    }
+    return false;
+  CONTINUE_WITH_NEXT_BUCKET:;
+  }
+#ifdef LOGGING
+  LOG3 ("blocked literal %u", lit);
+#else
+  (void) solver;
+#endif
+  return true;
+}
+
+static bool checker_blocked_imported (kissat *solver, checker *checker) {
+  for (all_stack (unsigned, lit, checker->imported))
+    if (checker_blocked_literal (solver, checker, lit))
+      return true;
+  return false;
+}
+
+static void check_line (kissat *solver, checker *checker) {
+  checker->checked++;
+  if (checker->inconsistent)
+    return;
+  if (!checker_propagate (solver, checker)) {
+    LOG3 ("root level checker unit propagations leads to conflict");
+    LOG2 ("checker becomes inconsistent");
+    checker->inconsistent = true;
+    return;
+  }
+  const unsigned saved = SIZE_STACK (checker->trail);
+  signed char *values = checker->values;
+  bool satisfied = false, pure = false;
+  unsigned decisions = 0, prev = INVALID_LIT;
+  for (all_stack (unsigned, lit, checker->imported)) {
+    KISSAT_assert (prev != lit);
+    prev = lit;
+    signed char lit_value = values[lit];
+    if (lit_value < 0)
+      continue;
+    if (lit_value > 0) {
+      LOG3 ("found satisfied literal %u", lit);
+      checker->satisfied++;
+      satisfied = true;
+      break;
+    }
+    const unsigned not_lit = lit ^ 1;
+    bool used = checker->used[not_lit];
+    if (!used) {
+      LOG3 ("found pure literal %u", lit);
+      checker->pure++;
+      pure = true;
+      break;
+    }
+    checker_assign (solver, checker, not_lit, &decision_line);
+    decisions++;
+  }
+  checker->decisions += decisions;
+  if (!satisfied && !pure) {
+    if (!checker_propagate (solver, checker))
+      LOG3 ("checker imported clause unit implied");
+    else if (checker_blocked_imported (solver, checker)) {
+      LOG3 ("checker imported clause binary blocked");
+      checker->blocked++;
+    } else {
+      kissat_fatal_message_start ();
+      fputs ("failed to check clause:\n", stderr);
+      for (all_stack (unsigned, lit, checker->imported))
+        fprintf (stderr, "%d ", export_checker (checker, lit));
+      fputs ("0\n", stderr);
+      fflush (stderr);
+      kissat_abort ();
+    }
+  }
+  checker_backtrack (checker, saved);
+}
+
+void kissat_add_unchecked_external (kissat *solver, size_t size,
+                                    const int *elits) {
+  LOGINTS3 (size, elits, "adding unchecked external checker");
+  checker *checker = solver->checker;
+  checker->unchecked++;
+  import_external_literals (solver, checker, size, elits);
+  insert_imported_if_not_simplified (solver, checker);
+}
+
+void kissat_add_unchecked_internal (kissat *solver, size_t size,
+                                    unsigned *lits) {
+  LOGUNSIGNEDS3 (size, lits, "adding unchecked internal checker");
+  checker *checker = solver->checker;
+  checker->unchecked++;
+  KISSAT_assert (size <= UINT_MAX);
+  import_internal_literals (solver, checker, size, lits);
+  insert_imported_if_not_simplified (solver, checker);
+}
+
+void kissat_check_and_add_binary (kissat *solver, unsigned a, unsigned b) {
+  LOGBINARY3 (a, b, "checking and adding internal checker");
+  checker *checker = solver->checker;
+  KISSAT_assert (VALID_INTERNAL_LITERAL (a));
+  KISSAT_assert (VALID_INTERNAL_LITERAL (b));
+  import_binary (solver, checker, a, b);
+  check_line (solver, checker);
+  insert_imported_if_not_simplified (solver, checker);
+}
+
+void kissat_check_and_add_clause (kissat *solver, clause *clause) {
+  LOGCLS3 (clause, "checking and adding internal checker");
+  checker *checker = solver->checker;
+  import_clause (solver, checker, clause);
+  check_line (solver, checker);
+  insert_imported_if_not_simplified (solver, checker);
+}
+
+void kissat_check_and_add_empty (kissat *solver) {
+  LOG3 ("checking and adding empty checker clause");
+  checker *checker = solver->checker;
+  CLEAR_STACK (checker->imported);
+  check_line (solver, checker);
+  insert_imported_if_not_simplified (solver, checker);
+}
+
+void kissat_check_and_add_internal (kissat *solver, size_t size,
+                                    const unsigned *lits) {
+  LOGUNSIGNEDS3 (size, lits, "checking and adding internal checker");
+  checker *checker = solver->checker;
+  import_internal_literals (solver, checker, size, lits);
+  check_line (solver, checker);
+  insert_imported_if_not_simplified (solver, checker);
+}
+
+void kissat_check_and_add_unit (kissat *solver, unsigned a) {
+  LOG3 ("checking and adding internal checker internal unit %u", a);
+  checker *checker = solver->checker;
+  KISSAT_assert (VALID_INTERNAL_LITERAL (a));
+  import_internal_unit (solver, checker, a);
+  check_line (solver, checker);
+  insert_imported_if_not_simplified (solver, checker);
+}
+
+void kissat_check_shrink_clause (kissat *solver, clause *c, unsigned remove,
+                                 unsigned keep) {
+  LOGCLS3 (c, "checking and shrinking by %u internal checker", remove);
+  checker *checker = solver->checker;
+  CLEAR_STACK (checker->imported);
+  const value *const values = solver->values;
+  for (all_literals_in_clause (ilit, c)) {
+    if (ilit == remove)
+      continue;
+    if (ilit != keep && values[ilit] < 0 && !LEVEL (ilit))
+      continue;
+    const unsigned lit = import_internal_checker (solver, checker, ilit);
+    PUSH_STACK (checker->imported, lit);
+  }
+  LOGIMPORTED3 ("checker imported internal");
+  check_line (solver, checker);
+  insert_imported_if_not_simplified (solver, checker);
+  import_clause (solver, checker, c);
+  remove_line_if_not_redundant (solver, checker);
+}
+
+void kissat_remove_checker_binary (kissat *solver, unsigned a, unsigned b) {
+  LOGBINARY3 (a, b, "removing internal checker");
+  checker *checker = solver->checker;
+  KISSAT_assert (VALID_INTERNAL_LITERAL (a));
+  KISSAT_assert (VALID_INTERNAL_LITERAL (b));
+  import_binary (solver, checker, a, b);
+  remove_line_if_not_redundant (solver, checker);
+}
+
+void kissat_remove_checker_clause (kissat *solver, clause *clause) {
+  LOGCLS3 (clause, "removing internal checker");
+  checker *checker = solver->checker;
+  import_clause (solver, checker, clause);
+  remove_line_if_not_redundant (solver, checker);
+}
+
+bool kissat_checker_contains_clause (kissat *solver, clause *clause) {
+  checker *checker = solver->checker;
+  import_clause (solver, checker, clause);
+  size_t size = SIZE_STACK (checker->imported);
+  if (bucket_redundant (solver, checker, size))
+    return true;
+  return find_line (solver, checker, size, false);
+}
+
+void kissat_remove_checker_external (kissat *solver, size_t size,
+                                     const int *elits) {
+  LOGINTS3 (size, elits, "removing external checker");
+  checker *checker = solver->checker;
+  import_external_literals (solver, checker, size, elits);
+  remove_line_if_not_redundant (solver, checker);
+}
+
+void kissat_remove_checker_internal (kissat *solver, size_t size,
+                                     const unsigned *ilits) {
+  LOGUNSIGNEDS3 (size, ilits, "removing internal checker");
+  checker *checker = solver->checker;
+  import_internal_literals (solver, checker, size, ilits);
+  remove_line_if_not_redundant (solver, checker);
+}
+
+void dump_line (bucket *bucket) {
+  printf ("bucket[%p]", (void *) bucket);
+  for (unsigned i = 0; i < bucket->size; i++)
+    printf (" %u", bucket->lits[i]);
+  fputc ('\n', stdout);
+}
+
+void dump_checker (kissat *solver) {
+  checker *checker = solver->checker;
+  printf ("%s\n", checker->inconsistent ? "inconsistent" : "consistent");
+  printf ("vars %u\n", checker->vars);
+  printf ("size %u\n", checker->size);
+  printf ("buckets %u\n", checker->buckets);
+  printf ("hashed %u\n", checker->hashed);
+  for (unsigned i = 0; i < SIZE_STACK (checker->trail); i++)
+    printf ("trail[%u] %u\n", i, PEEK_STACK (checker->trail, i));
+  for (unsigned h = 0; h < checker->hashed; h++)
+    for (bucket *bucket = checker->table[h]; bucket; bucket = bucket->next)
+      dump_line (bucket);
+}
+
+ABC_NAMESPACE_IMPL_END
+
+#else
+ABC_NAMESPACE_IMPL_START
+int kissat_check_dummy_to_avoid_warning;
+ABC_NAMESPACE_IMPL_END
+#endif
+
diff --git a/src/sat/kissat/check.h b/src/sat/kissat/check.h
new file mode 100644
index 000000000..e6065fd1d
--- /dev/null
+++ b/src/sat/kissat/check.h
@@ -0,0 +1,181 @@
+#ifndef _check_h_INCLUDED
+#define _check_h_INCLUDED
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifndef KISSAT_NDEBUG
+
+struct kissat;
+
+void kissat_check_satisfying_assignment (struct kissat *);
+
+typedef struct checker checker;
+
+struct clause;
+
+void kissat_init_checker (struct kissat *);
+void kissat_release_checker (struct kissat *);
+
+#ifndef KISSAT_QUIET
+void kissat_print_checker_statistics (struct kissat *, bool verbose);
+#endif
+
+void kissat_add_unchecked_external (struct kissat *, size_t, const int *);
+
+void kissat_check_and_add_binary (struct kissat *, unsigned, unsigned);
+void kissat_check_and_add_clause (struct kissat *, struct clause *c);
+void kissat_check_and_add_empty (struct kissat *);
+void kissat_check_and_add_internal (struct kissat *, size_t,
+                                    const unsigned *);
+void kissat_check_and_add_unit (struct kissat *, unsigned);
+
+void kissat_check_shrink_clause (struct kissat *, struct clause *,
+                                 unsigned remove, unsigned keep);
+
+void kissat_remove_checker_binary (struct kissat *, unsigned, unsigned);
+void kissat_remove_checker_clause (struct kissat *, struct clause *c);
+void kissat_remove_checker_external (struct kissat *, size_t, const int *);
+
+void kissat_remove_checker_internal (struct kissat *, size_t,
+                                     const unsigned *);
+
+#define ADD_UNCHECKED_EXTERNAL(SIZE, LITS) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_add_unchecked_external (solver, (SIZE), (LITS)); \
+  } while (0)
+
+#define CHECK_AND_ADD_BINARY(A, B) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_check_and_add_binary (solver, (A), (B)); \
+  } while (0)
+
+#define CHECK_AND_ADD_TERNARY(A, B, C) \
+  do { \
+    if (GET_OPTION (check) > 1) { \
+      unsigned CLAUSE[3] = {(A), (B), (C)}; \
+      kissat_check_and_add_internal (solver, 3, CLAUSE); \
+    } \
+  } while (0)
+
+#define CHECK_AND_ADD_CLAUSE(CLAUSE) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_check_and_add_clause (solver, (CLAUSE)); \
+  } while (0)
+
+#define CHECK_AND_ADD_EMPTY() \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_check_and_add_empty (solver); \
+  } while (0)
+
+#define CHECK_AND_ADD_LITS(SIZE, LITS) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_check_and_add_internal (solver, (SIZE), (LITS)); \
+  } while (0)
+
+#define CHECK_AND_ADD_STACK(S) \
+  CHECK_AND_ADD_LITS (SIZE_STACK (S), BEGIN_STACK (S))
+
+#define CHECK_AND_ADD_UNIT(A) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_check_and_add_unit (solver, (A)); \
+  } while (0)
+
+#define CHECK_SHRINK_CLAUSE(C, REMOVE, KEEP) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_check_shrink_clause (solver, (C), (REMOVE), (KEEP)); \
+  } while (0)
+
+#define REMOVE_CHECKER_BINARY(A, B) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_remove_checker_binary (solver, (A), (B)); \
+  } while (0)
+
+#define REMOVE_CHECKER_TERNARY(A, B, C) \
+  do { \
+    if (GET_OPTION (check) > 1) { \
+      unsigned CLAUSE[3] = {(A), (B), (C)}; \
+      kissat_remove_checker_internal (solver, 3, CLAUSE); \
+    } \
+  } while (0)
+
+#define REMOVE_CHECKER_CLAUSE(CLAUSE) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_remove_checker_clause (solver, (CLAUSE)); \
+  } while (0)
+
+#define REMOVE_CHECKER_LITS(SIZE, LITS) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_remove_checker_internal (solver, (SIZE), (LITS)); \
+  } while (0)
+
+#define REMOVE_CHECKER_STACK(S) \
+  do { \
+    if (GET_OPTION (check) > 1) \
+      kissat_remove_checker_internal (solver, SIZE_STACK (S), \
+                                      BEGIN_STACK (S)); \
+  } while (0)
+
+#else
+
+#define ADD_UNCHECKED_EXTERNAL(...) \
+  do { \
+  } while (0)
+#define CHECK_AND_ADD_BINARY(...) \
+  do { \
+  } while (0)
+#define CHECK_AND_ADD_TERNARY(...) \
+  do { \
+  } while (0)
+#define CHECK_AND_ADD_CLAUSE(...) \
+  do { \
+  } while (0)
+#define CHECK_AND_ADD_EMPTY(...) \
+  do { \
+  } while (0)
+#define CHECK_AND_ADD_LITS(...) \
+  do { \
+  } while (0)
+#define CHECK_AND_ADD_STACK(...) \
+  do { \
+  } while (0)
+#define CHECK_AND_ADD_UNIT(...) \
+  do { \
+  } while (0)
+#define CHECK_SHRINK_CLAUSE(...) \
+  do { \
+  } while (0)
+#define REMOVE_CHECKER_BINARY(...) \
+  do { \
+  } while (0)
+#define REMOVE_CHECKER_TERNARY(...) \
+  do { \
+  } while (0)
+#define REMOVE_CHECKER_CLAUSE(...) \
+  do { \
+  } while (0)
+#define REMOVE_CHECKER_LITS(...) \
+  do { \
+  } while (0)
+#define REMOVE_CHECKER_STACK(...) \
+  do { \
+  } while (0)
+
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/classify.c b/src/sat/kissat/classify.c
new file mode 100644
index 000000000..5b86239bf
--- /dev/null
+++ b/src/sat/kissat/classify.c
@@ -0,0 +1,32 @@
+#include "classify.h"
+#include "internal.h"
+#include "print.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_classify (struct kissat *solver) {
+  statistics *s = &solver->statistics_;
+  uint64_t clauses = s->clauses_binary + s->clauses_irredundant;
+  unsigned small_clauses_limit = GET_OPTION (smallclauses);
+  if (clauses <= small_clauses_limit) {
+    solver->classification.small = true;
+    solver->classification.bigbig = false;
+  } else {
+    solver->classification.small = false;
+    unsigned bigbigfraction = GET_OPTION (bigbigfraction);
+    double percent = bigbigfraction / 1000.0;
+    double actual = kissat_percent (s->clauses_binary, clauses);
+    if (actual >= percent)
+      solver->classification.bigbig = true;
+    else
+      solver->classification.bigbig = false;
+  }
+  kissat_very_verbose (
+      solver, "formula classified as having a %s total number of clauses",
+      solver->classification.small ? "small" : "large");
+  kissat_very_verbose (
+      solver, "formula classified to have a %s binary clauses fraction",
+      solver->classification.bigbig ? "large" : "small");
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/classify.h b/src/sat/kissat/classify.h
new file mode 100644
index 000000000..7590e72d0
--- /dev/null
+++ b/src/sat/kissat/classify.h
@@ -0,0 +1,22 @@
+#ifndef _classify_h_INCLUDED
+#define _classify_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+struct classification {
+  bool small;
+  bool bigbig;
+};
+
+typedef struct classification classification;
+
+void kissat_classify (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/clause.c b/src/sat/kissat/clause.c
new file mode 100644
index 000000000..9e50462cb
--- /dev/null
+++ b/src/sat/kissat/clause.c
@@ -0,0 +1,191 @@
+#include "allocate.h"
+#include "collect.h"
+#include "inline.h"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void inc_clause (kissat *solver, bool original, bool redundant,
+                        bool binary) {
+  if (binary)
+    INC (clauses_binary);
+  else if (redundant)
+    INC (clauses_redundant);
+  else
+    INC (clauses_irredundant);
+  INC (clauses_added);
+  if (original)
+    INC (clauses_original);
+}
+
+static void dec_clause (kissat *solver, bool redundant, bool binary) {
+  if (binary)
+    DEC (clauses_binary);
+  else if (redundant)
+    DEC (clauses_redundant);
+  else
+    DEC (clauses_irredundant);
+}
+
+static void init_clause (clause *res, bool redundant, unsigned glue,
+                         unsigned size) {
+  KISSAT_assert (size <= UINT_MAX);
+  KISSAT_assert (redundant || !glue);
+
+  glue = MIN (MAX_GLUE, glue);
+
+  res->glue = glue;
+  res->garbage = false;
+  res->quotient = false;
+  res->reason = false;
+  res->redundant = redundant;
+  res->shrunken = false;
+  res->subsume = false;
+  res->swept = false;
+  res->vivify = false;
+
+  res->used = 0;
+
+  res->searched = 2;
+  res->size = size;
+}
+
+void kissat_connect_referenced (kissat *solver, reference ref) {
+  watches *all_watches = solver->watches;
+  clause *c = kissat_dereference_clause (solver, ref);
+  kissat_inlined_connect_clause (solver, all_watches, c, ref);
+}
+
+void kissat_connect_clause (kissat *solver, clause *c) {
+  watches *all_watches = solver->watches;
+  const reference ref = kissat_reference_clause (solver, c);
+  kissat_inlined_connect_clause (solver, all_watches, c, ref);
+}
+
+static reference new_binary_clause (kissat *solver, bool original,
+                                    bool watch, unsigned first,
+                                    unsigned second) {
+  KISSAT_assert (first != second);
+  KISSAT_assert (first != NOT (second));
+  if (watch)
+    kissat_watch_binary (solver, first, second);
+  kissat_mark_added_literal (solver, first);
+  kissat_mark_added_literal (solver, second);
+  inc_clause (solver, original, false, true);
+  if (!original) {
+    CHECK_AND_ADD_BINARY (first, second);
+    ADD_BINARY_TO_PROOF (first, second);
+  }
+  return INVALID_REF;
+}
+
+static reference new_large_clause (kissat *solver, bool original,
+                                   bool redundant, unsigned glue,
+                                   unsigned size, unsigned *lits) {
+  KISSAT_assert (size > 2);
+  reference res = kissat_allocate_clause (solver, size);
+  clause *c = kissat_unchecked_dereference_clause (solver, res);
+  init_clause (c, redundant, glue, size);
+  memcpy (c->lits, lits, size * sizeof (unsigned));
+  LOGREF (res, "new");
+  if (solver->watching)
+    kissat_watch_reference (solver, lits[0], lits[1], res);
+  else
+    kissat_connect_clause (solver, c);
+  if (redundant) {
+    if (solver->first_reducible == INVALID_REF)
+      solver->first_reducible = res;
+  } else {
+    kissat_mark_added_literals (solver, size, lits);
+    solver->last_irredundant = res;
+  }
+  inc_clause (solver, original, redundant, false);
+  if (!original) {
+    CHECK_AND_ADD_CLAUSE (c);
+    ADD_CLAUSE_TO_PROOF (c);
+  }
+  return res;
+}
+
+static reference new_clause (kissat *solver, bool original, bool redundant,
+                             unsigned glue, unsigned size, unsigned *lits) {
+  reference res;
+  if (size == 2)
+    res = new_binary_clause (solver, original, true, lits[0], lits[1]);
+  else
+    res = new_large_clause (solver, original, redundant, glue, size, lits);
+  kissat_defrag_watches_if_needed (solver);
+  return res;
+}
+
+void kissat_new_binary_clause (kissat *solver, unsigned first,
+                               unsigned second) {
+  (void) new_binary_clause (solver, false, true, first, second);
+}
+
+void kissat_new_unwatched_binary_clause (kissat *solver, unsigned first,
+                                         unsigned second) {
+  (void) new_binary_clause (solver, false, false, first, second);
+}
+
+reference kissat_new_original_clause (kissat *solver) {
+  const unsigned size = SIZE_STACK (solver->clause);
+  unsigned *lits = BEGIN_STACK (solver->clause);
+  kissat_sort_literals (solver, size, lits);
+  reference res = new_clause (solver, true, false, 0, size, lits);
+  return res;
+}
+
+reference kissat_new_irredundant_clause (kissat *solver) {
+  const unsigned size = SIZE_STACK (solver->clause);
+  unsigned *lits = BEGIN_STACK (solver->clause);
+  return new_clause (solver, false, false, 0, size, lits);
+}
+
+reference kissat_new_redundant_clause (kissat *solver, unsigned glue) {
+  const unsigned size = SIZE_STACK (solver->clause);
+  unsigned *lits = BEGIN_STACK (solver->clause);
+  return new_clause (solver, false, true, glue, size, lits);
+}
+
+static void mark_clause_as_garbage (kissat *solver, clause *c) {
+  KISSAT_assert (!c->garbage);
+  LOGCLS (c, "garbage");
+  if (!c->redundant)
+    kissat_mark_removed_literals (solver, c->size, c->lits);
+  REMOVE_CHECKER_CLAUSE (c);
+  DELETE_CLAUSE_FROM_PROOF (c);
+  KISSAT_assert (c->size > 2);
+  dec_clause (solver, c->redundant, false);
+  c->garbage = true;
+}
+
+void kissat_mark_clause_as_garbage (kissat *solver, clause *c) {
+  KISSAT_assert (!c->garbage);
+  mark_clause_as_garbage (solver, c);
+  size_t bytes = kissat_actual_bytes_of_clause (c);
+  ADD (arena_garbage, bytes);
+}
+
+clause *kissat_delete_clause (kissat *solver, clause *c) {
+  LOGCLS (c, "delete");
+  KISSAT_assert (c->size > 2);
+  KISSAT_assert (c->garbage);
+  size_t bytes = kissat_actual_bytes_of_clause (c);
+  SUB (arena_garbage, bytes);
+  INC (clauses_deleted);
+  return (clause *) ((char *) c + bytes);
+}
+
+void kissat_delete_binary (kissat *solver, unsigned a, unsigned b) {
+  LOGBINARY (a, b, "delete");
+  kissat_mark_removed_literal (solver, a);
+  kissat_mark_removed_literal (solver, b);
+  REMOVE_CHECKER_BINARY (a, b);
+  DELETE_BINARY_FROM_PROOF (a, b);
+  dec_clause (solver, false, true);
+  INC (clauses_deleted);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/clause.h b/src/sat/kissat/clause.h
new file mode 100644
index 000000000..52e9c6fd1
--- /dev/null
+++ b/src/sat/kissat/clause.h
@@ -0,0 +1,95 @@
+#ifndef _clause_h_INCLUDED
+#define _clause_h_INCLUDED
+
+#include "arena.h"
+#include "literal.h"
+#include "reference.h"
+#include "utilities.h"
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct clause clause;
+
+#define LD_MAX_GLUE 19
+#define LD_MAX_USED 5
+
+#define MAX_GLUE ((1u << LD_MAX_GLUE) - 1)
+#define MAX_USED ((1u << LD_MAX_USED) - 1)
+
+struct clause {
+  unsigned glue : LD_MAX_GLUE;
+
+  bool garbage : 1;
+  bool quotient : 1;
+  bool reason : 1;
+  bool redundant : 1;
+  bool shrunken : 1;
+  bool subsume : 1;
+  bool swept : 1;
+  bool vivify : 1;
+
+  unsigned used : LD_MAX_USED;
+
+  unsigned searched;
+  unsigned size;
+
+  unsigned lits[3];
+};
+
+#define SIZE_OF_CLAUSE_HEADER ((size_t) & ((clause *) 0)->searched)
+
+#define BEGIN_LITS(C) ((C)->lits)
+#define END_LITS(C) (BEGIN_LITS (C) + (C)->size)
+
+#define all_literals_in_clause(LIT, C) \
+  unsigned LIT, \
+      *LIT##_PTR = BEGIN_LITS (C), *const LIT##_END = END_LITS (C); \
+  LIT##_PTR != LIT##_END && ((LIT = *LIT##_PTR), true); \
+  ++LIT##_PTR
+
+static inline size_t kissat_bytes_of_clause (unsigned size) {
+  const size_t res = sizeof (clause) + (size - 3) * sizeof (unsigned);
+  return kissat_align_ward (res);
+}
+
+static inline size_t kissat_actual_bytes_of_clause (clause *c) {
+  unsigned const *p = END_LITS (c);
+  if (c->shrunken)
+    while (*p++ != INVALID_LIT)
+      ;
+  return kissat_align_ward ((char *) p - (char *) c);
+}
+
+static inline clause *kissat_next_clause (clause *c) {
+  word bytes = kissat_actual_bytes_of_clause (c);
+  return (clause *) ((char *) c + bytes);
+}
+
+struct kissat;
+
+void kissat_new_binary_clause (struct kissat *, unsigned, unsigned);
+void kissat_new_unwatched_binary_clause (struct kissat *, unsigned,
+                                         unsigned);
+
+reference kissat_new_original_clause (struct kissat *);
+reference kissat_new_irredundant_clause (struct kissat *);
+reference kissat_new_redundant_clause (struct kissat *, unsigned glue);
+
+#ifndef INLINE_SORT
+void kissat_sort_literals (struct kissat *, unsigned size, unsigned *lits);
+#endif
+
+void kissat_connect_clause (struct kissat *, clause *);
+void kissat_connect_referenced (struct kissat *solver, reference);
+
+clause *kissat_delete_clause (struct kissat *, clause *);
+void kissat_delete_binary (struct kissat *, unsigned, unsigned);
+
+void kissat_mark_clause_as_garbage (struct kissat *, clause *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/collect.c b/src/sat/kissat/collect.c
new file mode 100644
index 000000000..3dfffe2db
--- /dev/null
+++ b/src/sat/kissat/collect.c
@@ -0,0 +1,742 @@
+#define INLINE_SORT
+
+#include "collect.h"
+#include "allocate.h"
+#include "colors.h"
+#include "compact.h"
+#include "inline.h"
+#include "print.h"
+#include "report.h"
+#include "sort.c"
+#include "trail.h"
+
+#include <inttypes.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void flush_watched_clauses_by_literal (kissat *solver, unsigned lit,
+                                              bool compact,
+                                              reference start) {
+  KISSAT_assert (start != INVALID_REF);
+
+  const value *const values = solver->values;
+  const assigned *const all_assigned = solver->assigned;
+
+  const value lit_value = values[lit];
+  const assigned *const lit_assigned = all_assigned + IDX (lit);
+  const value lit_fixed =
+      (lit_value && !lit_assigned->level) ? lit_value : 0;
+  const unsigned mlit = kissat_map_literal (solver, lit, true);
+
+  watches *lit_watches = &WATCHES (lit);
+  watch *begin = BEGIN_WATCHES (*lit_watches), *q = begin;
+  const watch *const end_of_watches = END_WATCHES (*lit_watches), *p = q;
+
+  while (p != end_of_watches) {
+    watch head = *p++;
+    if (head.type.binary) {
+      const unsigned other = head.binary.lit;
+      const unsigned other_idx = IDX (other);
+      const value other_value = values[other];
+      const value other_fixed =
+          (other_value && !all_assigned[other_idx].level) ? other_value : 0;
+      const unsigned mother = kissat_map_literal (solver, other, compact);
+      if (lit_fixed > 0 || other_fixed > 0 || mother == INVALID_LIT) {
+        if (lit < other)
+          kissat_delete_binary (solver, lit, other);
+      } else {
+        KISSAT_assert (!lit_fixed);
+        KISSAT_assert (!other_fixed);
+
+        {
+          head.binary.lit = mother;
+          *q++ = head;
+#ifdef LOGGING
+          if (lit < other) {
+            LOGBINARY (lit, other, "SRC");
+            LOGBINARY (mlit, mother, "DST");
+          }
+#endif
+        }
+      }
+    } else {
+      KISSAT_assert (solver->watching);
+      const watch tail = *p++;
+      if (!lit_fixed) {
+        const reference ref = tail.large.ref;
+        if (ref < start) {
+          *q++ = head;
+          *q++ = tail;
+        }
+      }
+    }
+  }
+
+  KISSAT_assert (!lit_fixed || q == begin);
+  SET_END_OF_WATCHES (*lit_watches, q);
+#ifdef LOGGING
+  const size_t size_lit_watches = SIZE_WATCHES (*lit_watches);
+  LOG ("keeping %zu watches[%u]", size_lit_watches, lit);
+#endif
+  if (!compact)
+    return;
+
+  if (mlit == INVALID_LIT)
+    return;
+
+  watches *mlit_watches = &WATCHES (mlit);
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  const size_t size_mlit_watches = SIZE_WATCHES (*mlit_watches);
+#endif
+  if (lit_fixed)
+    KISSAT_assert (!size_mlit_watches);
+  else if (mlit < lit) {
+    KISSAT_assert (mlit != INVALID_LIT);
+    KISSAT_assert (mlit < lit);
+    *mlit_watches = *lit_watches;
+    LOG ("copied watches[%u] = watches[%u] (size %zu)", mlit, lit,
+         size_mlit_watches);
+    memset (lit_watches, 0, sizeof *lit_watches);
+  } else
+    KISSAT_assert (mlit == lit);
+}
+
+static void flush_all_watched_clauses (kissat *solver, bool compact,
+                                       reference start) {
+  KISSAT_assert (solver->watching);
+  LOG ("starting to flush watches at clause[%" REFERENCE_FORMAT "]", start);
+  for (all_variables (idx)) {
+    const unsigned lit = LIT (idx);
+    flush_watched_clauses_by_literal (solver, lit, compact, start);
+    const unsigned not_lit = NOT (lit);
+    flush_watched_clauses_by_literal (solver, not_lit, compact, start);
+  }
+}
+
+static void update_large_reason (kissat *solver, assigned *assigned,
+                                 unsigned forced, clause *dst) {
+  KISSAT_assert (dst->reason);
+  KISSAT_assert (forced != INVALID_LIT);
+  reference dst_ref = kissat_reference_clause (solver, dst);
+  const unsigned forced_idx = IDX (forced);
+  struct assigned *a = assigned + forced_idx;
+  KISSAT_assert (!a->binary);
+  if (a->reason != dst_ref) {
+    LOG ("reason reference %u of %s updated to %u", a->reason,
+         LOGLIT (forced), dst_ref);
+    a->reason = dst_ref;
+  }
+  dst->reason = false;
+}
+
+static unsigned get_forced (const value *values, clause *dst) {
+  KISSAT_assert (dst->reason);
+  unsigned forced = INVALID_LIT;
+  for (all_literals_in_clause (lit, dst)) {
+    const value value = values[lit];
+    if (value <= 0)
+      continue;
+    forced = lit;
+    break;
+  }
+  KISSAT_assert (forced != INVALID_LIT);
+  return forced;
+}
+
+static void get_forced_and_update_large_reason (kissat *solver,
+                                                assigned *assigned,
+                                                const value *const values,
+                                                clause *dst) {
+  const unsigned forced = get_forced (values, dst);
+  update_large_reason (solver, assigned, forced, dst);
+}
+
+static void update_first_reducible (kissat *solver, const clause *end,
+                                    clause *first_reducible) {
+  if (first_reducible >= end) {
+    LOG ("first reducible after end of arena");
+    solver->first_reducible = INVALID_REF;
+  } else if (first_reducible) {
+    LOGCLS (first_reducible, "updating first reducible clause to");
+    solver->first_reducible =
+        kissat_reference_clause (solver, first_reducible);
+  } else {
+    LOG ("first reducible clause becomes invalid");
+    solver->first_reducible = INVALID_REF;
+  }
+}
+
+static void update_last_irredundant (kissat *solver, const clause *end,
+                                     clause *last_irredundant) {
+  if (!last_irredundant) {
+    LOG ("no more large irredundant clauses left");
+    solver->last_irredundant = INVALID_REF;
+  } else if (end <= last_irredundant) {
+    LOG ("last irredundant clause after end of arena");
+    solver->last_irredundant = INVALID_REF;
+  } else {
+    LOGCLS (last_irredundant, "updating last irredundant clause to");
+    reference ref = kissat_reference_clause (solver, last_irredundant);
+    solver->last_irredundant = ref;
+  }
+}
+
+void kissat_update_first_reducible (kissat *solver, clause *reducible) {
+  KISSAT_assert (reducible);
+  KISSAT_assert (!reducible->garbage);
+  KISSAT_assert (reducible->redundant);
+  if (solver->first_reducible != INVALID_REF) {
+    reference ref = kissat_reference_clause (solver, reducible);
+    if (ref >= solver->first_reducible) {
+      LOG ("no need to update larger first reducible");
+      return;
+    }
+  }
+  clause *end = (clause *) END_STACK (solver->arena);
+  update_first_reducible (solver, end, reducible);
+}
+
+void kissat_update_last_irredundant (kissat *solver, clause *irredundant) {
+  KISSAT_assert (irredundant);
+  KISSAT_assert (!irredundant->garbage);
+  KISSAT_assert (!irredundant->redundant);
+  if (solver->last_irredundant != INVALID_REF) {
+    reference ref = kissat_reference_clause (solver, irredundant);
+    if (ref <= solver->last_irredundant) {
+      LOG ("no need to update smaller last irredundant");
+      return;
+    }
+  }
+  clause *end = (clause *) END_STACK (solver->arena);
+  update_last_irredundant (solver, end, irredundant);
+}
+
+static void move_redundant_clauses_to_the_end (kissat *solver,
+                                               reference ref) {
+  INC (moved);
+  KISSAT_assert (ref != INVALID_REF);
+#ifndef KISSAT_NDEBUG
+  const size_t size = SIZE_STACK (solver->arena);
+  KISSAT_assert ((size_t) ref <= size);
+#endif
+  clause *begin = (clause *) (BEGIN_STACK (solver->arena) + ref);
+  clause *end = (clause *) END_STACK (solver->arena);
+  size_t bytes_redundant = (char *) end - (char *) begin;
+  kissat_phase (solver, "move", GET (moved),
+                "moving redundant clauses of %s to the end",
+                FORMAT_BYTES (bytes_redundant));
+  kissat_mark_reason_clauses (solver, ref);
+  clause *redundant = (clause *) kissat_malloc (solver, bytes_redundant);
+  clause *p = begin, *q = begin, *r = redundant;
+
+  const value *const values = solver->values;
+  assigned *assigned = solver->assigned;
+
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+
+  while (p != end) {
+    KISSAT_assert (!p->shrunken);
+    size_t bytes = kissat_bytes_of_clause (p->size);
+    if (p->redundant) {
+      memcpy (r, p, bytes);
+      r = (clause *) (bytes + (char *) r);
+    } else {
+      LOGCLS (p, "old DST");
+      memmove (q, p, bytes);
+      LOGCLS (q, "new DST");
+      last_irredundant = q;
+      if (q->reason)
+        get_forced_and_update_large_reason (solver, assigned, values, q);
+      q = (clause *) (bytes + (char *) q);
+    }
+    p = (clause *) (bytes + (char *) p);
+  }
+  r = redundant;
+  clause *first_reducible = 0;
+  while (q != end) {
+    size_t bytes = kissat_bytes_of_clause (r->size);
+    memcpy (q, r, bytes);
+    LOGCLS (q, "new DST");
+    if (q->reason)
+      get_forced_and_update_large_reason (solver, assigned, values, q);
+    KISSAT_assert (q->redundant);
+    if (!first_reducible)
+      first_reducible = q;
+    r = (clause *) (bytes + (char *) r);
+    q = (clause *) (bytes + (char *) q);
+  }
+  KISSAT_assert ((char *) r <= (char *) redundant + bytes_redundant);
+  kissat_free (solver, redundant, bytes_redundant);
+
+  KISSAT_assert (!first_reducible || first_reducible < q);
+
+  update_first_reducible (solver, q, first_reducible);
+  update_last_irredundant (solver, q, last_irredundant);
+  kissat_reset_last_learned (solver);
+}
+
+static reference sparse_sweep_garbage_clauses (kissat *solver, bool compact,
+                                               reference start) {
+  KISSAT_assert (solver->watching);
+  LOG ("sparse garbage collection starting at clause[%" REFERENCE_FORMAT
+       "]",
+       start);
+#ifdef CHECKING_OR_PROVING
+  const bool checking_or_proving = kissat_checking_or_proving (solver);
+#endif
+  KISSAT_assert (EMPTY_STACK (solver->added));
+  KISSAT_assert (EMPTY_STACK (solver->removed));
+
+  const value *const values = solver->values;
+  assigned *assigned = solver->assigned;
+
+#ifndef KISSAT_QUIET
+  size_t flushed_garbage_clauses = 0;
+  size_t flushed_satisfied_clauses = 0;
+#endif
+  size_t flushed = 0;
+
+  clause *begin = (clause *) BEGIN_STACK (solver->arena);
+  const clause *const end = (clause *) END_STACK (solver->arena);
+
+  clause *first, *src, *dst;
+  if (start)
+    first = kissat_dereference_clause (solver, start);
+  else
+    first = begin;
+  src = dst = first;
+
+  clause *first_redundant = 0;
+  clause *first_reducible = 0;
+  clause *last_irredundant;
+
+  if (start)
+    last_irredundant = kissat_last_irredundant_clause (solver);
+  else
+    last_irredundant = 0;
+#ifdef LOGGING
+  size_t redundant_bytes = 0;
+#endif
+  for (clause *next; src != end; src = next) {
+    if (src->garbage) {
+      next = kissat_delete_clause (solver, src);
+#ifndef KISSAT_QUIET
+      flushed_garbage_clauses++;
+#endif
+      if (last_irredundant == src) {
+        if (first == begin)
+          last_irredundant = 0;
+        else
+          last_irredundant = first;
+      }
+      continue;
+    }
+
+    KISSAT_assert (src->size > 1);
+    LOGCLS (src, "SRC");
+    next = kissat_next_clause (src);
+#if !defined(KISSAT_NDEBUG) || defined(CHECKING_OR_PROVING)
+    const unsigned old_size = src->size;
+#endif
+    KISSAT_assert (SIZE_OF_CLAUSE_HEADER == sizeof (unsigned));
+    *(unsigned *) dst = *(unsigned *) src;
+
+    unsigned *q = dst->lits;
+
+    unsigned mfirst = INVALID_LIT;
+    unsigned msecond = INVALID_LIT;
+    unsigned forced = INVALID_LIT;
+    unsigned other = INVALID_LIT;
+    unsigned non_false = 0;
+
+    bool satisfied = false;
+
+    for (all_literals_in_clause (lit, src)) {
+#ifdef CHECKING_OR_PROVING
+      if (checking_or_proving)
+        PUSH_STACK (solver->removed, lit);
+#endif
+      if (satisfied)
+        continue;
+
+      const value tmp = values[lit];
+      const unsigned idx = IDX (lit);
+      const unsigned level = tmp ? assigned[idx].level : INVALID_LEVEL;
+
+      if (tmp < 0 && !level)
+        flushed++;
+      else if (tmp > 0 && !level) {
+        KISSAT_assert (!satisfied);
+        KISSAT_assert (!dst->reason);
+        LOG ("SRC satisfied by %s", LOGLIT (lit));
+        satisfied = true;
+      } else {
+        const unsigned mlit = kissat_map_literal (solver, lit, compact);
+
+        if (tmp > 0) {
+          KISSAT_assert (level);
+          forced = non_false++ ? INVALID_LIT : lit;
+        } else if (tmp < 0)
+          other = lit;
+
+        if (mfirst == INVALID_LIT)
+          mfirst = mlit;
+        else if (msecond == INVALID_LIT)
+          msecond = mlit;
+
+        *q++ = mlit;
+
+#ifdef CHECKING_OR_PROVING
+        if (checking_or_proving)
+          PUSH_STACK (solver->added, lit);
+#endif
+      }
+    }
+
+    if (satisfied) {
+      if (dst->redundant)
+        DEC (clauses_redundant);
+      else
+        DEC (clauses_irredundant);
+#ifndef KISSAT_QUIET
+      flushed_satisfied_clauses++;
+#endif
+#ifdef CHECKING_OR_PROVING
+      if (checking_or_proving) {
+        REMOVE_CHECKER_STACK (solver->removed);
+        DELETE_STACK_FROM_PROOF (solver->removed);
+        CLEAR_STACK (solver->added);
+        CLEAR_STACK (solver->removed);
+      }
+#endif
+      if (last_irredundant == src) {
+        if (first == begin)
+          last_irredundant = 0;
+        else
+          last_irredundant = first;
+      }
+      continue;
+    }
+
+    const unsigned new_size = q - dst->lits;
+    KISSAT_assert (new_size <= old_size);
+    KISSAT_assert (1 < new_size);
+
+    if (new_size == 2) {
+      KISSAT_assert (mfirst != INVALID_LIT);
+      KISSAT_assert (msecond != INVALID_LIT);
+
+      statistics *statistics = &solver->statistics_;
+      KISSAT_assert (statistics->clauses_binary < UINT64_MAX);
+      statistics->clauses_binary++;
+      bool redundant = dst->redundant;
+      if (redundant) {
+        KISSAT_assert (statistics->clauses_redundant > 0);
+        statistics->clauses_redundant--;
+        redundant = false;
+      } else {
+        KISSAT_assert (statistics->clauses_irredundant > 0);
+        statistics->clauses_irredundant--;
+      }
+      LOGBINARY (mfirst, msecond, "DST");
+      kissat_watch_binary (solver, mfirst, msecond);
+
+      if (dst->reason) {
+        KISSAT_assert (non_false == 1);
+        KISSAT_assert (other != INVALID_LIT);
+        KISSAT_assert (forced != INVALID_LIT);
+
+        const unsigned forced_idx = IDX (forced);
+        struct assigned *a = assigned + forced_idx;
+        KISSAT_assert (!a->binary);
+
+        LOGBINARY (mfirst, msecond,
+                   "reason clause[%u] of %s updated to binary reason",
+                   a->reason, LOGLIT (forced));
+
+        a->binary = true;
+        a->reason = other;
+      }
+
+      if (!redundant && last_irredundant == src) {
+        if (first == begin)
+          last_irredundant = 0;
+        else
+          last_irredundant = first;
+      }
+    } else {
+      KISSAT_assert (2 < new_size);
+
+      dst->size = new_size;
+      dst->shrunken = false;
+      dst->searched = 2;
+
+      LOGCLS (dst, "DST");
+      if (dst->reason)
+        update_large_reason (solver, assigned, forced, dst);
+
+      clause *next_dst = kissat_next_clause (dst);
+
+      if (dst->redundant) {
+        if (!first_reducible)
+          first_reducible = dst;
+#ifdef LOGGING
+        redundant_bytes += (char *) next_dst - (char *) dst;
+#endif
+        if (!first_redundant)
+          first_redundant = dst;
+      } else
+        last_irredundant = dst;
+
+      dst = next_dst;
+    }
+
+#ifdef CHECKING_OR_PROVING
+    if (!checking_or_proving)
+      continue;
+
+    if (new_size != old_size) {
+      KISSAT_assert (1 < new_size);
+      KISSAT_assert (new_size < old_size);
+
+      CHECK_AND_ADD_STACK (solver->added);
+      ADD_STACK_TO_PROOF (solver->added);
+
+      REMOVE_CHECKER_STACK (solver->removed);
+      DELETE_STACK_FROM_PROOF (solver->removed);
+    }
+    CLEAR_STACK (solver->added);
+    CLEAR_STACK (solver->removed);
+#endif
+  }
+
+  update_first_reducible (solver, dst, first_reducible);
+  update_last_irredundant (solver, dst, last_irredundant);
+  kissat_reset_last_learned (solver);
+
+  if (first_redundant)
+    LOGCLS (first_redundant, "determined first redundant clause as");
+
+#if !defined(KISSAT_QUIET) || defined(METRICS)
+  size_t bytes = (char *) END_STACK (solver->arena) - (char *) dst;
+#endif
+#ifndef KISSAT_QUIET
+  if (flushed)
+    kissat_phase (solver, "collect", GET (garbage_collections),
+                  "flushed %zu falsified literals in large clauses",
+                  flushed);
+  size_t flushed_clauses =
+      flushed_satisfied_clauses + flushed_garbage_clauses;
+  if (flushed_satisfied_clauses)
+    kissat_phase (
+        solver, "collect", GET (garbage_collections),
+        "flushed %zu satisfied large clauses %.0f%%",
+        flushed_satisfied_clauses,
+        kissat_percent (flushed_satisfied_clauses, flushed_clauses));
+  if (flushed_garbage_clauses)
+    kissat_phase (
+        solver, "collect", GET (garbage_collections),
+        "flushed %zu large garbage clauses %.0f%%", flushed_garbage_clauses,
+        kissat_percent (flushed_garbage_clauses, flushed_clauses));
+  kissat_phase (solver, "collect", GET (garbage_collections),
+                "collected %s in total", FORMAT_BYTES (bytes));
+#endif
+  ADD (flushed, flushed);
+#ifdef METRICS
+  ADD (allocated_collected, bytes);
+#endif
+
+  reference res = INVALID_REF;
+
+  if (first_redundant && last_irredundant &&
+      first_redundant < last_irredundant) {
+#ifdef LOGGING
+    size_t move_bytes = (char *) dst - (char *) first_redundant;
+    LOG ("redundant bytes %s (%.0f%%) out of %s moving bytes",
+         FORMAT_BYTES (redundant_bytes),
+         kissat_percent (redundant_bytes, move_bytes),
+         FORMAT_BYTES (move_bytes));
+#endif
+    KISSAT_assert (first_redundant < dst);
+    res = kissat_reference_clause (solver, first_redundant);
+    KISSAT_assert (res != INVALID_REF);
+  }
+
+  SET_END_OF_STACK (solver->arena, (ward *) dst);
+  kissat_shrink_arena (solver);
+
+#ifdef METRICS
+  if (solver->statistics_.arena_garbage)
+    kissat_very_verbose (solver, "still %s garbage left in arena",
+                         FORMAT_BYTES (solver->statistics_.arena_garbage));
+  else
+    kissat_very_verbose (solver, "all garbage clauses in arena collected");
+#endif
+
+  return res;
+}
+
+static void rewatch_clauses (kissat *solver, reference start) {
+  LOG ("rewatching clause[%" REFERENCE_FORMAT "] and following clauses",
+       start);
+  KISSAT_assert (solver->watching);
+
+  const value *const values = solver->values;
+  const assigned *const assigned = solver->assigned;
+  watches *watches = solver->watches;
+  ward *const arena = BEGIN_STACK (solver->arena);
+
+  clause *end = (clause *) END_STACK (solver->arena);
+  clause *c = (clause *) (BEGIN_STACK (solver->arena) + start);
+  KISSAT_assert (c <= end);
+
+  for (clause *next; c != end; c = next) {
+    next = kissat_next_clause (c);
+
+    unsigned *lits = c->lits;
+    kissat_sort_literals (solver, values, assigned, c->size, lits);
+    c->searched = 2;
+
+    const reference ref = (ward *) c - arena;
+    const unsigned l0 = lits[0];
+    const unsigned l1 = lits[1];
+
+    kissat_push_blocking_watch (solver, watches + l0, l1, ref);
+    kissat_push_blocking_watch (solver, watches + l1, l0, ref);
+  }
+}
+
+void kissat_sparse_collect (kissat *solver, bool compact, reference start) {
+  KISSAT_assert (solver->watching);
+  START (collect);
+  INC (garbage_collections);
+  INC (sparse_gcs);
+  REPORT (1, 'G');
+  unsigned vars, mfixed;
+  if (compact)
+    vars = kissat_compact_literals (solver, &mfixed);
+  else {
+    vars = solver->vars;
+    mfixed = INVALID_LIT;
+  }
+  flush_all_watched_clauses (solver, compact, start);
+  reference move = sparse_sweep_garbage_clauses (solver, compact, start);
+  if (compact)
+    kissat_finalize_compacting (solver, vars, mfixed);
+  if (move != INVALID_REF)
+    move_redundant_clauses_to_the_end (solver, move);
+  rewatch_clauses (solver, start);
+  REPORT (1, 'C');
+  kissat_check_statistics (solver);
+  STOP (collect);
+}
+
+bool kissat_compacting (kissat *solver) {
+  if (!GET_OPTION (compact))
+    return false;
+  unsigned inactive = solver->vars - solver->active;
+  unsigned limit = GET_OPTION (compactlim) / 1e2 * solver->vars;
+  bool compact = (inactive > limit);
+  LOG ("%u inactive variables %.0f%% <= limit %u %.0f%%", inactive,
+       kissat_percent (inactive, solver->vars), limit,
+       kissat_percent (limit, solver->vars));
+  return compact;
+}
+
+void kissat_initial_sparse_collect (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (kissat_trail_flushed (solver));
+  if (solver->statistics_.units) {
+    bool compact = GET_OPTION (compact);
+    kissat_sparse_collect (solver, compact, 0);
+  }
+  REPORT (0, '.');
+}
+
+static void dense_sweep_garbage_clauses (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->watching);
+
+  LOG ("dense garbage collection");
+
+#ifndef KISSAT_QUIET
+  size_t flushed_garbage_clauses = 0;
+#endif
+  clause *first_reducible = 0;
+  clause *last_irredundant = 0;
+
+  clause *begin = (clause *) BEGIN_STACK (solver->arena);
+  const clause *const end = (clause *) END_STACK (solver->arena);
+
+  clause *src = begin;
+  clause *dst = src;
+
+  for (clause *next; src != end; src = next) {
+    if (src->garbage) {
+      next = kissat_delete_clause (solver, src);
+#ifndef KISSAT_QUIET
+      flushed_garbage_clauses++;
+#endif
+      continue;
+    }
+    KISSAT_assert (src->size > 1);
+    LOGCLS (src, "SRC");
+    next = kissat_next_clause (src);
+    KISSAT_assert (SIZE_OF_CLAUSE_HEADER == sizeof (unsigned));
+    *(unsigned *) dst = *(unsigned *) src;
+    dst->searched = src->searched;
+    dst->size = src->size;
+    dst->shrunken = false;
+    memmove (dst->lits, src->lits, src->size * sizeof (unsigned));
+    LOGCLS (dst, "DST");
+    if (!dst->redundant)
+      last_irredundant = dst;
+    else if (!first_reducible)
+      first_reducible = dst;
+    dst = kissat_next_clause (dst);
+  }
+
+  update_first_reducible (solver, dst, first_reducible);
+  update_last_irredundant (solver, dst, last_irredundant);
+  kissat_reset_last_learned (solver);
+
+#if !defined(KISSAT_QUIET) || defined(METRICS)
+  size_t bytes = (char *) END_STACK (solver->arena) - (char *) dst;
+#endif
+  kissat_phase (solver, "collect", GET (garbage_collections),
+                "flushed %zu large garbage clauses",
+                flushed_garbage_clauses);
+  kissat_phase (solver, "collect", GET (garbage_collections),
+                "collected %s in total", FORMAT_BYTES (bytes));
+#ifdef METRICS
+  ADD (allocated_collected, bytes);
+#endif
+
+  SET_END_OF_STACK (solver->arena, (ward *) dst);
+  kissat_shrink_arena (solver);
+
+#ifdef METRICS
+  if (solver->statistics_.arena_garbage)
+    kissat_very_verbose (solver, "still %s garbage left in arena",
+                         FORMAT_BYTES (solver->statistics_.arena_garbage));
+  else
+    kissat_very_verbose (solver, "all garbage clauses in arena collected");
+#endif
+}
+
+void kissat_dense_collect (kissat *solver) {
+  KISSAT_assert (!solver->watching);
+  KISSAT_assert (!solver->level);
+  START (collect);
+  INC (garbage_collections);
+  INC (dense_garbage_collections);
+  REPORT (1, 'G');
+  dense_sweep_garbage_clauses (solver);
+  REPORT (1, 'C');
+  STOP (collect);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/collect.h b/src/sat/kissat/collect.h
new file mode 100644
index 000000000..f6222ded4
--- /dev/null
+++ b/src/sat/kissat/collect.h
@@ -0,0 +1,38 @@
+#ifndef _collect_h_INCLUDED
+#define _collect_h_INCLUDED
+
+#include "internal.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+bool kissat_compacting (kissat *);
+void kissat_dense_collect (kissat *);
+void kissat_sparse_collect (kissat *, bool compact, reference start);
+void kissat_initial_sparse_collect (kissat *);
+
+static inline void kissat_defrag_watches (kissat *solver) {
+  kissat_defrag_vectors (solver, LITS, solver->watches);
+}
+
+static inline void kissat_defrag_watches_if_needed (kissat *solver) {
+  const size_t size = SIZE_STACK (solver->vectors.stack);
+  const size_t size_limit = GET_OPTION (defragsize);
+  if (size <= size_limit)
+    return;
+
+  const size_t usable = solver->vectors.usable;
+  const size_t usable_limit = (size * GET_OPTION (defraglim)) / 100;
+  if (usable <= usable_limit)
+    return;
+
+  INC (vectors_defrags_needed);
+  kissat_defrag_watches (solver);
+}
+
+void kissat_update_last_irredundant (kissat *, clause *last_irredundant);
+void kissat_update_first_reducible (kissat *, clause *first_reducible);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/colors.c b/src/sat/kissat/colors.c
new file mode 100644
index 000000000..f45260b29
--- /dev/null
+++ b/src/sat/kissat/colors.c
@@ -0,0 +1,27 @@
+#include "colors.h"
+
+#ifdef WIN32
+#define isatty _isatty
+#else
+#include <unistd.h>
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+int kissat_is_terminal[3] = {0, -1, -1};
+
+int kissat_initialize_terminal (int fd) {
+  KISSAT_assert (fd == 1 || fd == 2);
+  KISSAT_assert (kissat_is_terminal[fd] < 0);
+  return kissat_is_terminal[fd] = isatty (fd);
+}
+
+void kissat_force_colors (void) {
+  kissat_is_terminal[1] = kissat_is_terminal[2] = 1;
+}
+
+void kissat_force_no_colors (void) {
+  kissat_is_terminal[1] = kissat_is_terminal[2] = 0;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/colors.h b/src/sat/kissat/colors.h
new file mode 100644
index 000000000..0d79c79e8
--- /dev/null
+++ b/src/sat/kissat/colors.h
@@ -0,0 +1,73 @@
+#ifndef _colors_h_INCLUDED
+#define _colors_h_INCLUDED
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#include "keatures.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define BLUE "\033[34m"
+#define BOLD "\033[1m"
+#define CYAN "\033[36m"
+#define GREEN "\033[32m"
+#define MAGENTA "\033[35m"
+#define NORMAL "\033[0m"
+#define RED "\033[31m"
+#define WHITE "\037[34m"
+#define YELLOW "\033[33m"
+
+#define LIGHT_GRAY "\033[1;37m"
+#define DARK_GRAY "\033[0;37m"
+
+#ifdef KISSAT_HAS_FILENO
+#define KISSAT_assert_if_has_fileno KISSAT_assert
+#else
+#define KISSAT_assert_if_has_fileno(...) \
+  do { \
+  } while (0)
+#endif
+
+#define TERMINAL(F, I) \
+  KISSAT_assert_if_has_fileno (fileno (F) == \
+                        I); /* 'fileno' only in POSIX not C99 */ \
+  KISSAT_assert ((I == 1 && F == stdout) || (I == 2 && F == stderr)); \
+  bool connected_to_terminal = kissat_connected_to_terminal (I); \
+  FILE *terminal_file = F
+
+#define COLOR(CODE) \
+  do { \
+    if (!connected_to_terminal) \
+      break; \
+    fputs (CODE, terminal_file); \
+  } while (0)
+
+extern int kissat_is_terminal[3];
+
+int kissat_initialize_terminal (int fd);
+void kissat_force_colors (void);
+void kissat_force_no_colors (void);
+
+static inline bool kissat_connected_to_terminal (int fd) {
+  KISSAT_assert (fd == 1 || fd == 2);
+  int res = kissat_is_terminal[fd];
+  if (res < 0)
+    res = kissat_initialize_terminal (fd);
+  KISSAT_assert (res == 0 || res == 1);
+  return res;
+}
+
+static inline const char *kissat_bold_green_color_code (int fd) {
+  return kissat_connected_to_terminal (fd) ? BOLD GREEN : "";
+}
+
+static inline const char *kissat_normal_color_code (int fd) {
+  return kissat_connected_to_terminal (fd) ? NORMAL : "";
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/compact.c b/src/sat/kissat/compact.c
new file mode 100644
index 000000000..cb89cb9a9
--- /dev/null
+++ b/src/sat/kissat/compact.c
@@ -0,0 +1,380 @@
+#include "compact.h"
+#include "inline.h"
+#include "inlineheap.h"
+#include "print.h"
+#include "resize.h"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void reimport_literal (kissat *solver, unsigned eidx,
+                              unsigned mlit) {
+  import *import = &PEEK_STACK (solver->import, eidx);
+  KISSAT_assert (import->imported);
+  KISSAT_assert (!import->eliminated);
+  LOG ("reimporting external variable %u as internal literal %u (was %u)",
+       eidx, mlit, import->lit);
+  import->lit = mlit;
+}
+
+unsigned kissat_compact_literals (kissat *solver, unsigned *mfixed_ptr) {
+  INC (compacted);
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG)
+  const unsigned active = solver->active;
+#ifndef KISSAT_QUIET
+  const unsigned inactive = solver->vars - active;
+  kissat_phase (solver, "compact", GET (compacted),
+                "compacting garbage collection "
+                "(%u inactive variables %.2f%%)",
+                inactive, kissat_percent (inactive, solver->vars));
+#endif
+#endif
+#ifdef LOGGING
+  KISSAT_assert (!solver->compacting);
+  solver->compacting = true;
+#endif
+  unsigned mfixed = INVALID_LIT;
+  unsigned vars = 0;
+  for (all_variables (iidx)) {
+    const flags *const flags = FLAGS (iidx);
+    if (flags->eliminated)
+      continue;
+    const unsigned ilit = LIT (iidx);
+    unsigned mlit;
+    if (flags->fixed) {
+      const value value = kissat_fixed (solver, ilit);
+      KISSAT_assert (value);
+      if (mfixed == INVALID_LIT) {
+        mlit = mfixed = LIT (vars);
+        LOG2 ("first fixed %u mapped to %u assigned to %d", ilit, mfixed,
+              value);
+        if (value < 0)
+          mfixed = NOT (mfixed);
+        LOG2 ("all other fixed mapped to %u", mfixed);
+        vars++;
+      } else if (value < 0) {
+        mlit = NOT (mfixed);
+        LOG2 ("negatively fixed %u mapped to %u", ilit, mlit);
+      } else {
+        mlit = mfixed;
+        LOG2 ("positively fixed %u mapped to %u", ilit, mlit);
+      }
+    } else if (flags->active) {
+      KISSAT_assert (flags->active);
+      mlit = LIT (vars);
+      LOG2 ("remapping %u to %u", ilit, mlit);
+      vars++;
+    } else {
+      const int elit = PEEK_STACK (solver->export_, iidx);
+      if (elit) {
+        const unsigned eidx = ABS (elit);
+        import *import = &PEEK_STACK (solver->import, eidx);
+        KISSAT_assert (import->imported);
+        KISSAT_assert (!import->eliminated);
+        import->imported = false;
+        LOG2 ("external variable %d not imported anymore", eidx);
+        POKE_STACK (solver->export_, iidx, 0);
+      } else
+        LOG2 ("skipping inactive %u", ilit);
+      continue;
+    }
+    KISSAT_assert (mlit <= ilit);
+    KISSAT_assert (mlit != NOT (ilit));
+    if (mlit == ilit)
+      continue;
+    const int elit = PEEK_STACK (solver->export_, iidx);
+    const unsigned eidx = ABS (elit);
+    if (elit < 0)
+      mlit = NOT (mlit);
+    reimport_literal (solver, eidx, mlit);
+  }
+  *mfixed_ptr = mfixed;
+  LOG ("compacting to %u variables %.2f%% from %u", vars,
+       kissat_percent (vars, solver->vars), solver->vars);
+  KISSAT_assert (vars == active || vars == active + 1);
+  return vars;
+}
+
+static void compact_literal (kissat *solver, unsigned dst_lit,
+                             unsigned src_lit) {
+  KISSAT_assert (dst_lit < src_lit);
+  KISSAT_assert (dst_lit != NOT (src_lit));
+  const unsigned dst_idx = IDX (dst_lit);
+  const unsigned src_idx = IDX (src_lit);
+  KISSAT_assert (dst_idx != src_idx);
+  LOG ("mapping old internal literal %u to %u", src_lit, dst_lit);
+  solver->assigned[dst_idx] = solver->assigned[src_idx];
+  solver->flags[dst_idx] = solver->flags[src_idx];
+
+  solver->phases.best[dst_idx] = solver->phases.best[src_idx];
+  solver->phases.saved[dst_idx] = solver->phases.saved[src_idx];
+  solver->phases.target[dst_idx] = solver->phases.target[src_idx];
+
+  const unsigned not_src_lit = NOT (src_lit);
+  const unsigned not_dst_lit = NOT (dst_lit);
+  solver->values[dst_lit] = solver->values[src_lit];
+  solver->values[not_dst_lit] = solver->values[not_src_lit];
+}
+
+static unsigned map_idx (kissat *solver, unsigned iidx) {
+  int elit = PEEK_STACK (solver->export_, iidx);
+  if (!elit)
+    return INVALID_IDX;
+  KISSAT_assert (elit);
+  const unsigned eidx = ABS (elit);
+  KISSAT_assert (eidx);
+  import *import = &PEEK_STACK (solver->import, eidx);
+  KISSAT_assert (import->imported);
+  if (import->eliminated)
+    return INVALID_IDX;
+  const unsigned mlit = import->lit;
+  const unsigned midx = IDX (mlit);
+  KISSAT_assert (midx <= iidx);
+  return midx;
+}
+
+static void compact_queue (kissat *solver) {
+  LOG ("compacting queue");
+  links *links = solver->links, *l;
+  unsigned *p = &solver->queue.first, prev = DISCONNECT;
+  solver->queue.stamp = 0;
+  for (unsigned idx; !DISCONNECTED (idx = *p); p = &l->next) {
+    const unsigned midx = map_idx (solver, idx);
+    KISSAT_assert (midx != INVALID_IDX);
+    l = links + idx;
+    l->prev = prev;
+    l->stamp = ++solver->queue.stamp;
+    if (idx == solver->queue.search.idx) {
+      solver->queue.search.idx = midx;
+      solver->queue.search.stamp = l->stamp;
+    }
+    *p = prev = midx;
+  }
+  solver->queue.last = prev;
+  *p = DISCONNECT;
+  for (all_variables (idx)) {
+    const unsigned midx = map_idx (solver, idx);
+    if (midx == INVALID_IDX)
+      continue;
+    links[midx] = links[idx];
+  }
+}
+
+static void compact_stack (kissat *solver, unsigneds *stack) {
+  unsigned *q = BEGIN_STACK (*stack);
+  const unsigned *const end = END_STACK (*stack);
+  for (const unsigned *p = q; p != end; p++) {
+    const unsigned idx = *p;
+    const unsigned midx = map_idx (solver, idx);
+    if (midx == INVALID_IDX)
+      continue;
+    *q++ = midx;
+  }
+  SET_END_OF_STACK (*stack, q);
+  SHRINK_STACK (*stack);
+}
+
+static void compact_scores (kissat *solver, heap *old_scores,
+                            unsigned vars) {
+  LOG ("compacting scores");
+
+  heap new_scores;
+  memset (&new_scores, 0, sizeof new_scores);
+  kissat_resize_heap (solver, &new_scores, vars);
+
+  if (old_scores->tainted) {
+    LOG ("copying scores of tainted old scores heap");
+    for (all_variables (idx)) {
+      const unsigned midx = map_idx (solver, idx);
+      if (midx == INVALID_IDX)
+        continue;
+      const double score = kissat_get_heap_score (old_scores, idx);
+      kissat_update_heap (solver, &new_scores, midx, score);
+    }
+  } else
+    LOG ("no need to copy scores of old untainted scores heap");
+
+  LOG ("now pushing mapped literals onto new heap");
+  for (all_stack (unsigned, idx, old_scores->stack)) {
+    const unsigned midx = map_idx (solver, idx);
+    if (midx == INVALID_IDX)
+      continue;
+    kissat_push_heap (solver, &new_scores, midx);
+  }
+
+  kissat_release_heap (solver, old_scores);
+  *old_scores = new_scores;
+}
+
+static void compact_trail (kissat *solver) {
+  LOG ("compacting trail");
+  const size_t size = SIZE_ARRAY (solver->trail);
+  for (size_t i = 0; i < size; i++) {
+    const unsigned ilit = PEEK_ARRAY (solver->trail, i);
+    const unsigned mlit = kissat_map_literal (solver, ilit, true);
+    KISSAT_assert (mlit != INVALID_LIT);
+    POKE_ARRAY (solver->trail, i, mlit);
+    const unsigned idx = IDX (ilit);
+    assigned *a = solver->assigned + idx;
+    if (!a->binary)
+      continue;
+    const unsigned other = a->reason;
+    KISSAT_assert (VALID_INTERNAL_LITERAL (other));
+    const unsigned mother = kissat_map_literal (solver, other, true);
+    KISSAT_assert (mother != INVALID_LIT);
+    a->reason = mother;
+  }
+}
+
+static void compact_frames (kissat *solver) {
+  LOG ("compacting frames");
+  const size_t size = SIZE_STACK (solver->frames);
+  for (size_t level = 1; level < size; level++) {
+    frame *frame = &FRAME (level);
+    const unsigned ilit = frame->decision;
+    const unsigned mlit = kissat_map_literal (solver, ilit, true);
+    KISSAT_assert (mlit != INVALID_LIT);
+    frame->decision = mlit;
+  }
+}
+
+static void compact_export (kissat *solver, unsigned vars) {
+  LOG ("compacting export");
+  const size_t size = SIZE_STACK (solver->export_);
+  KISSAT_assert (size <= UINT_MAX);
+  KISSAT_assert (size == solver->vars);
+  for (unsigned iidx = 0; iidx < size; iidx++) {
+    const unsigned elit = PEEK_STACK (solver->export_, iidx);
+    if (!elit)
+      continue;
+    const unsigned midx = map_idx (solver, iidx);
+    if (midx == INVALID_IDX)
+      continue;
+    POKE_STACK (solver->export_, midx, elit);
+  }
+  RESIZE_STACK (solver->export_, vars);
+  SHRINK_STACK (solver->export_);
+#ifndef KISSAT_NDEBUG
+  KISSAT_assert (SIZE_STACK (solver->export_) == vars);
+  for (unsigned iidx = 0; iidx < vars; iidx++) {
+    const int elit = PEEK_STACK (solver->export_, iidx);
+    KISSAT_assert (VALID_EXTERNAL_LITERAL (elit));
+    const unsigned eidx = ABS (elit);
+    const import *const import = &PEEK_STACK (solver->import, eidx);
+    KISSAT_assert (import->imported);
+    if (import->eliminated)
+      continue;
+    unsigned mlit = import->lit;
+    if (elit < 0)
+      mlit = NOT (mlit);
+    const unsigned ilit = LIT (iidx);
+    KISSAT_assert (mlit == ilit);
+  }
+#endif
+}
+
+static void compact_units (kissat *solver, unsigned mfixed) {
+  LOG ("compacting units (first fixed %u)", mfixed);
+  KISSAT_assert (kissat_fixed (solver, mfixed) > 0);
+  for (all_stack (int, elit, solver->units)) {
+    const unsigned eidx = ABS (elit);
+    const unsigned mlit = elit < 0 ? NOT (mfixed) : mfixed;
+    const import *const import = &PEEK_STACK (solver->import, eidx);
+    KISSAT_assert (import->imported);
+    KISSAT_assert (!import->eliminated);
+    const unsigned ilit = import->lit;
+    if (mlit != ilit)
+      reimport_literal (solver, eidx, mlit);
+  }
+}
+
+static void compact_best_and_target_values (kissat *solver, unsigned vars) {
+  const value *const best = solver->phases.best;
+  const value *const target = solver->phases.target;
+  const flags *const flags = solver->flags;
+
+  unsigned best_assigned = 0;
+  unsigned target_assigned = 0;
+
+  for (unsigned idx = 0; idx < vars; idx++) {
+    if (!flags[idx].active)
+      continue;
+    if (target[idx])
+      target_assigned++;
+    if (best[idx])
+      best_assigned++;
+  }
+
+  if (solver->target_assigned != target_assigned) {
+    LOG ("compacting target assigned from %u to %u",
+         solver->target_assigned, target_assigned);
+    solver->target_assigned = target_assigned;
+  }
+
+  if (solver->best_assigned != best_assigned) {
+    LOG ("compacting best assigned from %u to %u", solver->best_assigned,
+         best_assigned);
+    solver->best_assigned = best_assigned;
+  }
+}
+
+void kissat_finalize_compacting (kissat *solver, unsigned vars,
+                                 unsigned mfixed) {
+  LOG ("finalizing compacting");
+  KISSAT_assert (vars <= solver->vars);
+#ifdef LOGGING
+  KISSAT_assert (solver->compacting);
+#endif
+  if (vars == solver->vars) {
+#ifdef LOGGING
+    solver->compacting = false;
+    LOG ("number of variables does not change");
+#endif
+    return;
+  }
+
+  unsigned reduced = solver->vars - vars;
+  LOG ("compacted number of variables from %u to %u", solver->vars, vars);
+
+  bool first = true;
+  for (all_variables (iidx)) {
+    flags *flags = FLAGS (iidx);
+    if (flags->fixed && first)
+      first = false;
+    else if (!flags->active)
+      POKE_STACK (solver->export_, iidx, 0);
+  }
+
+  compact_trail (solver);
+
+  for (all_variables (iidx)) {
+    const unsigned ilit = LIT (iidx);
+    const unsigned mlit = kissat_map_literal (solver, ilit, true);
+    if (mlit != INVALID_LIT && ilit != mlit)
+      compact_literal (solver, mlit, ilit);
+  }
+
+  if (mfixed != INVALID_LIT)
+    compact_units (solver, mfixed);
+
+  memset (solver->assigned + vars, 0, reduced * sizeof (assigned));
+  memset (solver->flags + vars, 0, reduced * sizeof (flags));
+  memset (solver->values + 2 * vars, 0, 2 * reduced * sizeof (value));
+  memset (solver->watches + 2 * vars, 0, 2 * reduced * sizeof (watches));
+
+  compact_queue (solver);
+  compact_stack (solver, &solver->sweep_schedule);
+  compact_scores (solver, SCORES, vars);
+  compact_frames (solver);
+  compact_export (solver, vars);
+  compact_best_and_target_values (solver, vars);
+
+  solver->vars = vars;
+#ifdef LOGGING
+  solver->compacting = false;
+#endif
+  kissat_decrease_size (solver);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/compact.h b/src/sat/kissat/compact.h
new file mode 100644
index 000000000..6c281af23
--- /dev/null
+++ b/src/sat/kissat/compact.h
@@ -0,0 +1,14 @@
+#ifndef _compact_h_INCLUDED
+#define _compact_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+unsigned kissat_compact_literals (struct kissat *, unsigned *mfixed_ptr);
+void kissat_finalize_compacting (struct kissat *, unsigned vars,
+                                 unsigned mfixed);
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/config.c b/src/sat/kissat/config.c
new file mode 100644
index 000000000..b1f322ba4
--- /dev/null
+++ b/src/sat/kissat/config.c
@@ -0,0 +1,85 @@
+#include "global.h"
+
+#ifndef KISSAT_NOPTIONS
+
+#include "config.h"
+#include "kissat.h"
+#include "options.h"
+
+#include <stdio.h>
+#include <string.h>
+
+int kissat_has_configuration (const char *name) {
+  if (!strcmp (name, "basic"))
+    return 1;
+  if (!strcmp (name, "default"))
+    return 1;
+  if (!strcmp (name, "plain"))
+    return 1;
+  if (!strcmp (name, "sat"))
+    return 1;
+  if (!strcmp (name, "unsat"))
+    return 1;
+  return 0;
+}
+
+void kissat_configuration_usage (void) {
+#define FMT "  --%-8s %s"
+  printf (FMT "\n", "basic",
+          "basic CDCL solving "
+          "('--plain' but no restarts, minimize, reduce)");
+  printf (FMT "\n", "default", "default configuration");
+  printf (FMT "\n", "plain",
+          "plain CDCL solving without advanced techniques");
+  printf (FMT " ('--target=%d --restartint=%d')\n", "sat",
+          "target satisfiable instances", (int) TARGET_SAT,
+          (int) RESTARTINT_SAT);
+  printf (FMT " ('--stable=%d')\n", "unsat",
+          "target unsatisfiable instances", (int) STABLE_UNSAT);
+}
+
+static void set_plain_options (kissat *solver) {
+  kissat_set_option (solver, "bumpreasons", 0);
+  kissat_set_option (solver, "chrono", 0);
+  kissat_set_option (solver, "compact", 0);
+  kissat_set_option (solver, "eagersubsume", 0);
+  kissat_set_option (solver, "jumpreasons", 0);
+  kissat_set_option (solver, "otfs", 0);
+  kissat_set_option (solver, "preprocess", 0);
+  kissat_set_option (solver, "reorder", 0);
+  kissat_set_option (solver, "rephase", 0);
+  kissat_set_option (solver, "restartreusetrail", 0);
+  kissat_set_option (solver, "simplify", 0);
+  kissat_set_option (solver, "stable", 2);
+  kissat_set_option (solver, "tumble", 0);
+}
+
+int kissat_set_configuration (kissat *solver, const char *name) {
+  if (!strcmp (name, "basic")) {
+    set_plain_options (solver);
+    kissat_set_option (solver, "restart", 0);
+    kissat_set_option (solver, "reduce", 0);
+    kissat_set_option (solver, "minimize", 0);
+    return 1;
+  }
+  if (!strcmp (name, "default"))
+    return 1;
+  if (!strcmp (name, "plain")) {
+    set_plain_options (solver);
+    return 1;
+  }
+  if (!strcmp (name, "sat")) {
+    kissat_set_option (solver, "target", TARGET_SAT);
+    kissat_set_option (solver, "restartint", RESTARTINT_SAT);
+    return 1;
+  }
+  if (!strcmp (name, "unsat")) {
+    kissat_set_option (solver, "stable", STABLE_UNSAT);
+    return 1;
+  }
+  return 0;
+}
+
+#else
+int kissat_config_dummy_to_avoid_warning;
+#endif
diff --git a/src/sat/kissat/config.h b/src/sat/kissat/config.h
new file mode 100644
index 000000000..d3d34fe49
--- /dev/null
+++ b/src/sat/kissat/config.h
@@ -0,0 +1,14 @@
+#ifndef _config_h_INCLUDED
+#define _config_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifndef KISSAT_NOPTIONS
+
+void kissat_configuration_usage (void);
+
+#endif
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/congruence.c b/src/sat/kissat/congruence.c
new file mode 100644
index 000000000..221f6a13a
--- /dev/null
+++ b/src/sat/kissat/congruence.c
@@ -0,0 +1,4651 @@
+#include "congruence.h"
+#include "dense.h"
+#include "fifo.h"
+#include "inline.h"
+#include "inlinevector.h"
+#include "internal.h"
+#include "logging.h"
+#include "print.h"
+#include "proprobe.h"
+#include "rank.h"
+#include "reference.h"
+#include "report.h"
+#include "sort.h"
+#include "terminate.h"
+#include "trail.h"
+#include "utilities.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+// #define INDEX_LARGE_CLAUSES
+// #define INDEX_BINARY_CLAUSES
+#define MERGE_CONDITIONAL_EQUIVALENCES
+
+#define AND_GATE 0
+#define XOR_GATE 1
+#define ITE_GATE 2
+
+#define LD_MAX_ARITY 26
+#define MAX_ARITY ((1 << LD_MAX_ARITY) - 1)
+
+struct gate {
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  size_t id;
+#endif
+  unsigned lhs;
+  unsigned hash;
+  unsigned tag : 2;
+  bool garbage : 1;
+  bool indexed : 1;
+  bool marked : 1;
+  bool shrunken : 1;
+  unsigned arity : LD_MAX_ARITY;
+  unsigned rhs[];
+};
+
+typedef struct gate gate;
+typedef STACK (gate *) gates;
+
+struct gate_hash_table {
+  gate **table;
+  size_t size;
+  size_t entries;
+};
+
+typedef struct gate_hash_table gate_hash_table;
+
+#define REMOVED ((gate *) (~(uintptr_t) 0))
+
+#define BEGIN_RHS(G) ((G)->rhs)
+#define END_RHS(G) (BEGIN_RHS (G) + (G)->arity)
+
+#define all_rhs_literals_in_gate(LIT, G) \
+  unsigned LIT, \
+      *LIT##_PTR = BEGIN_RHS (G), *const LIT##_END = END_RHS (G); \
+  LIT##_PTR != LIT##_END && ((LIT = *LIT##_PTR), true); \
+  ++LIT##_PTR
+
+#ifdef INDEX_BINARY_CLAUSES
+
+struct binary_clause {
+  unsigned lits[2];
+};
+
+typedef struct binary_clause binary_clause;
+
+struct binary_hash_table {
+  binary_clause *table;
+  size_t size, size2, count;
+};
+
+typedef struct binary_hash_table binary_hash_table;
+
+#endif
+
+struct hash_ref {
+  unsigned hash;
+  reference ref;
+};
+
+#ifdef INDEX_LARGE_CLAUSES
+
+typedef struct hash_ref hash_ref;
+
+struct large_clause_hash_table {
+  hash_ref *table;
+  size_t size, size2, count;
+};
+
+typedef struct large_clause_hash_table large_clause_hash_table;
+
+#endif
+
+#define SIZE_NONCES 16
+
+struct closure {
+  kissat *solver;
+  bool *scheduled;
+  gates *occurrences;
+  gates garbage;
+  unsigneds lits;
+  unsigneds rhs;
+  unsigneds unsimplified;
+  litpairs binaries;
+  unsigned_fifo schedule;
+  unsigned *repr;
+  gate_hash_table hash;
+  uint64_t nonces[SIZE_NONCES];
+  unsigned *units;
+  unsigned *equivalences;
+  unsigned *negbincount;
+  unsigned *largecount;
+  litpairs condbin[2];
+  litpairs condeq[2];
+#ifdef INDEX_BINARY_CLAUSES
+  binary_hash_table bintab;
+#endif
+#ifdef INDEX_LARGE_CLAUSES
+  large_clause_hash_table clauses;
+#endif
+#ifdef CHECKING_OR_PROVING
+  unsigneds chain;
+#endif
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  size_t gates_added;
+#endif
+#ifndef KISSAT_NDEBUG
+  unsigneds implied;
+#endif
+};
+
+typedef struct closure closure;
+
+static void init_closure (kissat *solver, closure *closure) {
+  closure->solver = solver;
+  CALLOC (bool, closure->scheduled, VARS);
+  CALLOC (gates, closure->occurrences, LITS);
+  INIT_STACK (closure->garbage);
+  INIT_STACK (closure->lits);
+  INIT_STACK (closure->rhs);
+  INIT_STACK (closure->unsimplified);
+  INIT_STACK (closure->binaries);
+  INIT_FIFO (closure->schedule);
+
+  NALLOC (unsigned, closure->repr, LITS);
+  for (all_literals (lit))
+    closure->repr[lit] = lit;
+
+  closure->hash.table = 0;
+  closure->hash.size = closure->hash.entries = 0;
+
+  generator random = solver->random;
+  for (size_t i = 0; i != SIZE_NONCES; i++)
+    closure->nonces[i] = 1 | kissat_next_random64 (&random);
+
+#ifdef CHECKING_OR_PROVING
+  INIT_STACK (closure->chain);
+#endif
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  closure->gates_added = 0;
+#endif
+#ifndef KISSAT_NDEBUG
+  INIT_STACK (closure->implied);
+#endif
+}
+
+static size_t bytes_gate (size_t arity) {
+  return sizeof (gate) + arity * sizeof (unsigned);
+}
+
+static unsigned actual_gate_arity (gate *g) {
+  unsigned res = g->arity;
+  if (!g->shrunken)
+    return res;
+  while (g->rhs[res++] != INVALID_LIT)
+    ;
+  return res;
+}
+
+#define CLOGANDGATE(G, ...) \
+  do { \
+    KISSAT_assert ((G)->tag == AND_GATE); \
+    LOGANDGATE ((G)->id, closure->repr, (G)->lhs, (G)->arity, (G)->rhs, \
+                __VA_ARGS__); \
+  } while (0)
+
+#define CLOGXORGATE(G, ...) \
+  do { \
+    KISSAT_assert ((G)->tag == XOR_GATE); \
+    LOGXORGATE ((G)->id, closure->repr, (G)->lhs, (G)->arity, (G)->rhs, \
+                __VA_ARGS__); \
+  } while (0)
+
+#define CLOGITEGATE(G, ...) \
+  do { \
+    KISSAT_assert ((G)->tag == ITE_GATE); \
+    LOGITEGATE ((G)->id, closure->repr, (G)->lhs, (G)->rhs[0], \
+                (G)->rhs[1], (G)->rhs[2], __VA_ARGS__); \
+  } while (0)
+
+#define CLOGREPR(L) LOGREPR ((L), closure->repr)
+
+#define LOGATE(G, ...) \
+  do { \
+    if ((G)->tag == AND_GATE) \
+      CLOGANDGATE (G, __VA_ARGS__); \
+    else if ((G)->tag == XOR_GATE) \
+      CLOGXORGATE (G, __VA_ARGS__); \
+    else { \
+      KISSAT_assert ((G)->tag == ITE_GATE); \
+      CLOGITEGATE (G, __VA_ARGS__); \
+    } \
+  } while (0)
+
+static void delete_gate (closure *closure, gate *g) {
+  kissat *const solver = closure->solver;
+  LOGATE (g, "delete");
+  unsigned actual_arity = actual_gate_arity (g);
+  size_t actual_bytes = bytes_gate (actual_arity);
+  kissat_free (solver, g, actual_bytes);
+}
+
+void reset_gate_hash_table (closure *closure) {
+  kissat *const solver = closure->solver;
+  gate **table = closure->hash.table;
+  for (size_t pos = 0; pos != closure->hash.size; pos++) {
+    gate *g = table[pos];
+    if (g && g != REMOVED && !g->garbage)
+      delete_gate (closure, g);
+  }
+  DEALLOC (table, closure->hash.size);
+}
+
+static void reset_closure (closure *closure) {
+  kissat *const solver = closure->solver;
+
+  gates *occurrences = closure->occurrences;
+  for (all_literals (lit))
+    RELEASE_STACK (occurrences[lit]);
+  DEALLOC (occurrences, LITS);
+
+  reset_gate_hash_table (closure);
+  for (all_pointers (gate, g, closure->garbage))
+    delete_gate (closure, g);
+
+  RELEASE_STACK (closure->garbage);
+  RELEASE_STACK (closure->binaries);
+  DEALLOC (closure->scheduled, VARS);
+  RELEASE_STACK (closure->lits);
+  RELEASE_STACK (closure->rhs);
+  RELEASE_STACK (closure->unsimplified);
+  RELEASE_FIFO (closure->schedule);
+#ifdef CHECKING_OR_PROVING
+  RELEASE_STACK (closure->chain);
+#endif
+#ifndef KISSAT_NDEBUG
+  RELEASE_STACK (closure->implied);
+#endif
+
+  if (!solver->inconsistent && solver->unflushed)
+    kissat_flush_trail (solver);
+}
+
+static unsigned reset_repr (closure *closure) {
+  kissat *const solver = closure->solver;
+  unsigned res = 0, *repr = closure->repr;
+  for (all_variables (idx)) {
+    unsigned lit = LIT (idx);
+    if (!VALUE (lit) && repr[lit] != lit)
+      res++;
+  }
+  DEALLOC (repr, LITS);
+  return res;
+}
+
+#ifndef KISSAT_NDEBUG
+
+static void check_lits_sorted (size_t size, const unsigned *lits) {
+  unsigned prev = INVALID_LIT;
+  const unsigned *const end_lits = lits + size;
+  for (const unsigned *p = lits; p != end_lits; p++) {
+    const unsigned lit = *p;
+    if (prev != INVALID_LIT) {
+      KISSAT_assert (prev != lit);
+      const unsigned not_lit = lit ^ 1;
+      KISSAT_assert (prev != not_lit);
+      KISSAT_assert (prev < lit);
+    }
+    prev = lit;
+  }
+}
+
+static void check_and_lits_normalized (size_t arity, const unsigned *lits) {
+  KISSAT_assert (arity > 1);
+  check_lits_sorted (arity, lits);
+}
+
+static void check_xor_lits_normalized (const unsigned arity,
+                                       const unsigned *lits) {
+  KISSAT_assert (arity > 1);
+  check_lits_sorted (arity, lits);
+  for (size_t i = 1; i != arity; i++)
+    KISSAT_assert (lits[i - 1] < lits[i]);
+}
+
+static void check_ite_lits_normalized (kissat *solver,
+                                       const unsigned *lits) {
+  KISSAT_assert (!NEGATED (lits[0]));
+  KISSAT_assert (!NEGATED (lits[1]));
+  KISSAT_assert (lits[0] != lits[1]);
+  KISSAT_assert (lits[0] != lits[2]);
+  KISSAT_assert (lits[1] != lits[2]);
+  KISSAT_assert (lits[0] != NOT (lits[1]));
+  KISSAT_assert (lits[0] != NOT (lits[2]));
+  KISSAT_assert (lits[1] != NOT (lits[2]));
+}
+
+#else
+
+#define check_lits_sorted(...) \
+  do { \
+  } while (0)
+
+#define check_and_lits_normalized check_lits_sorted
+#define check_xor_lits_normalized check_lits_sorted
+#define check_ite_lits_normalized check_lits_sorted
+
+#endif
+
+#define LESS_LIT(A, B) ((A) < (B))
+
+static void sort_lits (kissat *solver, size_t arity, unsigned *lits) {
+  SORT (unsigned, arity, lits, LESS_LIT);
+  check_lits_sorted (arity, lits);
+}
+
+static unsigned hash_lits (closure *closure, unsigned tag, size_t arity,
+                           const unsigned *lits) {
+#ifndef KISSAT_NDEBUG
+  if (tag == AND_GATE)
+    check_and_lits_normalized (arity, lits);
+  else if (tag == XOR_GATE)
+    check_xor_lits_normalized (arity, lits);
+  else {
+    KISSAT_assert (tag == ITE_GATE);
+    check_ite_lits_normalized (closure->solver, lits);
+  }
+#endif
+  const unsigned *end_lits = lits + arity;
+  const uint64_t *const nonces = closure->nonces;
+  const uint64_t *const end_nonces = nonces + SIZE_NONCES;
+  const uint64_t *n = nonces + tag;
+  uint64_t hash = 0;
+  KISSAT_assert (n < end_nonces);
+  for (const unsigned *l = lits; l != end_lits; l++) {
+    hash += *l;
+    hash *= *n++;
+    hash = (hash << 4) | (hash >> 60);
+    if (n == end_nonces)
+      n = nonces;
+  }
+  hash ^= hash >> 32;
+  return hash;
+}
+
+#ifndef KISSAT_NDEBUG
+static bool is_power_of_two (size_t n) { return n && ~(n & (n - 1)); }
+#endif
+
+static size_t reduce_hash (unsigned hash, size_t size, size_t size2) {
+  KISSAT_assert (size <= size2);
+  KISSAT_assert (size2 <= 2 * size);
+  KISSAT_assert (is_power_of_two (size2));
+  unsigned res = hash;
+  res &= size2 - 1;
+  if (res >= size)
+    res -= size;
+  KISSAT_assert (res < size);
+  return res;
+}
+
+#define MAX_HASH_TABLE_SIZE ((size_t) 1 << 32)
+
+static bool closure_hash_table_is_full (closure *closure) {
+  if (closure->hash.size == MAX_HASH_TABLE_SIZE)
+    return false;
+  if (2 * closure->hash.entries < closure->hash.size)
+    return false;
+  return true;
+}
+
+static bool match_lits (gate *g, unsigned tag, unsigned hash, size_t size,
+                        const unsigned *lits) {
+  KISSAT_assert (!g->garbage);
+  if (g->tag != tag)
+    return false;
+  if (g->hash != hash)
+    return false;
+  if (g->arity != size)
+    return false;
+  const unsigned *p = lits;
+  for (all_rhs_literals_in_gate (lit, g))
+    if (lit != *p++)
+      return false;
+  return true;
+}
+
+static void resize_gate_hash_table (closure *closure) {
+  kissat *solver = closure->solver;
+  gate_hash_table *hash = &closure->hash;
+  const size_t old_size = hash->size;
+  const size_t new_size = old_size ? 2 * old_size : 1;
+  const size_t old_entries = hash->entries;
+  kissat_extremely_verbose (
+      solver,
+      "resizing gate table of size %zu filled with %zu entries %.0f%%",
+      old_size, old_entries, kissat_percent (old_entries, old_size));
+  gate **old_table = hash->table, **new_table;
+  CALLOC (gate*, new_table, new_size);
+  size_t flushed = 0;
+  for (size_t old_pos = 0; old_pos != old_size; old_pos++) {
+    gate *g = old_table[old_pos];
+    if (!g)
+      continue;
+    if (g == REMOVED) {
+      flushed++;
+      continue;
+    }
+    size_t new_pos = reduce_hash (g->hash, new_size, new_size);
+    while (new_table[new_pos]) {
+      KISSAT_assert (new_table[new_pos] != REMOVED);
+      if (++new_pos == new_size)
+        new_pos = 0;
+    }
+    new_table[new_pos] = g;
+  }
+  kissat_extremely_verbose (
+      solver, "flushed %zu entries %.0f%% resizing table of size %zu",
+      flushed, kissat_percent (flushed, old_size), old_size);
+  DEALLOC (old_table, old_size);
+  KISSAT_assert (flushed <= old_entries);
+  const size_t new_entries = old_entries - flushed;
+  hash->table = new_table;
+  hash->size = new_size;
+  hash->entries = new_entries;
+  kissat_very_verbose (
+      solver, "resized gate table to %zu with %zu entries %.0f%%", new_size,
+      new_entries, kissat_percent (new_entries, new_size));
+}
+
+static bool remove_gate (closure *closure, gate *g) {
+  if (!g->indexed)
+    return false;
+  kissat *solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  const size_t hash_size = closure->hash.size;
+  size_t pos = reduce_hash (g->hash, hash_size, hash_size);
+  gate **table = closure->hash.table;
+  INC (congruent_lookups);
+  INC (congruent_lookups_removed);
+  unsigned collisions = 0;
+  while (table[pos] != g) {
+    collisions++;
+    if (++pos == hash_size)
+      pos = 0;
+  }
+  ADD (congruent_collisions_removed, collisions);
+  ADD (congruent_collisions, collisions);
+  table[pos] = REMOVED;
+  LOGATE (g, "removing from hash table");
+  g->indexed = false;
+  return true;
+}
+
+static gate *find_gate (closure *closure, unsigned tag, unsigned hash,
+                        size_t size, const unsigned *lits, gate *except) {
+  KISSAT_assert (!except || !except->garbage);
+  if (!closure->hash.entries)
+    return 0;
+  kissat *solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (hash == hash_lits (closure, tag, size, lits));
+  const size_t hash_size = closure->hash.size;
+  size_t start_pos = reduce_hash (hash, hash_size, hash_size);
+  gate **table = closure->hash.table, *g;
+  INC (congruent_lookups);
+  INC (congruent_lookups_find);
+  size_t pos = start_pos;
+  unsigned collisions = 0;
+  gate *res = 0;
+  while ((g = table[pos])) {
+    if (g == REMOVED)
+      ;
+    else if (g->garbage) {
+      KISSAT_assert (g->indexed);
+      g->indexed = false;
+      table[pos] = REMOVED;
+    } else if (g != except && match_lits (g, tag, hash, size, lits)) {
+      INC (congruent_matched);
+      res = g;
+      break;
+    }
+    collisions++;
+    if (++pos == hash_size)
+      pos = 0;
+    if (pos == start_pos)
+      break;
+  }
+  ADD (congruent_collisions_find, collisions);
+  ADD (congruent_collisions, collisions);
+  return res;
+}
+
+static void index_gate (closure *closure, gate *g) {
+  KISSAT_assert (!g->indexed);
+  kissat *solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (g->arity > 1);
+  if (closure_hash_table_is_full (closure))
+    resize_gate_hash_table (closure);
+  LOGATE (g, "adding to hash table");
+  INC (congruent_indexed);
+  KISSAT_assert (g->hash == hash_lits (closure, g->tag, g->arity, g->rhs));
+  const size_t hash_size = closure->hash.size;
+  size_t pos = reduce_hash (g->hash, hash_size, hash_size);
+  gate **table = closure->hash.table, *h;
+  unsigned collisions = 0;
+  while ((h = table[pos]) && h != REMOVED) {
+    collisions++;
+    if (++pos == hash_size)
+      pos = 0;
+  }
+  ADD (congruent_collisions_index, collisions);
+  ADD (congruent_collisions, collisions);
+  table[pos] = g;
+  closure->hash.entries++;
+  g->indexed = true;
+}
+
+static unsigned parity_lits (kissat *solver, unsigneds *lits) {
+  unsigned res = 0;
+  for (all_stack (unsigned, lit, *lits))
+    res ^= NEGATED (lit);
+#ifdef KISSAT_NDEBUG
+  (void) solver;
+#endif
+  return res;
+}
+
+static void inc_lits (kissat *solver, unsigneds *lits) {
+  unsigned *p = BEGIN_STACK (*lits);
+  unsigned *end = END_STACK (*lits);
+  unsigned carry = 1;
+  while (carry && p != end) {
+    unsigned lit = *p;
+    unsigned not_lit = NOT (lit);
+    carry = !NEGATED (not_lit);
+    *p++ = not_lit;
+  }
+#ifdef KISSAT_NDEBUG
+  (void) solver;
+#endif
+}
+
+#ifndef KISSAT_NDEBUG
+
+#define LESS_LITERAL(A, B) ((A) < (B))
+
+static void check_implied (closure *closure) {
+  kissat *const solver = closure->solver;
+  unsigneds *implied = &closure->implied;
+  SORT_STACK (unsigned, *implied, LESS_LITERAL);
+  unsigned *q = BEGIN_STACK (*implied);
+  const unsigned *const end = END_STACK (*implied);
+  unsigned prev = INVALID_LIT;
+  bool tautological = false;
+  for (const unsigned *p = q; p != end; p++) {
+    const unsigned lit = *p;
+    if (prev == lit)
+      continue;
+    const unsigned not_lit = NOT (lit);
+    if (prev == not_lit) {
+      tautological = true;
+      break;
+    }
+    *q++ = prev = lit;
+  }
+  if (!tautological) {
+    SET_END_OF_STACK (*implied, q);
+    CHECK_AND_ADD_STACK (*implied);
+    REMOVE_CHECKER_STACK (*implied);
+  }
+  CLEAR_STACK (*implied);
+}
+
+static void check_clause (closure *closure) {
+  kissat *const solver = closure->solver;
+  unsigneds *implied = &closure->implied;
+  unsigneds *clause = &solver->clause;
+  for (all_stack (unsigned, lit, *clause))
+    PUSH_STACK (*implied, lit);
+  check_implied (closure);
+}
+
+static void check_binary_implied (closure *closure, unsigned a,
+                                  unsigned b) {
+  kissat *const solver = closure->solver;
+  unsigneds *implied = &closure->implied;
+  KISSAT_assert (EMPTY_STACK (*implied));
+  PUSH_STACK (*implied, a);
+  PUSH_STACK (*implied, b);
+  check_implied (closure);
+}
+
+static void check_and_gate_implied (closure *closure, gate *g) {
+  KISSAT_assert (g->tag == AND_GATE);
+  kissat *const solver = closure->solver;
+  if (GET_OPTION (check) < 2)
+    return;
+  CLOGANDGATE (g, "checking implied");
+  const unsigned lhs = g->lhs;
+  const unsigned not_lhs = NOT (lhs);
+  for (all_rhs_literals_in_gate (other, g))
+    check_binary_implied (closure, not_lhs, other);
+  unsigneds *implied = &closure->implied;
+  KISSAT_assert (EMPTY_STACK (*implied));
+  PUSH_STACK (*implied, lhs);
+  for (all_rhs_literals_in_gate (other, g)) {
+    const unsigned not_other = NOT (other);
+    PUSH_STACK (*implied, not_other);
+  }
+  check_implied (closure);
+}
+
+static void check_xor_gate_implied (closure *closure, gate *g) {
+  KISSAT_assert (g->tag == XOR_GATE);
+  kissat *const solver = closure->solver;
+  if (GET_OPTION (check) < 2)
+    return;
+  CLOGXORGATE (g, "checking implied");
+  const unsigned lhs = g->lhs;
+  const unsigned not_lhs = NOT (lhs);
+  unsigneds *clause = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*clause));
+  PUSH_STACK (*clause, not_lhs);
+  for (all_rhs_literals_in_gate (other, g)) {
+    KISSAT_assert (!NEGATED (other));
+    PUSH_STACK (*clause, other);
+  }
+  unsigned arity = g->arity;
+  unsigned end = 1u << arity;
+  unsigned parity = NEGATED (not_lhs);
+  KISSAT_assert (parity == parity_lits (solver, clause));
+  for (unsigned i = 0; i != end; i++) {
+    while (i && parity_lits (solver, clause) != parity)
+      inc_lits (solver, clause);
+    check_clause (closure);
+    inc_lits (solver, clause);
+  }
+  CLEAR_STACK (*clause);
+}
+
+static void check_ternary (closure *closure, unsigned a, unsigned b,
+                           unsigned c) {
+  kissat *const solver = closure->solver;
+  if (GET_OPTION (check) < 2)
+    return;
+  unsigneds *implied = &closure->implied;
+  PUSH_STACK (*implied, a);
+  PUSH_STACK (*implied, b);
+  PUSH_STACK (*implied, c);
+  check_implied (closure);
+}
+
+static void check_ite_implied (closure *closure, unsigned lhs,
+                               unsigned cond, unsigned then_lit,
+                               unsigned else_lit) {
+  kissat *const solver = closure->solver;
+  if (GET_OPTION (check) < 2)
+    return;
+  LOG ("checking implied ITE gate %s := %s ? %s : %s", LOGLIT (lhs),
+       LOGLIT (cond), LOGLIT (then_lit), LOGLIT (else_lit));
+  const unsigned not_lhs = NOT (lhs);
+  const unsigned not_cond = NOT (cond);
+  const unsigned not_then_lit = NOT (then_lit);
+  const unsigned not_else_lit = NOT (else_lit);
+  check_ternary (closure, cond, not_else_lit, lhs);
+  check_ternary (closure, cond, else_lit, not_lhs);
+  check_ternary (closure, not_cond, not_then_lit, lhs);
+  check_ternary (closure, not_cond, then_lit, not_lhs);
+}
+
+static void check_ite_gate_implied (closure *closure, gate *g) {
+  KISSAT_assert (g->tag == ITE_GATE);
+  KISSAT_assert (g->arity == 3);
+#ifndef KISSAT_NOPTIONS
+  kissat *const solver = closure->solver;
+#endif
+  if (GET_OPTION (check) < 2)
+    return;
+  const unsigned lhs = g->lhs;
+  const unsigned cond = g->rhs[0];
+  const unsigned then_lit = g->rhs[1];
+  const unsigned else_lit = g->rhs[2];
+  check_ite_implied (closure, lhs, cond, then_lit, else_lit);
+}
+
+#else
+
+#define check_and_gate_implied(...) \
+  do { \
+  } while (0)
+
+#define check_xor_gate_implied check_and_gate_implied
+#define check_ternary check_and_gate_implied
+#define check_ite_implied check_and_gate_implied
+#define check_ite_gate_implied check_and_gate_implied
+
+#endif
+
+static inline unsigned find_repr (closure *closure, unsigned lit) {
+  const unsigned *const repr = closure->repr;
+  unsigned res = lit, next = repr[res];
+  while (res != next)
+    res = next, next = repr[res];
+  return res;
+}
+
+#ifndef MERGE_CONDITIONAL_EQUIVALENCES
+
+static clause *find_other_two (kissat *solver, watches *watches, unsigned a,
+                               unsigned b, unsigned ignore) {
+  KISSAT_assert (!solver->watching);
+  const value *const values = solver->values;
+  const watch *const begin_watches = BEGIN_WATCHES (*watches);
+  const watch *const end_watches = END_WATCHES (*watches);
+  const watch *p = begin_watches;
+  while (p != end_watches) {
+    const watch watch = *p++;
+    KISSAT_assert (!watch.type.binary);
+    const reference ref = watch.large.ref;
+    clause *c = kissat_dereference_clause (solver, ref);
+    KISSAT_assert (!c->garbage);
+    unsigned found = 0;
+    for (all_literals_in_clause (lit, c)) {
+      if (values[lit])
+        continue;
+      if (lit == ignore)
+        continue;
+      if (lit == a || lit == b) {
+        found++;
+        continue;
+      }
+      goto CONTINUE_WITH_NEXT_WATCH;
+    }
+    KISSAT_assert (found <= 2);
+    if (found == 2)
+      return c;
+  CONTINUE_WITH_NEXT_WATCH:;
+  }
+  return 0;
+}
+
+static clause *find_ternary_clause (kissat *solver, unsigned a, unsigned b,
+                                    unsigned c) {
+  KISSAT_assert (!solver->watching);
+  watches *const a_watches = &WATCHES (a);
+  watches *const b_watches = &WATCHES (b);
+  watches *const c_watches = &WATCHES (c);
+  const size_t size_a = SIZE_WATCHES (*a_watches);
+  const size_t size_b = SIZE_WATCHES (*b_watches);
+  const size_t size_c = SIZE_WATCHES (*c_watches);
+  if (size_a <= size_b && size_a <= size_b)
+    return find_other_two (solver, a_watches, b, c, a);
+  if (size_b <= size_a && size_b <= size_c)
+    return find_other_two (solver, b_watches, a, c, b);
+  KISSAT_assert (size_c <= size_a && size_c <= size_b);
+  return find_other_two (solver, c_watches, a, b, c);
+}
+
+#endif
+
+static bool learn_congruence_unit (closure *closure, unsigned unit) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  const value value = solver->values[unit];
+  if (value > 0)
+    return true;
+  INC (congruent_units);
+  if (value < 0) {
+    solver->inconsistent = 1;
+    LOG ("inconsistent congruence unit %s", LOGLIT (unit));
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    return false;
+  }
+  LOG ("learning congruence unit %s", LOGLIT (unit));
+  kissat_learned_unit (solver, unit);
+  clause *conflict = kissat_probing_propagate (solver, 0, false);
+  if (!conflict)
+    return true;
+  KISSAT_assert (solver->inconsistent);
+  LOG ("propagating congruence unit %s yields conflict", LOGLIT (unit));
+  return false;
+}
+
+static void add_binary_clause (closure *closure, unsigned a, unsigned b) {
+  kissat *const solver = closure->solver;
+  if (solver->inconsistent)
+    return;
+  if (a == NOT (b))
+    return;
+  value a_value = VALUE (a);
+  if (a_value > 0)
+    return;
+  value b_value = VALUE (b);
+  if (b_value > 0)
+    return;
+  unsigned unit = INVALID_LIT;
+  if (a == b)
+    unit = a;
+  else if (a_value < 0 && !b_value)
+    unit = b;
+  else if (!a_value && b_value < 0)
+    unit = a;
+  if (unit != INVALID_LIT) {
+    (void) !learn_congruence_unit (closure, unit);
+    return;
+  }
+  KISSAT_assert (!a_value), KISSAT_assert (!b_value);
+  LOGBINARY (a, b, "adding representative");
+  if (solver->watching)
+    kissat_new_binary_clause (solver, a, b);
+  else {
+    kissat_new_unwatched_binary_clause (solver, a, b);
+    litpair litpair = {.lits = {a < b ? a : b, a < b ? b : a}};
+    PUSH_STACK (closure->binaries, litpair);
+  }
+}
+
+static void schedule_literal (closure *closure, unsigned lit) {
+  kissat *const solver = closure->solver;
+  unsigned idx = IDX (lit);
+  bool *scheduled = closure->scheduled + idx;
+  if (*scheduled)
+    return;
+  *scheduled = true;
+  ENQUEUE_FIFO (unsigned, closure->schedule, lit);
+  LOG ("scheduled propagation of merged %s", CLOGREPR (lit));
+}
+
+static unsigned dequeue_next_scheduled_literal (closure *closure) {
+  unsigned res;
+  DEQUEUE_FIFO (closure->schedule, res);
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  kissat *const solver = closure->solver;
+#endif
+  unsigned idx = IDX (res);
+  bool *scheduled = closure->scheduled + idx;
+  KISSAT_assert (*scheduled);
+  *scheduled = false;
+  LOG ("dequeued from schedule %s", CLOGREPR (res));
+  return res;
+}
+
+static bool merge_literals (closure *closure, unsigned lit,
+                            unsigned other) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  unsigned repr_lit = find_repr (closure, lit);
+  unsigned repr_other = find_repr (closure, other);
+  unsigned *const repr = closure->repr;
+  if (repr_lit == repr_other) {
+    LOG ("already merged %s and %s", LOGREPR (lit, repr),
+         LOGREPR (other, repr));
+    return false;
+  }
+  const value *const values = solver->values;
+  const value lit_value = values[lit];
+  const value other_value = values[other];
+  KISSAT_assert (lit_value == values[repr_lit]);
+  KISSAT_assert (other_value == values[repr_other]);
+  if (lit_value) {
+    if (lit_value == other_value) {
+      LOG ("not merging %s and %s assigned to the same value",
+           LOGREPR (lit, repr), LOGREPR (other, repr));
+      return false;
+    }
+    if (lit_value == -other_value) {
+      LOG ("merging inconsistently assigned %s and %s", LOGREPR (lit, repr),
+           LOGREPR (other, repr));
+      solver->inconsistent = true;
+      CHECK_AND_ADD_EMPTY ();
+      ADD_EMPTY_TO_PROOF ();
+      return false;
+    }
+    KISSAT_assert (!other_value);
+    LOG ("merging assigned %s and unassigned %s", LOGREPR (lit, repr),
+         LOGREPR (other, repr));
+    const unsigned unit = (lit_value < 0) ? NOT (other) : other;
+    (void) learn_congruence_unit (closure, unit);
+    return false;
+  }
+  if (!lit_value && other_value) {
+    LOG ("merging unassigned %s and assigned %s", LOGREPR (lit, repr),
+         LOGREPR (other, repr));
+    const unsigned unit = (other_value < 0) ? NOT (lit) : lit;
+    (void) learn_congruence_unit (closure, unit);
+    return false;
+  }
+  unsigned smaller = repr_lit;
+  unsigned larger = repr_other;
+  if (smaller > larger)
+    SWAP (unsigned, smaller, larger);
+  KISSAT_assert (repr[smaller] == smaller);
+  KISSAT_assert (repr[larger] > smaller);
+  if (repr_lit == NOT (repr_other)) {
+    LOG ("merging clashing %s and %s", LOGREPR (lit, repr),
+         LOGREPR (other, repr));
+    kissat_learned_unit (solver, smaller);
+    solver->inconsistent = true;
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    return false;
+  }
+  LOG ("merging %s and %s", LOGREPR (lit, repr), LOGREPR (other, repr));
+  const unsigned not_smaller = NOT (smaller);
+  const unsigned not_larger = NOT (larger);
+  repr[larger] = smaller;
+  repr[not_larger] = not_smaller;
+  LOG ("congruence repr[%s] = %s", LOGLIT (larger), LOGLIT (smaller));
+  LOG ("congruence repr[%s] = %s", LOGLIT (not_larger),
+       LOGLIT (not_smaller));
+  add_binary_clause (closure, not_larger, smaller);
+  add_binary_clause (closure, larger, not_smaller);
+  schedule_literal (closure, larger);
+  INC (congruent);
+  return true;
+}
+
+static void connect_occurrence (closure *closure, unsigned lit, gate *g) {
+  gates *const occurrences = closure->occurrences;
+  kissat *const solver = closure->solver;
+  PUSH_STACK (occurrences[lit], g);
+  LOG ("connected %s to gate[%zu]", LOGLIT (lit), g->id);
+}
+
+static gate *new_gate (closure *closure, unsigned tag, unsigned hash,
+                       unsigned lhs, unsigned arity, const unsigned *lits) {
+  kissat *const solver = closure->solver;
+  const size_t bytes = bytes_gate (arity);
+  gate *g = (gate*)kissat_malloc (solver, bytes);
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  g->id = closure->gates_added++;
+#endif
+  g->tag = tag;
+  g->hash = hash;
+  g->lhs = lhs;
+  g->arity = arity;
+  g->garbage = false;
+  g->indexed = false;
+  g->marked = false;
+  g->shrunken = false;
+  memcpy (g->rhs, lits, arity * sizeof *lits);
+  for (all_rhs_literals_in_gate (lit, g))
+    connect_occurrence (closure, lit, g);
+  LOGATE (g, "new");
+  index_gate (closure, g);
+  ADD (congruent_arity, arity);
+  INC (congruent_gates);
+  return g;
+}
+
+static gate *find_and_lits (closure *closure, unsigned *hash_ptr,
+                            unsigned arity, unsigned *lits, gate *except) {
+  kissat *const solver = closure->solver;
+  sort_lits (solver, arity, lits);
+  const unsigned hash = hash_lits (closure, AND_GATE, arity, lits);
+  gate *g = find_gate (closure, AND_GATE, hash, arity, lits, except);
+  *hash_ptr = hash;
+  if (g) {
+    CLOGANDGATE (g, "found matching");
+    INC (congruent_matched_ands);
+  } else
+    LOGANDGATE (INVALID_GATE_ID, closure->repr, INVALID_LIT, arity, lits,
+                "could not find matching");
+  return g;
+}
+
+static gate *find_and_gate (closure *closure, unsigned *h, gate *g) {
+  return find_and_lits (closure, h, g->arity, g->rhs, g);
+}
+
+static gate *new_and_gate (closure *closure, unsigned lhs) {
+  kissat *const solver = closure->solver;
+  unsigneds *all_lits = &closure->lits;
+  unsigneds *rhs_stack = &closure->rhs;
+  CLEAR_STACK (*rhs_stack);
+  for (all_stack (unsigned, lit, *all_lits))
+    if (lhs != lit) {
+      unsigned not_lit = NOT (lit);
+      KISSAT_assert (lhs != not_lit);
+      PUSH_STACK (*rhs_stack, not_lit);
+    }
+  const unsigned arity = SIZE_STACK (*rhs_stack);
+  unsigned *rhs_lits = BEGIN_STACK (*rhs_stack);
+  KISSAT_assert (arity + 1 == SIZE_STACK (*all_lits));
+  unsigned hash;
+  gate *g = find_and_lits (closure, &hash, arity, rhs_lits, 0);
+  if (g) {
+    if (merge_literals (closure, g->lhs, lhs))
+      INC (congruent_ands);
+    return 0;
+  }
+  g = new_gate (closure, AND_GATE, hash, lhs, arity, rhs_lits);
+  check_and_gate_implied (closure, g);
+  ADD (congruent_arity_ands, arity);
+  INC (congruent_gates_ands);
+  return g;
+}
+
+#ifdef CHECKING_OR_PROVING
+
+static void copy_literals (kissat *solver, unsigneds *dst,
+                           const unsigneds *src) {
+  for (all_stack (unsigned, lit, *src))
+    PUSH_STACK (*dst, lit);
+  PUSH_STACK (*dst, INVALID_LIT);
+}
+
+static void simplify_and_add_to_proof_chain (kissat *solver, mark *marks,
+                                             unsigneds *unsimplified,
+                                             unsigneds *clause,
+                                             unsigneds *chain) {
+  KISSAT_assert (EMPTY_STACK (*clause));
+#ifndef KISSAT_NDEBUG
+  for (all_stack (unsigned, lit, *unsimplified))
+    KISSAT_assert (!(marks[lit] & 4));
+#endif
+  bool trivial = false;
+  for (all_stack (unsigned, lit, *unsimplified)) {
+    mark lit_mark = marks[lit];
+    if (lit_mark & 4)
+      continue;
+    const unsigned not_lit = NOT (lit);
+    const mark not_lit_mark = marks[not_lit];
+    if (not_lit_mark & 4) {
+      trivial = true;
+      break;
+    }
+    lit_mark |= 4;
+    marks[lit] = lit_mark;
+    PUSH_STACK (*clause, lit);
+  }
+  for (all_stack (unsigned, lit, *clause)) {
+    mark mark = marks[lit];
+    KISSAT_assert (mark & 4);
+    mark &= ~4u;
+    marks[lit] = mark;
+  }
+  if (!trivial) {
+    CHECK_AND_ADD_STACK (*clause);
+    ADD_STACK_TO_PROOF (*clause);
+    copy_literals (solver, chain, clause);
+  }
+  CLEAR_STACK (*clause);
+}
+
+#define SIMPLIFY_AND_ADD_TO_PROOF_CHAIN() \
+  simplify_and_add_to_proof_chain (solver, marks, unsimplified, clause, \
+                                   chain)
+
+static void add_xor_matching_proof_chain (closure *closure, gate *g,
+                                          unsigned lhs1, unsigned lhs2) {
+  if (lhs1 == lhs2)
+    return;
+  kissat *const solver = closure->solver;
+  if (!kissat_checking_or_proving (solver))
+    return;
+  LOG ("starting XOR matching proof chain");
+  unsigneds *const unsimplified = &closure->unsimplified;
+  unsigneds *const clause = &solver->clause;
+  unsigneds *const chain = &closure->chain;
+  mark *const marks = solver->marks;
+  KISSAT_assert (EMPTY_STACK (*unsimplified));
+  KISSAT_assert (EMPTY_STACK (*chain));
+  KISSAT_assert (g->arity > 1);
+  const unsigned reduced_arity = g->arity - 1;
+  for (unsigned i = 0; i != reduced_arity; i++)
+    PUSH_STACK (*unsimplified, g->rhs[i]);
+  const unsigned not_lhs1 = NOT (lhs1);
+  const unsigned not_lhs2 = NOT (lhs2);
+  do {
+    const size_t size = SIZE_STACK (*unsimplified);
+    KISSAT_assert (size < 32);
+    for (unsigned i = 0; i != 1u << size; i++) {
+      PUSH_STACK (*unsimplified, not_lhs1);
+      PUSH_STACK (*unsimplified, lhs2);
+      SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+      unsimplified->end -= 2;
+      PUSH_STACK (*unsimplified, lhs1);
+      PUSH_STACK (*unsimplified, not_lhs2);
+      SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+      unsimplified->end -= 2;
+      inc_lits (solver, unsimplified);
+    }
+    KISSAT_assert (!EMPTY_STACK (*unsimplified));
+    unsimplified->end--;
+  } while (!EMPTY_STACK (*unsimplified));
+  LOG ("finished XOR matching proof chain");
+}
+
+static void delete_proof_chain (closure *closure) {
+  kissat *const solver = closure->solver;
+  unsigneds *chain = &closure->chain;
+  if (!kissat_checking_or_proving (solver)) {
+    KISSAT_assert (EMPTY_STACK (*chain));
+    return;
+  }
+  if (EMPTY_STACK (*chain))
+    return;
+  LOG ("starting deletion of proof chain");
+  unsigneds *clause = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*clause));
+  const unsigned *start = BEGIN_STACK (*chain);
+  const unsigned *end = END_STACK (*chain);
+  const unsigned *p = start;
+  while (p != end) {
+    const unsigned lit = *p;
+    if (lit == INVALID_LIT) {
+      while (start != p) {
+        const unsigned other = *start++;
+        PUSH_STACK (*clause, other);
+      }
+      REMOVE_CHECKER_STACK (*clause);
+      DELETE_STACK_FROM_PROOF (*clause);
+      CLEAR_STACK (*clause);
+      start++;
+    }
+    p++;
+  }
+  KISSAT_assert (EMPTY_STACK (*clause));
+  KISSAT_assert (start == end);
+  CLEAR_STACK (*chain);
+  LOG ("finished deletion of proof chain");
+}
+
+#else
+
+#define add_xor_matching_proof_chain(...) \
+  do { \
+  } while (0)
+
+#define delete_proof_chain(...) \
+  do { \
+  } while (0)
+
+#endif
+
+static gate *find_xor_lits (closure *closure, unsigned *hash_ptr,
+                            unsigned arity, unsigned *lits, gate *except) {
+  kissat *const solver = closure->solver;
+  sort_lits (solver, arity, lits);
+  const unsigned hash = hash_lits (closure, XOR_GATE, arity, lits);
+  gate *g = find_gate (closure, XOR_GATE, hash, arity, lits, except);
+  *hash_ptr = hash;
+  if (g) {
+    CLOGXORGATE (g, "found matching");
+    INC (congruent_matched_xors);
+  } else
+    LOGXORGATE (INVALID_GATE_ID, closure->repr, INVALID_LIT, arity, lits,
+                "tried but did not find matching");
+  return g;
+}
+
+static gate *find_xor_gate (closure *closure, unsigned *h, gate *g) {
+  return find_xor_lits (closure, h, g->arity, g->rhs, g);
+}
+
+static gate *new_xor_gate (closure *closure, unsigned lhs) {
+  kissat *const solver = closure->solver;
+  unsigneds *all_lits = &closure->lits;
+  unsigneds *rhs_stack = &closure->rhs;
+  CLEAR_STACK (*rhs_stack);
+  const unsigned not_lhs = NOT (lhs);
+  for (all_stack (unsigned, lit, *all_lits))
+    if (lit != lhs && lit != not_lhs) {
+      KISSAT_assert (!NEGATED (lit));
+      PUSH_STACK (*rhs_stack, lit);
+    }
+  const unsigned arity = SIZE_STACK (*rhs_stack);
+  unsigned *rhs_lits = BEGIN_STACK (*rhs_stack);
+  KISSAT_assert (arity + 1 == SIZE_STACK (*all_lits));
+  unsigned hash;
+  gate *g = find_xor_lits (closure, &hash, arity, rhs_lits, 0);
+  if (g) {
+    add_xor_matching_proof_chain (closure, g, g->lhs, lhs);
+    if (merge_literals (closure, g->lhs, lhs))
+      INC (congruent_xors);
+    if (!solver->inconsistent)
+      delete_proof_chain (closure);
+    return 0;
+  }
+  g = new_gate (closure, XOR_GATE, hash, lhs, arity, rhs_lits);
+  check_xor_gate_implied (closure, g);
+  ADD (congruent_arity_xors, arity);
+  INC (congruent_gates_xors);
+  return g;
+}
+
+#ifdef CHECKING_OR_PROVING
+
+static void add_ite_matching_proof_chain (closure *closure, gate *g,
+                                          unsigned lhs1, unsigned lhs2) {
+  if (lhs1 == lhs2)
+    return;
+  kissat *const solver = closure->solver;
+  if (!kissat_checking_or_proving (solver))
+    return;
+  LOG ("starting ITE matching proof chain");
+  unsigneds *const unsimplified = &closure->unsimplified;
+  unsigneds *clause = &solver->clause;
+  mark *const marks = solver->marks;
+  unsigneds *chain = &closure->chain;
+  KISSAT_assert (EMPTY_STACK (*clause));
+  KISSAT_assert (EMPTY_STACK (*chain));
+  const unsigned *rhs = g->rhs;
+  const unsigned cond = rhs[0];
+  const unsigned not_cond = NOT (cond);
+  const unsigned not_lhs1 = NOT (lhs1);
+  const unsigned not_lhs2 = NOT (lhs2);
+  PUSH_STACK (*unsimplified, lhs1);
+  PUSH_STACK (*unsimplified, not_lhs2);
+  PUSH_STACK (*unsimplified, cond);
+  SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+  unsimplified->end--;
+  PUSH_STACK (*unsimplified, not_cond);
+  SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+  unsimplified->end--;
+  CHECK_AND_ADD_STACK (*unsimplified);
+  ADD_STACK_TO_PROOF (*unsimplified);
+  copy_literals (solver, chain, unsimplified);
+  CLEAR_STACK (*unsimplified);
+  PUSH_STACK (*unsimplified, not_lhs1);
+  PUSH_STACK (*unsimplified, lhs2);
+  PUSH_STACK (*unsimplified, cond);
+  SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+  unsimplified->end--;
+  PUSH_STACK (*unsimplified, not_cond);
+  SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+  unsimplified->end--;
+  SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+  CLEAR_STACK (*unsimplified);
+  LOG ("finished ITE matching proof chain");
+}
+
+static void add_ite_turned_and_binary_clauses (closure *closure, gate *g) {
+  kissat *const solver = closure->solver;
+  if (!kissat_checking_or_proving (solver))
+    return;
+  LOG ("starting ITE turned AND supporting binary clauses");
+  unsigneds *const unsimplified = &closure->unsimplified;
+  unsigneds *clause = &solver->clause;
+  unsigneds *chain = &closure->chain;
+  mark *const marks = solver->marks;
+  KISSAT_assert (EMPTY_STACK (*unsimplified));
+  KISSAT_assert (EMPTY_STACK (*chain));
+  const unsigned not_lhs = NOT (g->lhs);
+  const unsigned *rhs = g->rhs;
+  PUSH_STACK (*unsimplified, not_lhs);
+  PUSH_STACK (*unsimplified, rhs[0]);
+  SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+  unsimplified->end--;
+  PUSH_STACK (*unsimplified, rhs[1]);
+  SIMPLIFY_AND_ADD_TO_PROOF_CHAIN ();
+  CLEAR_STACK (*unsimplified);
+}
+
+#else
+
+#define add_ite_matching_proof_chain(...) \
+  do { \
+  } while (0)
+
+#define add_ite_turned_and_binary_clauses add_ite_matching_proof_chain
+
+#endif
+
+static bool normalize_ite_lits (kissat *solver, unsigned *lits) {
+#ifdef KISSAT_NDEBUG
+  (void) solver;
+#endif
+  if (NEGATED (lits[0])) {
+    lits[0] = NOT (lits[0]);
+    SWAP (unsigned, lits[1], lits[2]);
+  }
+  if (!NEGATED (lits[1]))
+    return false;
+  lits[1] = NOT (lits[1]);
+  lits[2] = NOT (lits[2]);
+  return true;
+}
+
+static gate *find_ite_lits (closure *closure, unsigned *hash_ptr,
+                            bool *negate_lhs_ptr, unsigned arity,
+                            unsigned *lits, gate *except) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (arity == 3);
+  LOGITEGATE (INVALID_GATE_ID, closure->repr, INVALID_LIT, lits[0], lits[1],
+              lits[2], "finding not yet normalized");
+  bool negate_lhs = normalize_ite_lits (solver, lits);
+#ifdef LOGGING
+  if (negate_lhs)
+    LOG ("normalization forces negation of LHS");
+  LOGITEGATE (INVALID_GATE_ID, closure->repr, INVALID_LIT, lits[0], lits[1],
+              lits[2], "normalized");
+#endif
+  *negate_lhs_ptr = negate_lhs;
+  const unsigned hash = hash_lits (closure, ITE_GATE, arity, lits);
+  gate *g = find_gate (closure, ITE_GATE, hash, arity, lits, except);
+  *hash_ptr = hash;
+  if (g) {
+    CLOGITEGATE (g, "found matching");
+    INC (congruent_matched_ites);
+  } else
+    LOGITEGATE (INVALID_GATE_ID, closure->repr, INVALID_LIT, lits[0],
+                lits[1], lits[2], "tried but did not find matching");
+  return g;
+}
+
+static gate *find_ite_gate (closure *closure, unsigned *h,
+                            bool *negate_lhs_ptr, gate *g) {
+  return find_ite_lits (closure, h, negate_lhs_ptr, g->arity, g->rhs, g);
+}
+
+static gate *new_ite_gate (closure *closure, unsigned lhs, unsigned cond,
+                           unsigned then_lit, unsigned else_lit) {
+  kissat *const solver = closure->solver;
+  const unsigned not_then_lit = NOT (then_lit);
+  if (else_lit == not_then_lit) {
+#ifdef LOGGING
+    if (NEGATED (then_lit))
+      LOG ("skipping ternary XOR gate %s := %s ^ %s", LOGLIT (lhs),
+           LOGLIT (cond), LOGLIT (not_then_lit));
+    else
+      LOG ("skipping ternary XOR gate %s := %s ^ %s", LOGLIT (NOT (lhs)),
+           LOGLIT (cond), LOGLIT (then_lit));
+#endif
+    return 0;
+  }
+  if (else_lit == then_lit) {
+    LOG ("found trivial ITE gate %s := %s ? %s : %s", LOGLIT (lhs),
+         LOGLIT (cond), LOGLIT (then_lit), LOGLIT (else_lit));
+    if (merge_literals (closure, lhs, then_lit))
+      INC (congruent_trivial_ite);
+    return 0;
+  }
+  unsigneds *rhs_stack = &closure->rhs;
+  CLEAR_STACK (*rhs_stack);
+  PUSH_STACK (*rhs_stack, cond);
+  PUSH_STACK (*rhs_stack, then_lit);
+  PUSH_STACK (*rhs_stack, else_lit);
+  KISSAT_assert (SIZE_STACK (*rhs_stack) == 3);
+  const unsigned arity = 3;
+  unsigned *rhs_lits = BEGIN_STACK (*rhs_stack);
+  bool negate_lhs;
+  unsigned hash;
+  gate *g = find_ite_lits (closure, &hash, &negate_lhs, arity, rhs_lits, 0);
+  if (g) {
+    if (negate_lhs)
+      lhs = NOT (lhs);
+    add_ite_matching_proof_chain (closure, g, g->lhs, lhs);
+    if (merge_literals (closure, g->lhs, lhs))
+      INC (congruent_ites);
+    if (!solver->inconsistent)
+      delete_proof_chain (closure);
+    return 0;
+  }
+  if (negate_lhs)
+    lhs = NOT (lhs);
+  g = new_gate (closure, ITE_GATE, hash, lhs, arity, rhs_lits);
+  check_ite_gate_implied (closure, g);
+  INC (congruent_gates_ites);
+  return g;
+}
+
+static void mark_gate_as_garbage (closure *closure, gate *g) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!g->garbage);
+  g->garbage = true;
+  LOGATE (g, "marked as garbage");
+  PUSH_STACK (closure->garbage, g);
+}
+
+static void shrink_gate (closure *closure, gate *g,
+                         const unsigned *new_end_rhs) {
+  unsigned *const rhs = g->rhs;
+  const unsigned old_arity = g->arity;
+  unsigned *const old_end_rhs = rhs + old_arity;
+  KISSAT_assert (rhs <= new_end_rhs);
+  KISSAT_assert (new_end_rhs <= old_end_rhs);
+  if (new_end_rhs == old_end_rhs)
+    return;
+  const unsigned new_arity = new_end_rhs - rhs;
+  if (!g->shrunken) {
+    KISSAT_assert (old_end_rhs[-1] != INVALID_LIT);
+    old_end_rhs[-1] = INVALID_LIT;
+    g->shrunken = true;
+  }
+  g->arity = new_arity;
+#ifdef LOGGING
+  kissat *const solver = closure->solver;
+  LOGATE (g, "shrunken");
+#else
+  (void) closure;
+#endif
+}
+
+static bool skip_and_gate (closure *closure, gate *g) {
+  KISSAT_assert (g->tag == AND_GATE);
+  if (g->garbage)
+    return true;
+  kissat *const solver = closure->solver;
+  const value *const values = solver->values;
+  const unsigned lhs = g->lhs;
+  const value value_lhs = values[lhs];
+  if (value_lhs > 0) {
+    mark_gate_as_garbage (closure, g);
+    return true;
+  }
+  KISSAT_assert (g->arity > 1);
+  return false;
+}
+
+static bool gate_contains (gate *g, unsigned lit) {
+  for (all_rhs_literals_in_gate (other, g))
+    if (lit == other)
+      return true;
+  return false;
+}
+
+static bool rewriting_lhs (closure *closure, gate *g, unsigned dst) {
+#ifndef KISSAT_NDEBUG
+  kissat *const solver = closure->solver;
+#endif
+  if (dst != g->lhs && dst != NOT (g->lhs))
+    return false;
+  mark_gate_as_garbage (closure, g);
+  return true;
+}
+
+static void shrink_and_gate (closure *closure, gate *g,
+                             unsigned *new_end_rhs, unsigned falsifies,
+                             unsigned clashing) {
+  KISSAT_assert (g->tag == AND_GATE);
+#ifndef KISSAT_NDEBUG
+  kissat *const solver = closure->solver;
+#endif
+  if (falsifies != INVALID_LIT) {
+    KISSAT_assert (g->arity);
+    g->rhs[0] = falsifies;
+    new_end_rhs = g->rhs + 1;
+  } else if (clashing != INVALID_LIT) {
+    KISSAT_assert (1 < g->arity);
+    g->rhs[0] = clashing;
+    g->rhs[1] = NOT (clashing);
+    new_end_rhs = g->rhs + 2;
+  }
+  shrink_gate (closure, g, new_end_rhs);
+}
+
+static void update_and_gate (closure *closure, gate *g, unsigned falsifies,
+                             unsigned clashing) {
+  KISSAT_assert (g->tag == AND_GATE);
+  bool garbage = true;
+  kissat *const solver = closure->solver;
+  if (falsifies != INVALID_LIT || clashing != INVALID_LIT)
+    (void) learn_congruence_unit (closure, NOT (g->lhs));
+  else if (g->arity == 1) {
+    const value value_lhs = VALUE (g->lhs);
+    if (value_lhs > 0)
+      (void) learn_congruence_unit (closure, g->rhs[0]);
+    else if (value_lhs < 0)
+      (void) learn_congruence_unit (closure, NOT (g->rhs[0]));
+    else if (merge_literals (closure, g->lhs, g->rhs[0])) {
+      INC (congruent_unary_ands);
+      INC (congruent_unary);
+    }
+  } else {
+    unsigned hash;
+    gate *h = find_and_gate (closure, &hash, g);
+    if (h) {
+      KISSAT_assert (garbage);
+      if (merge_literals (closure, g->lhs, h->lhs))
+        INC (congruent_ands);
+    } else {
+      remove_gate (closure, g);
+      g->hash = hash;
+      index_gate (closure, g);
+      garbage = false;
+    }
+  }
+  if (garbage && !solver->inconsistent)
+    mark_gate_as_garbage (closure, g);
+}
+
+static void simplify_and_gate (closure *closure, gate *g) {
+  if (skip_and_gate (closure, g))
+    return;
+  kissat *const solver = closure->solver;
+  const value *const values = solver->values;
+  CLOGANDGATE (g, "simplifying");
+  const unsigned old_arity = g->arity;
+  unsigned *const rhs = g->rhs;
+  unsigned *const end_of_rhs = rhs + old_arity;
+  const unsigned *p = rhs;
+  unsigned *q = rhs;
+  unsigned falsifies = INVALID_LIT;
+  while (p != end_of_rhs) {
+    const unsigned lit = *p++;
+    const value value = values[lit];
+    if (value > 0)
+      continue;
+    if (value < 0) {
+      LOG ("found falsifying literal %s", LOGLIT (lit));
+      falsifies = lit;
+      continue;
+    }
+    *q++ = lit;
+  }
+  shrink_and_gate (closure, g, q, falsifies, INVALID_LIT);
+  CLOGANDGATE (g, "simplified");
+  check_and_gate_implied (closure, g);
+  update_and_gate (closure, g, falsifies, INVALID_LIT);
+  INC (congruent_simplified);
+  INC (congruent_simplified_ands);
+}
+
+static void rewrite_and_gate (closure *closure, gate *g, unsigned dst,
+                              unsigned src) {
+  if (skip_and_gate (closure, g))
+    return;
+  if (!gate_contains (g, src))
+    return;
+  KISSAT_assert (src != INVALID_LIT);
+  KISSAT_assert (dst != INVALID_LIT);
+  kissat *const solver = closure->solver;
+  const value *const values = solver->values;
+  KISSAT_assert (values[src] == values[dst]);
+  CLOGANDGATE (g, "rewriting %s by %s in", CLOGREPR (src), CLOGREPR (dst));
+  const unsigned old_arity = g->arity;
+  const unsigned not_lhs = NOT (g->lhs);
+  unsigned *const rhs = g->rhs;
+  unsigned *const end_of_rhs = rhs + old_arity;
+  const unsigned *p = rhs;
+  unsigned *q = rhs;
+  unsigned falsifies = INVALID_LIT;
+  unsigned clashing = INVALID_LIT;
+  const unsigned not_dst = NOT (dst);
+  unsigned dst_count = 0, not_dst_count = 0;
+  while (p != end_of_rhs) {
+    unsigned lit = *p++;
+    if (lit == src)
+      lit = dst;
+    if (lit == not_lhs) {
+      LOG ("found negated LHS literal %s", LOGLIT (lit));
+      clashing = lit;
+      break;
+    }
+    const value value = values[lit];
+    if (value > 0)
+      continue;
+    if (value < 0) {
+      LOG ("found falsifying literal %s", LOGLIT (lit));
+      falsifies = lit;
+      break;
+    }
+    if (lit == dst) {
+      if (not_dst_count) {
+        LOG ("clashing literals %s and %s", LOGLIT (not_dst), LOGLIT (dst));
+        clashing = not_dst;
+        break;
+      }
+      if (dst_count++)
+        continue;
+    }
+    if (lit == not_dst) {
+      if (dst_count) {
+        KISSAT_assert (!not_dst_count);
+        LOG ("clashing literals %s and %s", LOGLIT (dst), LOGLIT (not_dst));
+        clashing = dst;
+        break;
+      }
+      KISSAT_assert (!not_dst_count);
+      not_dst_count++;
+    }
+    *q++ = lit;
+  }
+  KISSAT_assert (dst_count <= 2);
+  KISSAT_assert (not_dst_count <= 1);
+  shrink_and_gate (closure, g, q, falsifies, clashing);
+  CLOGANDGATE (g, "rewritten");
+  check_and_gate_implied (closure, g);
+  update_and_gate (closure, g, falsifies, clashing);
+  INC (congruent_rewritten);
+  INC (congruent_rewritten_ands);
+}
+
+static bool skip_xor_gate (gate *g) {
+  KISSAT_assert (g->tag == XOR_GATE);
+  if (g->garbage)
+    return true;
+  KISSAT_assert (g->arity > 1);
+  return false;
+}
+
+#ifdef CHECKING_OR_PROVING
+
+static void add_xor_shrinking_proof_chain (closure *closure, gate *g,
+                                           unsigned pivot) {
+  kissat *const solver = closure->solver;
+  if (!kissat_checking_or_proving (solver))
+    return;
+  LOG ("starting XOR shrinking proof chain");
+  unsigneds *clause = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*clause));
+  for (unsigned i = 0; i != g->arity; i++) {
+    unsigned lit = g->rhs[i];
+    PUSH_STACK (*clause, lit);
+  }
+  const unsigned lhs = g->lhs;
+  const unsigned not_lhs = NOT (lhs);
+  PUSH_STACK (*clause, not_lhs);
+  const unsigned parity = NEGATED (not_lhs);
+  KISSAT_assert (parity == parity_lits (solver, clause));
+  const unsigned not_pivot = NOT (pivot);
+  const size_t size = SIZE_STACK (*clause);
+  KISSAT_assert (size < 32);
+  const unsigned end = 1u << size;
+  for (unsigned i = 0; i != end; i++) {
+    while (i && parity != parity_lits (solver, clause))
+      inc_lits (solver, clause);
+    PUSH_STACK (*clause, pivot);
+    CHECK_AND_ADD_STACK (*clause);
+    ADD_STACK_TO_PROOF (*clause);
+    clause->end--;
+    PUSH_STACK (*clause, not_pivot);
+    CHECK_AND_ADD_STACK (*clause);
+    ADD_STACK_TO_PROOF (*clause);
+    clause->end--;
+    CHECK_AND_ADD_STACK (*clause);
+    ADD_STACK_TO_PROOF (*clause);
+    PUSH_STACK (*clause, pivot);
+    REMOVE_CHECKER_STACK (*clause);
+    DELETE_STACK_FROM_PROOF (*clause);
+    clause->end--;
+    PUSH_STACK (*clause, not_pivot);
+    REMOVE_CHECKER_STACK (*clause);
+    DELETE_STACK_FROM_PROOF (*clause);
+    clause->end--;
+    inc_lits (solver, clause);
+  }
+  CLEAR_STACK (*clause);
+  LOG ("finished XOR shrinking proof chain");
+}
+
+#else
+
+#define add_xor_shrinking_proof_chain(...) \
+  do { \
+  } while (0)
+#endif
+
+static void shrink_xor_gate (closure *closure, gate *g,
+                             unsigned *new_end_rhs) {
+  KISSAT_assert (g->tag == XOR_GATE);
+  shrink_gate (closure, g, new_end_rhs);
+}
+
+static void update_xor_gate (closure *closure, gate *g) {
+  KISSAT_assert (g->tag == XOR_GATE);
+  kissat *const solver = closure->solver;
+  bool garbage = true;
+  if (g->arity == 0)
+    (void) learn_congruence_unit (closure, NOT (g->lhs));
+  else if (g->arity == 1) {
+    const value value_lhs = VALUE (g->lhs);
+    if (value_lhs > 0)
+      (void) learn_congruence_unit (closure, g->rhs[0]);
+    else if (value_lhs < 0)
+      (void) learn_congruence_unit (closure, NOT (g->rhs[0]));
+    else if (merge_literals (closure, g->lhs, g->rhs[0])) {
+      INC (congruent_unary_xors);
+      INC (congruent_unary);
+    }
+  } else {
+    KISSAT_assert (g->arity > 1);
+    unsigned hash;
+    gate *h = find_xor_gate (closure, &hash, g);
+    if (h) {
+      KISSAT_assert (garbage);
+      add_xor_matching_proof_chain (closure, g, g->lhs, h->lhs);
+      if (merge_literals (closure, g->lhs, h->lhs))
+        INC (congruent_xors);
+      if (!solver->inconsistent)
+        delete_proof_chain (closure);
+    } else {
+      remove_gate (closure, g);
+      g->hash = hash;
+      index_gate (closure, g);
+      garbage = false;
+    }
+  }
+  if (garbage && !solver->inconsistent)
+    mark_gate_as_garbage (closure, g);
+}
+
+static void simplify_xor_gate (closure *closure, gate *g) {
+  if (skip_xor_gate (g))
+    return;
+  kissat *const solver = closure->solver;
+  const value *const values = solver->values;
+  CLOGXORGATE (g, "simplifying");
+  unsigned *q = g->rhs, *const end_of_rhs = q + g->arity;
+  unsigned negate = 0;
+  for (const unsigned *p = q; p != end_of_rhs; p++) {
+    const unsigned lit = *p;
+    KISSAT_assert (!NEGATED (lit));
+    const value value = values[lit];
+    if (value > 0)
+      negate ^= 1;
+    if (!value)
+      *q++ = lit;
+  }
+  if (negate) {
+    LOG ("flipping LHS literal %s", LOGLIT (g->lhs));
+    g->lhs = NOT (g->lhs);
+  }
+  shrink_xor_gate (closure, g, q);
+  update_xor_gate (closure, g);
+  CLOGXORGATE (g, "simplified");
+  check_xor_gate_implied (closure, g);
+  INC (congruent_simplified);
+  INC (congruent_simplified_xors);
+}
+
+static void rewrite_xor_gate (closure *closure, gate *g, unsigned dst,
+                              unsigned src) {
+  if (skip_xor_gate (g))
+    return;
+  if (rewriting_lhs (closure, g, dst))
+    return;
+  if (!gate_contains (g, src))
+    return;
+  kissat *const solver = closure->solver;
+  CLOGXORGATE (g, "rewriting %s by %s in", CLOGREPR (src), CLOGREPR (dst));
+  const value *const values = solver->values;
+  unsigned *q = g->rhs, *end_of_rhs = q + g->arity;
+  unsigned original_dst_negated = NEGATED (dst);
+  unsigned negate = original_dst_negated;
+  unsigned dst_count = 0;
+  dst = STRIP (dst);
+  for (const unsigned *p = q; p != end_of_rhs; p++) {
+    unsigned lit = *p;
+    KISSAT_assert (!NEGATED (lit));
+    if (lit == src)
+      lit = dst;
+    const value value = values[lit];
+    if (value > 0)
+      negate ^= 1;
+    if (value)
+      continue;
+    if (lit == dst)
+      dst_count++;
+    *q++ = lit;
+  }
+  if (negate) {
+    LOG ("flipping LHS literal %s", LOGLIT (g->lhs));
+    g->lhs = NOT (g->lhs);
+  }
+  KISSAT_assert (dst_count <= 2);
+  if (dst_count == 2) {
+    CLOGXORGATE (g, "literals %s and %s were both in", LOGLIT (src),
+                 LOGLIT (dst));
+    end_of_rhs = q;
+    q = g->rhs;
+    for (const unsigned *p = q; p != end_of_rhs; p++) {
+      const unsigned lit = *p;
+      if (lit != dst)
+        *q++ = lit;
+    }
+    KISSAT_assert (q + 2 == end_of_rhs);
+  }
+  shrink_xor_gate (closure, g, q);
+  CLOGXORGATE (g, "rewritten");
+  if (dst_count > 1)
+    add_xor_shrinking_proof_chain (closure, g, src);
+  update_xor_gate (closure, g);
+  if (!g->garbage && !solver->inconsistent && original_dst_negated &&
+      dst_count == 1) {
+    KISSAT_assert (!NEGATED (dst));
+    connect_occurrence (closure, dst, g);
+  }
+  check_xor_gate_implied (closure, g);
+  INC (congruent_rewritten);
+  INC (congruent_rewritten_xors);
+}
+
+static bool skip_ite_gate (gate *g) {
+  KISSAT_assert (g->tag == ITE_GATE);
+  if (g->garbage)
+    return true;
+  return false;
+}
+
+static void simplify_ite_gate (closure *closure, gate *g) {
+  if (skip_ite_gate (g))
+    return;
+  kissat *const solver = closure->solver;
+  const value *const values = solver->values;
+  CLOGITEGATE (g, "simplifying");
+  KISSAT_assert (g->arity == 3);
+  bool garbage = true;
+  const unsigned lhs = g->lhs;
+  unsigned *const rhs = g->rhs;
+  const unsigned cond = rhs[0];
+  const unsigned then_lit = rhs[1];
+  const unsigned else_lit = rhs[2];
+  const value cond_value = values[cond];
+  if (cond_value > 0) {
+    if (merge_literals (closure, lhs, then_lit)) {
+      INC (congruent_unary_ites);
+      INC (congruent_unary);
+    }
+  } else if (cond_value < 0) {
+    if (merge_literals (closure, lhs, else_lit)) {
+      INC (congruent_unary_ites);
+      INC (congruent_unary);
+    }
+  } else {
+    const value then_value = values[then_lit];
+    const value else_value = values[else_lit];
+    const unsigned not_lhs = NOT (lhs);
+    KISSAT_assert (then_value || else_value);
+    if (then_value > 0 && else_value > 0)
+      learn_congruence_unit (closure, lhs);
+    else if (then_value < 0 && else_value < 0)
+      learn_congruence_unit (closure, not_lhs);
+    else if (then_value > 0 && else_value < 0) {
+      if (merge_literals (closure, lhs, cond)) {
+        INC (congruent_unary_ites);
+        INC (congruent_unary);
+      }
+    } else if (then_value < 0 && else_value > 0) {
+      const unsigned not_cond = NOT (cond);
+      if (merge_literals (closure, lhs, not_cond)) {
+        INC (congruent_unary_ites);
+        INC (congruent_unary);
+      }
+    } else {
+      KISSAT_assert (!!else_value + !!then_value == 1);
+      if (then_value > 0) {
+        KISSAT_assert (!else_value);
+        g->lhs = not_lhs;
+        rhs[0] = NOT (cond);
+        rhs[1] = NOT (else_lit);
+      } else if (then_value < 0) {
+        KISSAT_assert (!else_value);
+        rhs[0] = NOT (cond);
+        rhs[1] = else_lit;
+      } else if (else_value > 0) {
+        KISSAT_assert (!then_value);
+        g->lhs = not_lhs;
+        rhs[0] = NOT (then_lit);
+        rhs[1] = cond;
+      } else {
+        KISSAT_assert (else_value < 0);
+        KISSAT_assert (!then_value);
+        rhs[0] = cond;
+        rhs[1] = then_lit;
+      }
+      if (rhs[0] > rhs[1])
+        SWAP (unsigned, rhs[0], rhs[1]);
+      KISSAT_assert (!g->shrunken);
+      g->shrunken = true;
+      rhs[2] = INVALID_LIT;
+      g->arity = 2;
+      g->tag = AND_GATE;
+      KISSAT_assert (rhs[0] < rhs[1]);
+      KISSAT_assert (rhs[0] != NOT (rhs[1]));
+      CLOGANDGATE (g, "simplified");
+      check_and_gate_implied (closure, g);
+      unsigned hash;
+      gate *h = find_and_gate (closure, &hash, g);
+      if (h) {
+        KISSAT_assert (garbage);
+        if (merge_literals (closure, g->lhs, h->lhs))
+          INC (congruent_ands);
+      } else {
+        remove_gate (closure, g);
+        g->hash = hash;
+        index_gate (closure, g);
+        garbage = false;
+        for (all_rhs_literals_in_gate (lit, g))
+          if (lit != cond && lit != then_lit && lit != else_lit)
+            connect_occurrence (closure, lit, g);
+      }
+    }
+  }
+  if (garbage && !solver->inconsistent)
+    mark_gate_as_garbage (closure, g);
+  INC (congruent_simplified);
+  INC (congruent_simplified_ites);
+}
+
+static void rewrite_ite_gate (closure *closure, gate *g, unsigned dst,
+                              unsigned src) {
+  if (skip_ite_gate (g))
+    return;
+  if (!gate_contains (g, src))
+    return;
+  kissat *const solver = closure->solver;
+  CLOGITEGATE (g, "rewriting %s by %s in", CLOGREPR (src), CLOGREPR (dst));
+  unsigned *const rhs = g->rhs;
+  KISSAT_assert (g->arity == 3);
+  const unsigned lhs = g->lhs;
+  const unsigned cond = rhs[0];
+  const unsigned then_lit = rhs[1];
+  const unsigned else_lit = rhs[2];
+  const unsigned not_lhs = NOT (lhs);
+  const unsigned not_dst = NOT (dst);
+  const unsigned not_cond = NOT (cond);
+  const unsigned not_then_lit = NOT (then_lit);
+  const unsigned not_else_lit = NOT (else_lit);
+  unsigned new_tag = AND_GATE;
+  bool garbage = false;
+  bool shrink = true;
+  if (src == cond) {
+    if (dst == then_lit) {
+      // then_lit ? then_lit : else_lit
+      // then_lit & then_lit | !then_lit & else_lit
+      // then_lit | !then_lit & else_lit
+      // then_lit | else_lit
+      // !(!then_lit & !else_lit)
+      g->lhs = not_lhs;
+      rhs[0] = not_then_lit;
+      rhs[1] = not_else_lit;
+    } else if (not_dst == then_lit) {
+      // !then_lit ? then_lit : else_lit
+      // !then_lit & then_lit | then_lit & else_lit
+      // then_lit & else_lit
+      rhs[0] = else_lit;
+      KISSAT_assert (rhs[1] == then_lit);
+    } else if (dst == else_lit) {
+      // else_list ? then_lit : else_lit
+      // else_list & then_lit | !else_list & else_lit
+      // else_list & then_lit
+      rhs[0] = else_lit;
+      KISSAT_assert (rhs[1] == then_lit);
+    } else if (not_dst == else_lit) {
+      // !else_list ? then_lit : else_lit
+      // !else_list & then_lit | else_lit & else_lit
+      // !else_list & then_lit | else_lit
+      // then_lit | else_lit
+      // !(!then_lit & !else_lit)
+      g->lhs = not_lhs;
+      rhs[0] = not_then_lit;
+      rhs[1] = not_else_lit;
+    } else {
+      shrink = false;
+      rhs[0] = dst;
+    }
+  } else if (src == then_lit) {
+    if (dst == cond) {
+      // cond ? cond : else_lit
+      // cond & cond | !cond & else_lit
+      // cond | !cond & else_lit
+      // cond | else_lit
+      // !(!cond & !else_lit)
+      g->lhs = not_lhs;
+      rhs[0] = not_cond;
+      rhs[1] = not_else_lit;
+    } else if (not_dst == cond) {
+      // cond ? !cond : else_lit
+      // cond & !cond | !cond & else_lit
+      // !cond & else_lit
+      rhs[0] = not_cond;
+      rhs[1] = else_lit;
+    } else if (dst == else_lit) {
+      // cond ? else_lit : else_lit
+      // else_lit
+      if (merge_literals (closure, lhs, else_lit)) {
+        INC (congruent_unary_ites);
+        INC (congruent_unary);
+      }
+      garbage = true;
+    } else if (not_dst == else_lit) {
+      // cond ? !else_lit : else_lit
+      // cond & !else_lit | !cond & else_lit
+      // cond ^ else_lit
+      new_tag = XOR_GATE;
+      KISSAT_assert (rhs[0] == cond);
+      rhs[1] = else_lit;
+    } else {
+      shrink = false;
+      rhs[1] = dst;
+    }
+  } else {
+    KISSAT_assert (src == else_lit);
+    if (dst == cond) {
+      // cond ? then_lit : cond
+      // cond & then_lit | !cond & cond
+      // cond & then_lit
+      KISSAT_assert (rhs[0] == cond);
+      KISSAT_assert (rhs[1] == then_lit);
+    } else if (not_dst == cond) {
+      // cond ? then_lit : !cond
+      // cond & then_lit | !cond & !cond
+      // cond & then_lit | !cond
+      // then_lit | !cond
+      // !(!then_lit & cond)
+      g->lhs = not_lhs;
+      KISSAT_assert (rhs[0] == cond);
+      rhs[1] = not_then_lit;
+    } else if (dst == then_lit) {
+      // cond ? then_lit : then_lit
+      // then_lit
+      if (merge_literals (closure, lhs, then_lit)) {
+        INC (congruent_unary_ites);
+        INC (congruent_unary);
+      }
+      garbage = true;
+    } else if (not_dst == then_lit) {
+      // cond ? then_lit : !then_lit
+      // cond & then_lit | !cond & !then_lit
+      // !(cond ^ then_lit)
+      new_tag = XOR_GATE;
+      g->lhs = not_lhs;
+      KISSAT_assert (rhs[0] == cond);
+      KISSAT_assert (rhs[1] == then_lit);
+    } else {
+      shrink = false;
+      rhs[2] = dst;
+    }
+  }
+  if (!garbage) {
+    if (shrink) {
+      if (rhs[0] > rhs[1])
+        SWAP (unsigned, rhs[0], rhs[1]);
+      if (new_tag == XOR_GATE) {
+        bool negate_lhs = false;
+        if (NEGATED (rhs[0])) {
+          rhs[0] = NOT (rhs[0]);
+          negate_lhs = !negate_lhs;
+        }
+        if (NEGATED (rhs[1])) {
+          rhs[1] = NOT (rhs[1]);
+          negate_lhs = !negate_lhs;
+        }
+        if (negate_lhs)
+          g->lhs = NOT (g->lhs);
+      }
+      KISSAT_assert (!g->shrunken);
+      g->shrunken = true;
+      rhs[2] = INVALID_LIT;
+      g->arity = 2;
+      g->tag = new_tag;
+      KISSAT_assert (rhs[0] < rhs[1]);
+      KISSAT_assert (rhs[0] != NOT (rhs[1]));
+      LOGATE (g, "rewritten");
+      gate *h;
+      unsigned hash;
+      if (new_tag == AND_GATE) {
+        check_and_gate_implied (closure, g);
+        h = find_and_gate (closure, &hash, g);
+      } else {
+        KISSAT_assert (new_tag == XOR_GATE);
+        check_xor_gate_implied (closure, g);
+        h = find_xor_gate (closure, &hash, g);
+      }
+      if (h) {
+        garbage = true;
+        if (new_tag == XOR_GATE)
+          add_xor_matching_proof_chain (closure, g, g->lhs, h->lhs);
+        else
+          add_ite_turned_and_binary_clauses (closure, g);
+        if (merge_literals (closure, g->lhs, h->lhs))
+          INC (congruent_ands);
+        if (!solver->inconsistent)
+          delete_proof_chain (closure);
+      } else {
+        garbage = false;
+        remove_gate (closure, g);
+        g->hash = hash;
+        index_gate (closure, g);
+        KISSAT_assert (g->arity == 2);
+        for (all_rhs_literals_in_gate (lit, g))
+          if (lit != dst)
+            if (lit != cond && lit != then_lit && lit != else_lit)
+              connect_occurrence (closure, lit, g);
+        if (g->tag == AND_GATE)
+          for (all_rhs_literals_in_gate (lit, g))
+            add_binary_clause (closure, NOT (g->lhs), lit);
+      }
+    } else {
+      CLOGITEGATE (g, "rewritten");
+      KISSAT_assert (rhs[0] != rhs[1]);
+      KISSAT_assert (rhs[0] != rhs[2]);
+      KISSAT_assert (rhs[1] != rhs[2]);
+      KISSAT_assert (rhs[0] != NOT (rhs[1]));
+      KISSAT_assert (rhs[0] != NOT (rhs[2]));
+      KISSAT_assert (rhs[1] != NOT (rhs[2]));
+      check_ite_gate_implied (closure, g);
+      unsigned hash;
+      bool negate_lhs;
+      gate *h = find_ite_gate (closure, &hash, &negate_lhs, g);
+      KISSAT_assert (lhs == g->lhs);
+      KISSAT_assert (not_lhs == NOT (g->lhs));
+      if (h) {
+        garbage = true;
+        unsigned normalized_lhs = negate_lhs ? not_lhs : lhs;
+        add_ite_matching_proof_chain (closure, h, h->lhs, normalized_lhs);
+        if (merge_literals (closure, h->lhs, normalized_lhs))
+          INC (congruent_ites);
+        if (!solver->inconsistent)
+          delete_proof_chain (closure);
+      } else {
+        garbage = false;
+        remove_gate (closure, g);
+        if (negate_lhs)
+          g->lhs = not_lhs;
+        CLOGITEGATE (g, "normalized");
+        g->hash = hash;
+        index_gate (closure, g);
+        KISSAT_assert (g->arity == 3);
+        for (all_rhs_literals_in_gate (lit, g))
+          if (lit != dst)
+            if (lit != cond && lit != then_lit && lit != else_lit)
+              connect_occurrence (closure, lit, g);
+      }
+    }
+  }
+  if (garbage && !solver->inconsistent)
+    mark_gate_as_garbage (closure, g);
+  INC (congruent_rewritten);
+  INC (congruent_rewritten_ites);
+}
+
+static bool simplify_gate (closure *closure, gate *g) {
+  if (g->tag == AND_GATE)
+    simplify_and_gate (closure, g);
+  else if (g->tag == XOR_GATE)
+    simplify_xor_gate (closure, g);
+  else
+    simplify_ite_gate (closure, g);
+  return !closure->solver->inconsistent;
+}
+
+static bool rewrite_gate (closure *closure, gate *g, unsigned dst,
+                          unsigned src) {
+  if (g->tag == AND_GATE)
+    rewrite_and_gate (closure, g, dst, src);
+  else if (g->tag == XOR_GATE)
+    rewrite_xor_gate (closure, g, dst, src);
+  else
+    rewrite_ite_gate (closure, g, dst, src);
+  return !closure->solver->inconsistent;
+}
+
+struct offsetsize {
+  unsigned offset, size;
+};
+
+typedef struct offsetsize offsetsize;
+
+#define RANK_OTHER(A) ((A).lits[1])
+#define LESS_OTHER(A, B) (RANK_OTHER (A) < RANK_OTHER (B))
+
+static bool find_binary (kissat *solver, litpair *binaries,
+                         offsetsize *offsetsize, unsigned lit,
+                         unsigned other) {
+  KISSAT_assert (lit != other);
+  if (lit > other)
+    SWAP (unsigned, lit, other);
+  size_t l = offsetsize[lit].offset;
+  size_t r = l + offsetsize[lit].size;
+  while (l < r) {
+    const size_t m = (l + r) / 2;
+    const unsigned tmp = binaries[m].lits[1];
+    if (tmp < other)
+      l = m + 1;
+    else if (tmp > other)
+      r = m;
+    else {
+      KISSAT_assert (binaries[m].lits[0] == lit);
+      KISSAT_assert (binaries[m].lits[1] == other);
+#ifdef LOGGING
+      LOGBINARY (lit, other, "found");
+#else
+      (void) solver;
+#endif
+      return true;
+    }
+  }
+  return false;
+}
+
+static uint64_t rank_litpair (litpair p) {
+  uint64_t res = p.lits[0];
+  res <<= 32;
+  res += p.lits[1];
+  return res;
+}
+
+static void extract_binaries (closure *closure) {
+  kissat *const solver = closure->solver;
+  if (!GET_OPTION (congruencebinaries))
+    return;
+  START (extractbinaries);
+  litpair *binaries = BEGIN_STACK (closure->binaries);
+  offsetsize *offsetsize;
+  CALLOC (struct offsetsize, offsetsize, LITS);
+  {
+    litpair *end = END_STACK (closure->binaries);
+    litpair *p = binaries;
+    while (p != end) {
+      litpair *q = p + 1;
+      const unsigned lit = p->lits[0];
+      while (q != end && q->lits[0] == lit)
+        q++;
+      const size_t size = q - p;
+      KISSAT_assert (size), KISSAT_assert (size <= UINT_MAX);
+      const size_t offset = p - binaries;
+      if (size < 32)
+        SORT (litpair, size, p, LESS_OTHER);
+      else
+        RADIX_SORT (litpair, unsigned, size, p, RANK_OTHER);
+      offsetsize[lit].offset = offset;
+      offsetsize[lit].size = size;
+      p = q;
+    }
+  }
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+  const size_t before = SIZE_STACK (closure->binaries);
+  size_t extracted = 0, duplicated = 0;
+  const value *const values = solver->values;
+  for (all_clauses (d)) {
+    if (d->garbage)
+      continue;
+    if (last_irredundant && last_irredundant < d)
+      break;
+    if (d->redundant)
+      continue;
+    if (d->size != 3)
+      continue;
+    const unsigned *lits = d->lits;
+    const unsigned a = lits[0];
+    if (values[a])
+      continue;
+    const unsigned b = lits[1];
+    if (values[b])
+      continue;
+    const unsigned c = lits[2];
+    if (values[c])
+      continue;
+    const unsigned not_a = NOT (a);
+    const unsigned not_b = NOT (b);
+    const unsigned not_c = NOT (c);
+    unsigned l = INVALID_LIT, k = INVALID_LIT;
+    if (find_binary (solver, binaries, offsetsize, not_a, b) ||
+        find_binary (solver, binaries, offsetsize, not_a, c))
+      l = b, k = c;
+    else if (find_binary (solver, binaries, offsetsize, not_b, a) ||
+             find_binary (solver, binaries, offsetsize, not_b, c))
+      l = a, k = c;
+    else if (find_binary (solver, binaries, offsetsize, not_c, a) ||
+             find_binary (solver, binaries, offsetsize, not_c, b))
+      l = a, k = b;
+    else
+      continue;
+    LOGCLS (d, "strengthening");
+    if (!find_binary (solver, binaries, offsetsize, l, k)) {
+      LOGBINARY (l, k, "strengthened");
+      add_binary_clause (closure, l, k);
+      binaries = BEGIN_STACK (closure->binaries);
+      extracted++;
+    }
+  }
+  DEALLOC (offsetsize, LITS);
+  {
+    litpair *end = END_STACK (closure->binaries);
+    litpair *added = binaries + before;
+#ifndef KISSAT_NDEBUG
+    const size_t after = end - binaries;
+    KISSAT_assert (after - before == extracted);
+#endif
+    RADIX_SORT (litpair, uint64_t, extracted, added, rank_litpair);
+    litpair *q = added;
+    unsigned prev_lit = INVALID_LIT;
+    unsigned prev_other = INVALID_LIT;
+    for (const litpair *p = q; p != end; p++) {
+      const litpair pair = *p;
+      const unsigned lit = pair.lits[0];
+      const unsigned other = pair.lits[1];
+      if (p == added || lit != prev_lit || other != prev_other) {
+        q->lits[0] = lit;
+        q->lits[1] = other;
+        prev_lit = lit;
+        prev_other = other;
+        q++;
+      } else {
+        duplicated++;
+        LOGBINARY (lit, other, "removing duplicated");
+        kissat_delete_binary (solver, lit, other);
+      }
+    }
+    SET_END_OF_STACK (closure->binaries, q);
+  }
+  ADD (congruent_binaries, extracted - duplicated);
+  kissat_verbose (solver, "extracted %zu binaries (plus %zu duplicated)",
+                  extracted, duplicated);
+  STOP (extractbinaries);
+}
+
+#ifndef INDEX_BINARY_CLAUSES
+
+static gate *find_first_and_gate (closure *closure, unsigned lhs,
+                                  unsigneds *lits) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->watching);
+  mark *const marks = solver->marks;
+
+  const unsigned not_lhs = NOT (lhs);
+  LOG ("trying to find AND gate with first LHS %s", LOGLIT (lhs));
+  LOG ("negated LHS %s occurs in %u binary clauses", LOGLIT (not_lhs),
+       closure->negbincount[lhs]);
+
+  unsigneds *const marked = &solver->analyzed;
+  KISSAT_assert (EMPTY_STACK (*marked));
+
+  const unsigned arity = SIZE_STACK (*lits) - 1;
+  unsigned matched = 0;
+  KISSAT_assert (1 < arity);
+
+  watches *watches = &WATCHES (not_lhs);
+  const watch *const end = END_WATCHES (*watches);
+  const watch *p = BEGIN_WATCHES (*watches);
+
+  while (p != end) {
+    const watch watch = *p++;
+    KISSAT_assert (watch.type.binary);
+    const unsigned other = watch.binary.lit;
+    const mark tmp = marks[other];
+    if (tmp) {
+      matched++;
+      KISSAT_assert (~(tmp & 2));
+      marks[other] |= 2;
+      PUSH_STACK (*marked, other);
+    }
+  }
+
+  LOG ("found %zu initial LHS candidates", SIZE_STACK (*marked));
+  if (matched < arity)
+    return 0;
+
+  return new_and_gate (closure, lhs);
+}
+
+static gate *find_remaining_and_gate (closure *closure, unsigned lhs,
+                                      unsigneds *lits) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->watching);
+  mark *const marks = solver->marks;
+  const unsigned not_lhs = NOT (lhs);
+
+  if (marks[not_lhs] < 2) {
+    LOG ("skipping no-candidate LHS %s", LOGLIT (lhs));
+    return NULL;
+  }
+
+  LOG ("trying to find AND gate with remaining LHS %s", LOGLIT (lhs));
+  LOG ("negated LHS %s occurs times in %u binary clauses", LOGLIT (not_lhs),
+       closure->negbincount[lhs]);
+
+  const unsigned arity = SIZE_STACK (*lits) - 1;
+  unsigned matched = 0;
+  KISSAT_assert (1 < arity);
+
+  {
+    watches *watches = &WATCHES (not_lhs);
+    const watch *const end_watches = END_WATCHES (*watches);
+    const watch *p = BEGIN_WATCHES (*watches);
+    while (p != end_watches) {
+      const watch watch = *p++;
+      KISSAT_assert (watch.type.binary);
+      const unsigned other = watch.binary.lit;
+      mark mark = marks[other];
+      if (!mark)
+        continue;
+      matched++;
+      if (!(mark & 2))
+        continue;
+      KISSAT_assert (!(mark & 4));
+      marks[other] = mark | 4;
+    }
+  }
+
+  {
+    unsigneds *const marked = &solver->analyzed;
+    KISSAT_assert (!EMPTY_STACK (*marked));
+    unsigned *const begin_marked = BEGIN_STACK (*marked);
+    const unsigned *const end_marked = END_STACK (*marked);
+    unsigned *q = begin_marked;
+    const unsigned *p = q;
+    KISSAT_assert (marks[not_lhs] == 3);
+    while (p != end_marked) {
+      const unsigned lit = *p++;
+      if (lit == not_lhs) {
+        marks[not_lhs] = 1;
+        continue;
+      }
+      mark mark = marks[lit];
+      KISSAT_assert ((mark & 3) == 3);
+      if (mark & 4) {
+        mark = 3;
+        *q++ = lit;
+        LOG2 ("keeping LHS candidate %s", LOGLIT (NOT (lit)));
+      } else {
+        LOG2 ("dropping LHS candidate %s", LOGLIT (NOT (lit)));
+        mark = 1;
+      }
+      marks[lit] = mark;
+    }
+    KISSAT_assert (q != end_marked);
+    KISSAT_assert (marks[not_lhs] == 1);
+    SET_END_OF_STACK (*marked, q);
+    LOG ("after filtering %zu LHS candidates remain", SIZE_STACK (*marked));
+  }
+
+  if (matched < arity)
+    return 0;
+
+  return new_and_gate (closure, lhs);
+}
+
+#endif
+
+static inline bool smaller_negated_bin_count (const unsigned *negbincount,
+                                              unsigned a, unsigned b) {
+  unsigned c = negbincount[a];
+  unsigned d = negbincount[b];
+  if (c < d)
+    return true;
+  if (c > d)
+    return false;
+  return a < b;
+}
+
+#define SMALLER_NEGATED_BIN_COUNT(A, B) \
+  smaller_negated_bin_count (negbincount, A, B)
+
+static void sort_lits_by_negbincount (closure *closure, size_t size,
+                                      unsigned *lits) {
+  const unsigned *const negbincount = closure->negbincount;
+  kissat *const solver = closure->solver;
+  SORT (unsigned, size, lits, SMALLER_NEGATED_BIN_COUNT);
+}
+
+#ifdef INDEX_BINARY_CLAUSES
+
+static unsigned hash_binary (closure *closure, binary_clause *binary) {
+  return hash_lits (closure, 0, 2, binary->lits);
+}
+
+static bool indexed_binary (closure *closure, unsigned lit,
+                            unsigned other) {
+  KISSAT_assert (lit != other);
+#ifdef LOGGING
+  kissat *const solver = closure->solver;
+#endif
+  binary_hash_table *bintab = &closure->bintab;
+  if (!bintab->count) {
+    LOG ("did not find binary %s %s", LOGLIT (lit), LOGLIT (other));
+    return false;
+  }
+  KISSAT_assert (bintab->size);
+  SWAP (unsigned, lit, other);
+  if (lit > other)
+    SWAP (unsigned, lit, other);
+  binary_clause binary = {.lits = {lit, other}};
+  const unsigned hash = hash_binary (closure, &binary);
+  const size_t size = bintab->size;
+  const size_t size2 = bintab->size2;
+  size_t pos = reduce_hash (hash, size, size2);
+  binary_clause *table = bintab->table;
+  unsigned lit0, lit1;
+  while ((lit1 = table[pos].lits[1])) {
+    if (lit1 == other) {
+      lit0 = table[pos].lits[0];
+      KISSAT_assert (lit0 < other);
+      if (lit0 == lit) {
+        LOG ("found binary %s %s", LOGLIT (lit), LOGLIT (other));
+        return true;
+      }
+    }
+    if (++pos == size)
+      pos = 0;
+  }
+  LOG ("did not find binary %s %s", LOGLIT (lit), LOGLIT (other));
+  return false;
+}
+
+#endif
+
+static void extract_and_gates_with_base_clause (closure *closure,
+                                                clause *c) {
+  KISSAT_assert (!c->garbage);
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  value *values = solver->values;
+  unsigned arity_limit = MIN (GET_OPTION (congruenceandarity), MAX_ARITY);
+  const unsigned size_limit = arity_limit + 1;
+  const unsigned *const negbincount = closure->negbincount;
+  unsigneds *lits = &closure->lits;
+  unsigned size = 0, max_negbincount = 0;
+  CLEAR_STACK (*lits);
+  for (all_literals_in_clause (lit, c)) {
+    value value = values[lit];
+    if (value < 0)
+      continue;
+    if (value > 0) {
+      KISSAT_assert (!solver->level);
+      LOGCLS (c, "found satisfied %s in", LOGLIT (lit));
+      kissat_mark_clause_as_garbage (solver, c);
+      return;
+    }
+    if (++size > size_limit) {
+      LOGCLS (c, "too large actual size %u thus skipping", size);
+      return;
+    }
+    const unsigned count = negbincount[lit];
+    if (!count) {
+      LOGCLS (c,
+              "%s negated does not occur in any binary clause "
+              "thus skipping",
+              LOGLIT (lit));
+      return;
+    }
+    if (count > max_negbincount)
+      max_negbincount = count;
+    PUSH_STACK (*lits, lit);
+  }
+  if (size < 3) {
+    LOGCLS (c, "actual size %u too small thus skipping", size);
+    return;
+  }
+  const unsigned arity = size - 1;
+  if (max_negbincount < arity) {
+    LOGCLS (c,
+            "all literals have less than %u negated occurrences "
+            "thus skipping",
+            arity);
+    return;
+  }
+  unsigned *begin_lits = BEGIN_STACK (*lits), *reduced_lits = begin_lits;
+  LOGCOUNTEDLITS (size, begin_lits, negbincount,
+                  "counted candidate arity %u AND gate base clause", arity);
+  const unsigned *const end_lits = END_STACK (*lits);
+#ifndef INDEX_BINARY_CLAUSES
+  mark *const marks = solver->marks;
+  unsigneds *marked = &solver->analyzed;
+  KISSAT_assert (EMPTY_STACK (*marked));
+#endif
+  for (unsigned *p = begin_lits; p != end_lits; p++) {
+    const unsigned lit = *p, count = negbincount[lit];
+#ifndef INDEX_BINARY_CLAUSES
+    const unsigned not_lit = NOT (lit);
+    marks[not_lit] = 1;
+#endif
+    if (count < arity) {
+      if (reduced_lits < p)
+        *p = *reduced_lits, *reduced_lits++ = lit;
+      else if (reduced_lits == p)
+        reduced_lits++;
+    }
+  }
+  KISSAT_assert (reduced_lits < end_lits);
+  const size_t reduced_size = end_lits - reduced_lits;
+  KISSAT_assert (reduced_size);
+  LOGCLS (c, "trying as base arity %u AND gate", arity);
+  sort_lits_by_negbincount (closure, reduced_size, reduced_lits);
+#ifdef LOGGING
+  if (begin_lits < reduced_lits) {
+    LOGCOUNTEDLITS (reduced_lits - begin_lits, begin_lits, negbincount,
+                    "skipping low occurrence");
+    LOGCOUNTEDLITS (reduced_size, reduced_lits, negbincount,
+                    "remaining LHS candidate");
+  } else
+    LOGCOUNTEDLITS (reduced_size, reduced_lits, negbincount,
+                    "all remain LHS candidate");
+#endif
+#ifdef LOGGING
+  unsigned extracted = 0;
+#endif
+#ifndef INDEX_BINARY_CLAUSES
+  bool first = true;
+#endif
+  for (unsigned *p = reduced_lits; p != end_lits; p++) {
+    if (solver->inconsistent)
+      break;
+    if (c->garbage)
+      break;
+    const unsigned lhs = *p;
+    LOG ("trying LHS candidate literal %s with %u negated occurrences",
+         LOGLIT (lhs), negbincount[lhs]);
+    KISSAT_assert (arity <= negbincount[lhs]);
+#ifdef INDEX_BINARY_CLAUSES
+    const unsigned not_lhs = NOT (lhs);
+    for (const unsigned *q = begin_lits; q != end_lits; q++)
+      if (p != q) {
+        const unsigned rhs = *q, not_rhs = NOT (rhs);
+        if (!indexed_binary (closure, not_lhs, not_rhs))
+          goto CONTINUE_WITH_NEXT_LHS;
+      }
+    (void) new_and_gate (closure, lhs);
+#ifdef LOGGING
+    extracted++;
+#endif
+  CONTINUE_WITH_NEXT_LHS:;
+#else
+    if (first) {
+      first = false;
+      KISSAT_assert (EMPTY_STACK (*marked));
+      if (find_first_and_gate (closure, lhs, lits)) {
+#ifdef LOGGING
+        extracted++;
+#endif
+      }
+    } else if (EMPTY_STACK (*marked)) {
+      LOG ("early abort AND gate search");
+      break;
+    } else if (find_remaining_and_gate (closure, lhs, lits)) {
+#ifdef LOGGING
+      extracted++;
+#endif
+    }
+#endif
+  }
+#ifndef INDEX_BINARY_CLAUSES
+  for (const unsigned *p = begin_lits; p != end_lits; p++) {
+    const unsigned lit = *p, not_lit = NOT (lit);
+    marks[not_lit] = 0;
+  }
+  CLEAR_STACK (*marked);
+#endif
+#ifdef LOGGING
+  if (extracted)
+    LOGCLS (c, "extracted %u with arity %u AND base", extracted, arity);
+#endif
+}
+
+#ifdef INDEX_LARGE_CLAUSES
+
+static bool valid_large_clause (hash_ref *clause) {
+  return clause->hash || clause->ref;
+}
+
+static clause *find_indexed_large_clause (closure *closure,
+                                          unsigneds *lits) {
+  kissat *const solver = closure->solver;
+  size_t size_lits = SIZE_STACK (*lits);
+  KISSAT_assert (size_lits > 2);
+#ifdef LOGGING
+  {
+    unsigned *begin = BEGIN_STACK (*lits);
+    unsigned arity = size_lits - 1;
+    LOGCOUNTEDLITS (size_lits, begin, closure->largecount,
+                    "trying to find arity %u XOR side clause", arity);
+  }
+#endif
+  large_clause_hash_table *clauses = &closure->clauses;
+  if (!clauses->count)
+    return 0;
+  const value *const values = solver->values;
+  mark *const marks = solver->marks;
+  unsigneds *sorted = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*sorted));
+  for (all_stack (unsigned, lit, *lits)) {
+    KISSAT_assert (!values[lit]);
+    PUSH_STACK (*sorted, lit);
+    marks[lit] = 1;
+  }
+  KISSAT_assert (size_lits == SIZE_STACK (*sorted));
+  unsigned *begin_sorted = BEGIN_STACK (*sorted);
+  sort_lits (solver, size_lits, begin_sorted);
+  const unsigned hash = hash_lits (closure, 0, size_lits, begin_sorted);
+  const size_t hash_size = clauses->size;
+  const size_t hash_size2 = clauses->size2;
+  size_t pos = reduce_hash (hash, hash_size, hash_size2);
+  hash_ref *table = clauses->table, *hash_ref;
+  clause *res = 0;
+  while (valid_large_clause (hash_ref = table + pos)) {
+    if (hash_ref->hash == hash) {
+      reference ref = hash_ref->ref;
+      if (ref == INVALID_REF) {
+        KISSAT_assert (!hash);
+        ref = 0;
+      }
+      clause *c = kissat_dereference_clause (solver, ref);
+      for (all_literals_in_clause (other, c))
+        if (!values[other] && !marks[other])
+          goto CONTINUE_WITH_NEXT_HASH_BUCKET;
+      res = c;
+      break;
+    }
+  CONTINUE_WITH_NEXT_HASH_BUCKET:
+    if (++pos == hash_size)
+      pos = 0;
+  }
+  while (!EMPTY_STACK (*sorted)) {
+    const unsigned lit = POP_STACK (*sorted);
+    marks[lit] = 0;
+  }
+  if (res)
+    LOGCLS (res, "found indexed matching XOR side clause");
+  else
+    LOG ("no matching XOR side clause found");
+  return res;
+}
+
+#else
+
+static clause *find_large_xor_side_clause (closure *closure,
+                                           unsigneds *lits) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->watching);
+  const unsigned *const largecount = closure->largecount;
+  unsigned least_occurring_literal = INVALID_LIT;
+  unsigned count_least_occurring = UINT_MAX;
+  mark *marks = solver->marks;
+  const size_t size_lits = SIZE_STACK (*lits);
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  const unsigned arity = size_lits - 1;
+#endif
+#ifndef KISSAT_NDEBUG
+  const unsigned count_limit = 1u << (arity - 1);
+#endif
+  const value *const values = solver->values;
+  LOGCOUNTEDLITS (size_lits, BEGIN_STACK (*lits), largecount,
+                  "trying to find arity %u XOR side clause", arity);
+  for (all_stack (unsigned, lit, *lits)) {
+    KISSAT_assert (!values[lit]);
+    marks[lit] = 1;
+    unsigned count = largecount[lit];
+    KISSAT_assert (count_limit <= count);
+    if (count >= count_least_occurring)
+      continue;
+    count_least_occurring = count;
+    least_occurring_literal = lit;
+  }
+  clause *res = 0;
+  KISSAT_assert (least_occurring_literal != INVALID_LIT);
+  LOG ("searching XOR side clause watched by %s#%u",
+       LOGLIT (least_occurring_literal), count_least_occurring);
+  watches *const watches = &WATCHES (least_occurring_literal);
+  watch *p = BEGIN_WATCHES (*watches);
+  const watch *const end = END_WATCHES (*watches);
+  while (p != end) {
+    const watch watch = *p++;
+    if (watch.type.binary)
+      break;
+    const reference ref = watch.large.ref;
+    clause *const c = kissat_dereference_clause (solver, ref);
+    if (c->garbage)
+      continue;
+    if (c->size < size_lits)
+      continue;
+    size_t found = 0;
+    for (all_literals_in_clause (other, c)) {
+      const value value = values[other];
+      if (value < 0)
+        continue;
+      if (value > 0) {
+        LOGCLS (c, "found satisfied %s in", LOGLIT (other));
+        kissat_mark_clause_as_garbage (solver, c);
+        KISSAT_assert (c->garbage);
+        break;
+      }
+      if (marks[other])
+        found++;
+      else {
+        found = UINT_MAX;
+        break;
+      }
+    }
+    if (found < UINT_MAX && !c->garbage) {
+      res = c;
+      break;
+    }
+  }
+  for (all_stack (unsigned, lit, *lits))
+    marks[lit] = 0;
+  if (res)
+    LOGCLS (res, "found matching XOR side");
+  else
+    LOG ("no matching XOR side clause found");
+  return res;
+}
+
+#endif
+
+static void extract_xor_gates_with_base_clause (closure *closure,
+                                                clause *c) {
+  KISSAT_assert (!c->garbage);
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  const value *const values = solver->values;
+  unsigned smallest = INVALID_LIT, largest = INVALID_LIT;
+  const unsigned arity_limit =
+      MIN (GET_OPTION (congruencexorarity), MAX_ARITY);
+  const unsigned size_limit = arity_limit + 1;
+  unsigned negated = 0, size = 0;
+  unsigneds *lits = &closure->lits;
+  CLEAR_STACK (*lits);
+  bool first = true;
+  for (all_literals_in_clause (lit, c)) {
+    const value value = values[lit];
+    if (value < 0)
+      continue;
+    if (value > 0) {
+      LOGCLS (c, "found satisfied %s in", LOGLIT (lit));
+      kissat_mark_clause_as_garbage (solver, c);
+      return;
+    }
+    if (size == size_limit) {
+      LOGCLS (c, "size limit %u for XOR base clause exceeded in",
+              size_limit);
+      return;
+    }
+    if (first) {
+      largest = smallest = lit;
+      first = false;
+    } else {
+      KISSAT_assert (smallest != INVALID_LIT);
+      KISSAT_assert (largest != INVALID_LIT);
+      if (lit < smallest)
+        smallest = lit;
+      if (lit > largest) {
+        if (NEGATED (largest)) {
+          LOGCLS (c, "not largest literal %s occurs negated in XOR base",
+                  LOGLIT (largest));
+          return;
+        }
+        largest = lit;
+      }
+    }
+    if (NEGATED (lit) && lit < largest) {
+      LOGCLS (c, "negated literal %s not largest in XOR base",
+              LOGLIT (lit));
+      return;
+    }
+    if (NEGATED (lit) && negated++) {
+      LOGCLS (c, "more than one negated literal in XOR base");
+      return;
+    }
+    PUSH_STACK (*lits, lit);
+    size++;
+  }
+  KISSAT_assert (size == SIZE_STACK (*lits));
+  if (size < 3) {
+    LOGCLS (c, "short XOR base clause");
+    return;
+  }
+  const unsigned arity = size - 1;
+  const unsigned needed_clauses = 1u << (arity - 1);
+  const unsigned *const largecount = closure->largecount;
+  for (all_stack (unsigned, lit, *lits))
+    for (unsigned sign = 0; sign != 2; sign++, lit = NOT (lit)) {
+      unsigned count = largecount[lit];
+      if (count >= needed_clauses)
+        continue;
+      LOGCLS (c,
+              "literal %s in XOR base clause only occurs "
+              "%u times in large clauses thus skipping",
+              LOGLIT (lit), count);
+      return;
+    }
+  LOGCLS (c, "trying arity %u XOR base", arity);
+  KISSAT_assert (smallest != INVALID_LIT);
+  KISSAT_assert (largest != INVALID_LIT);
+  const unsigned end = 1u << arity;
+  KISSAT_assert (negated == parity_lits (solver, lits));
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+  unsigned found = 0;
+#endif
+  for (unsigned i = 0; i != end; i++) {
+    while (i && parity_lits (solver, lits) != negated)
+      inc_lits (solver, lits);
+    if (i) {
+#ifdef INDEX_LARGE_CLAUSES
+      clause *d = find_indexed_large_clause (closure, lits);
+#else
+      clause *d = find_large_xor_side_clause (closure, lits);
+#endif
+      if (!d)
+        return;
+      KISSAT_assert (!d->redundant);
+    } else
+      KISSAT_assert (!c->redundant);
+    inc_lits (solver, lits);
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+    found++;
+#endif
+  }
+  while (parity_lits (solver, lits) != negated)
+    inc_lits (solver, lits);
+  LOGUNSIGNEDS2 (size, BEGIN_STACK (*lits), "back to original");
+  LOG ("found all needed %u matching clauses:", found);
+  KISSAT_assert (found == 1u << arity);
+  if (negated) {
+    unsigned *p = BEGIN_STACK (*lits), lit;
+    while (!NEGATED (lit = *p))
+      p++;
+    LOG ("flipping RHS literal %s", LOGLIT (lit));
+    *p = NOT (lit);
+  }
+  unsigned extracted = 0;
+  for (all_stack (unsigned, lhs, *lits)) {
+    if (!negated)
+      lhs = NOT (lhs);
+    gate *g = new_xor_gate (closure, lhs);
+    if (g)
+      extracted++;
+    if (solver->inconsistent)
+      break;
+  }
+  if (!extracted)
+    LOG ("no arity %u XOR gate extracted", arity);
+}
+
+#ifdef INDEX_BINARY_CLAUSES
+
+static void init_bintab (closure *closure) {
+  kissat *const solver = closure->solver;
+  size_t limit = BINARY_CLAUSES;
+  size_t size = 2 * limit;
+  size_t size2 = 1;
+  while (size > size2)
+    size2 *= 2;
+  KISSAT_assert (!limit || size2 <= 2 * size);
+  binary_hash_table *bintab = &closure->bintab;
+  CALLOC (binary_hash_table, bintab->table, size);
+  bintab->count = 0;
+  bintab->size = size;
+  bintab->size2 = size2;
+  kissat_very_verbose (
+      solver, "allocated binary clause hash table of size %zu", size);
+}
+
+#ifndef KISSAT_NDEBUG
+
+static bool binaries_hash_table_is_full (binary_hash_table *bintab) {
+  if (bintab->size == MAX_HASH_TABLE_SIZE)
+    return false;
+  if (2 * bintab->count < bintab->size)
+    return false;
+  return true;
+}
+
+#endif
+
+static void index_binary (closure *closure, unsigned lit, unsigned other) {
+  KISSAT_assert (lit < other);
+  binary_hash_table *bintab = &closure->bintab;
+  KISSAT_assert (!binaries_hash_table_is_full (bintab));
+  binary_clause binary = {.lits = {lit, other}};
+  const unsigned hash = hash_binary (closure, &binary);
+  const size_t size = bintab->size;
+  const size_t size2 = bintab->size2;
+  size_t pos = reduce_hash (hash, size, size2);
+  binary_clause *table = bintab->table;
+  while (table[pos].lits[1])
+    if (++pos == size)
+      pos = 0;
+  table[pos] = binary;
+  bintab->count++;
+#ifdef LOGGING
+  kissat *const solver = closure->solver;
+  LOG ("indexed binary %s %s", LOGLIT (lit), LOGLIT (other));
+#endif
+}
+
+static void reset_bintab (closure *closure) {
+  kissat *const solver = closure->solver;
+  binary_hash_table *bintab = &closure->bintab;
+  DEALLOC (bintab->table, bintab->size);
+}
+
+#endif
+
+static void init_and_gate_extraction (closure *closure) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->watching);
+  unsigned *negbincount;
+  CALLOC (unsigned, negbincount, LITS);
+  litpairs *binaries = &closure->binaries;
+#ifdef INDEX_BINARY_CLAUSES
+  init_bintab (closure);
+#endif
+  for (all_stack (litpair, pair, *binaries)) {
+    const unsigned lit = pair.lits[0], other = pair.lits[1];
+    const unsigned not_lit = NOT (lit), not_other = NOT (other);
+    negbincount[not_lit]++, negbincount[not_other]++;
+    kissat_watch_binary (solver, lit, other);
+#ifdef INDEX_BINARY_CLAUSES
+    index_binary (closure, lit, other);
+#endif
+  }
+#ifndef KISSAT_QUIET
+  size_t connected = SIZE_STACK (*binaries);
+  kissat_very_verbose (solver, "connected %zu binary clauses", connected);
+#endif
+  closure->negbincount = negbincount;
+}
+
+static void reset_and_gate_extraction (closure *closure) {
+  kissat *const solver = closure->solver;
+  DEALLOC (closure->negbincount, LITS);
+  kissat_flush_all_connected (solver);
+#ifdef INDEX_BINARY_CLAUSES
+  reset_bintab (closure);
+#endif
+}
+
+#ifdef INDEX_LARGE_CLAUSES
+
+static void init_large_clauses (closure *closure, size_t expected) {
+  kissat *const solver = closure->solver;
+  size_t size = 2 * expected;
+  size_t size2 = 1;
+  while (size > size2)
+    size2 *= 2;
+  KISSAT_assert (!expected || size2 <= 2 * size);
+  large_clause_hash_table *clauses = &closure->clauses;
+  CALLOC (large_clause_hash_table, clauses->table, size);
+  clauses->count = 0;
+  clauses->size = size;
+  clauses->size2 = size2;
+  kissat_very_verbose (
+      solver, "allocated large clause hash table of size %zu", size);
+}
+
+#ifndef KISSAT_NDEBUG
+
+static bool large_clause_hash_table_is_full (closure *closure) {
+  if (closure->clauses.size == MAX_HASH_TABLE_SIZE)
+    return false;
+  if (2 * closure->clauses.count < closure->clauses.size)
+    return false;
+  return true;
+}
+
+#endif
+
+static void index_large_clause (closure *closure, reference ref) {
+  KISSAT_assert (!large_clause_hash_table_is_full (closure));
+  kissat *const solver = closure->solver;
+  clause *c = kissat_dereference_clause (solver, ref);
+  const value *const values = solver->values;
+  unsigneds *lits = &closure->lits;
+  CLEAR_STACK (*lits);
+  for (all_literals_in_clause (lit, c))
+    if (!values[lit])
+      PUSH_STACK (*lits, lit);
+  const size_t size_lits = SIZE_STACK (*lits);
+  unsigned *begin_lits = BEGIN_STACK (*lits);
+  KISSAT_assert (3 <= size_lits);
+  sort_lits (solver, size_lits, begin_lits);
+  const unsigned hash = hash_lits (closure, 0, size_lits, begin_lits);
+  large_clause_hash_table *clauses = &closure->clauses;
+  if (!hash && !ref) {
+    ref = INVALID_REF;
+    KISSAT_assert (ref);
+  }
+  const size_t hash_size = clauses->size;
+  const size_t hash_size2 = clauses->size2;
+  size_t pos = reduce_hash (hash, hash_size, hash_size2);
+  hash_ref *table = clauses->table, *clause;
+  while (valid_large_clause (clause = table + pos))
+    if (++pos == hash_size)
+      pos = 0;
+  clause->hash = hash;
+  clause->ref = ref;
+  KISSAT_assert (valid_large_clause (clause));
+  clauses->count++;
+  LOGCLS (c, "indexed");
+}
+
+static void reset_large_clauses (closure *closure) {
+  large_clause_hash_table *clauses = &closure->clauses;
+  kissat *const solver = closure->solver;
+  DEALLOC (clauses->table, clauses->size);
+}
+
+#endif
+
+static void init_xor_gate_extraction (closure *closure,
+                                      references *candidates) {
+  KISSAT_assert (EMPTY_STACK (*candidates));
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->watching);
+  const unsigned arity_limit = GET_OPTION (congruencexorarity);
+  const unsigned size_limit = arity_limit + 1;
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+  const value *const values = solver->values;
+  unsigned *largecount;
+  CALLOC (unsigned, largecount, LITS);
+  for (all_clauses (c)) {
+    if (c->garbage)
+      continue;
+    if (last_irredundant && last_irredundant < c)
+      break;
+    if (c->redundant)
+      continue;
+    unsigned size = 0;
+    int continue_counting_next_clause = 0;
+    for (all_literals_in_clause (lit, c)) {
+      const value value = values[lit];
+      if (value < 0)
+        continue;
+      if (value > 0) {
+        LOGCLS (c, "satisfied %s in", LOGLIT (lit));
+        kissat_mark_clause_as_garbage (solver, c);
+        continue_counting_next_clause = 1;
+        break;
+      }
+      if (size == size_limit) {
+        continue_counting_next_clause = 1;
+        break;
+      }
+      size++;
+    }
+    if(continue_counting_next_clause) {
+      continue;
+    }
+    if (size < 3)
+      continue;
+    for (all_literals_in_clause (lit, c))
+      if (!values[lit])
+        largecount[lit]++;
+    reference ref = kissat_reference_clause (solver, c);
+    PUSH_STACK (*candidates, ref);
+  }
+#ifndef KISSAT_QUIET
+  size_t considered_clauses = IRREDUNDANT_CLAUSES;
+  size_t original_candidates = SIZE_STACK (*candidates);
+  kissat_very_verbose (
+      solver,
+      "%zu original candidate XOR base clauses "
+      "(%.0f%% of %zu irredundant clauses)",
+      original_candidates,
+      kissat_percent (original_candidates, considered_clauses),
+      considered_clauses);
+#endif
+  const unsigned counting_rounds = GET_OPTION (congruencexorcounts);
+  for (unsigned round = 1; round <= counting_rounds; round++) {
+    size_t removed = 0;
+    unsigned *new_largecount;
+    CALLOC (unsigned, new_largecount, LITS);
+    const reference *const end_candidates = END_STACK (*candidates);
+    reference *q = BEGIN_STACK (*candidates), *p = q;
+    while (p != end_candidates) {
+      const reference ref = *p++;
+      clause *c = kissat_dereference_clause (solver, ref);
+      unsigned size = 0;
+      for (all_literals_in_clause (lit, c))
+        if (!values[lit])
+          size++;
+      KISSAT_assert (3 <= size);
+      KISSAT_assert (size <= size_limit);
+      const unsigned arity = size - 1;
+      const unsigned needed_clauses = 1u << (arity - 1);
+      for (all_literals_in_clause (lit, c))
+        if (largecount[lit] < needed_clauses) {
+          removed++;
+          goto CONTINUE_WITH_NEXT_CANDIDATE_CLAUSE;
+        }
+      for (all_literals_in_clause (lit, c))
+        if (!values[lit])
+          new_largecount[lit]++;
+      *q++ = ref;
+    CONTINUE_WITH_NEXT_CANDIDATE_CLAUSE:;
+    }
+    DEALLOC (largecount, LITS);
+    largecount = new_largecount;
+    SET_END_OF_STACK (*candidates, q);
+    if (!removed)
+      break;
+#ifndef KISSAT_QUIET
+    size_t remaining_candidates = SIZE_STACK (*candidates);
+    const char *how_often;
+    char buffer[64];
+    if (round == 1)
+      how_often = "once";
+    else if (round == 2)
+      how_often = "twice";
+    else {
+      sprintf (buffer, "%u times", round);
+      how_often = buffer;
+    }
+    kissat_very_verbose (
+        solver,
+        "%zu XOR base clause candidates remain (%.0f%% "
+        "original candidates)"
+        " after counting %s",
+        remaining_candidates,
+        kissat_percent (remaining_candidates, original_candidates),
+        how_often);
+#endif
+  }
+  closure->largecount = largecount;
+#ifdef INDEX_LARGE_CLAUSES
+  init_large_clauses (closure, SIZE_STACK (*candidates));
+#endif
+  for (all_stack (reference, ref, *candidates)) {
+    kissat_connect_referenced (solver, ref);
+#ifdef INDEX_LARGE_CLAUSES
+    index_large_clause (closure, ref);
+#endif
+  }
+#ifndef KISSAT_QUIET
+  size_t connected = SIZE_STACK (*candidates);
+  kissat_very_verbose (solver, "connected %zu large clauses %.0f%%",
+                       connected,
+                       kissat_percent (connected, IRREDUNDANT_CLAUSES));
+#endif
+}
+
+static void reset_xor_gate_extraction (closure *closure) {
+  kissat *const solver = closure->solver;
+  DEALLOC (closure->largecount, LITS);
+  kissat_flush_all_connected (solver);
+#ifdef INDEX_LARGE_CLAUSES
+  reset_large_clauses (closure);
+#endif
+}
+
+static void init_ite_gate_extraction (closure *closure,
+                                      references *candidates) {
+  KISSAT_assert (EMPTY_STACK (*candidates));
+  kissat *const solver = closure->solver;
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+  const value *const values = solver->values;
+  unsigned *largecount;
+  CALLOC (unsigned, largecount, LITS);
+  references ternary;
+  INIT_STACK (ternary);
+  for (all_clauses (c)) {
+    if (c->garbage)
+      continue;
+    if (last_irredundant && last_irredundant < c)
+      break;
+    if (c->redundant)
+      continue;
+    unsigned size = 0;
+    int continue_counting_next_clause = 0;
+    for (all_literals_in_clause (lit, c)) {
+      const value value = values[lit];
+      if (value < 0)
+        continue;
+      if (value > 0) {
+        LOGCLS (c, "satisfied %s in", LOGLIT (lit));
+        kissat_mark_clause_as_garbage (solver, c);
+        continue_counting_next_clause = 1;
+        break;
+      }
+      if (size == 3) {
+        continue_counting_next_clause = 1;
+        break;
+      }
+      size++;
+    }
+    if(continue_counting_next_clause) {
+      continue;
+    }
+    if (size < 3)
+      continue;
+    KISSAT_assert (size == 3);
+    const reference ref = kissat_reference_clause (solver, c);
+    PUSH_STACK (ternary, ref);
+    LOGCLS (c, "counting original ITE gate base");
+    for (all_literals_in_clause (lit, c))
+      if (!values[lit])
+        largecount[lit]++;
+  }
+#ifndef KISSAT_QUIET
+  size_t counted = SIZE_STACK (ternary);
+  kissat_very_verbose (solver,
+                       "counted %zu ternary ITE clauses "
+                       "(%.0f%% of %" PRIu64 " irredundant clauses)",
+                       counted,
+                       kissat_percent (counted, IRREDUNDANT_CLAUSES),
+                       IRREDUNDANT_CLAUSES);
+  size_t connected = 0;
+#endif
+  for (all_stack (reference, ref, ternary)) {
+    clause *c = kissat_dereference_clause (solver, ref);
+    KISSAT_assert (!c->garbage);
+    unsigned positive = 0, negative = 0, twice = 0;
+    for (all_literals_in_clause (lit, c)) {
+      if (values[lit])
+        continue;
+      const unsigned not_lit = NOT (lit);
+      const unsigned count_not_lit = largecount[not_lit];
+      if (!count_not_lit)
+        goto CONTINUE_WITH_NEXT_TERNARY_CLAUSE;
+      const unsigned count_lit = largecount[lit];
+      KISSAT_assert (count_lit);
+      if (count_lit > 1 && count_not_lit > 1)
+        twice++;
+      if (NEGATED (lit))
+        negative++;
+      else
+        positive++;
+    }
+    if (twice < 2)
+      goto CONTINUE_WITH_NEXT_TERNARY_CLAUSE;
+#ifndef KISSAT_QUIET
+    connected++;
+#endif
+    kissat_connect_clause (solver, c);
+    if (positive && negative)
+      PUSH_STACK (*candidates, ref);
+  CONTINUE_WITH_NEXT_TERNARY_CLAUSE:;
+  }
+  RELEASE_STACK (ternary);
+#ifndef KISSAT_QUIET
+  kissat_very_verbose (solver,
+                       "connected %zu ITE clauses "
+                       "(%.0f%% of %" PRIu64 " counted clauses)",
+                       connected, kissat_percent (connected, counted),
+                       IRREDUNDANT_CLAUSES);
+  size_t size_candidates = SIZE_STACK (*candidates);
+  kissat_very_verbose (solver,
+                       "%zu candidates ITE base clauses "
+                       "(%.0f%% of %zu connected)",
+                       size_candidates,
+                       kissat_percent (size_candidates, connected),
+                       connected);
+#endif
+  closure->largecount = largecount;
+  INIT_STACK (closure->condbin[0]);
+  INIT_STACK (closure->condbin[1]);
+  INIT_STACK (closure->condeq[0]);
+  INIT_STACK (closure->condeq[1]);
+}
+
+static void reset_ite_gate_extraction (closure *closure) {
+  kissat *const solver = closure->solver;
+  RELEASE_STACK (closure->condbin[0]);
+  RELEASE_STACK (closure->condbin[1]);
+  RELEASE_STACK (closure->condeq[0]);
+  RELEASE_STACK (closure->condeq[1]);
+  DEALLOC (closure->largecount, LITS);
+  kissat_flush_all_connected (solver);
+}
+
+static void unmark_all (unsigneds *marked, signed char *marks) {
+  for (all_stack (unsigned, lit, *marked))
+    marks[lit] = 0;
+  CLEAR_STACK (*marked);
+}
+
+#ifdef MERGE_CONDITIONAL_EQUIVALENCES
+
+static void copy_conditional_equivalences (kissat *solver, unsigned lit,
+                                           watches *watches,
+                                           litpairs *condbin) {
+  KISSAT_assert (EMPTY_STACK (*condbin));
+  const value *const values = solver->values;
+  const watch *const begin_watches = BEGIN_WATCHES (*watches);
+  const watch *const end_watches = END_WATCHES (*watches);
+  for (const watch *p = begin_watches; p != end_watches; p++) {
+    const watch watch = *p;
+    if (watch.type.binary)
+      break;
+    const unsigned ref = watch.large.ref;
+    clause *c = kissat_dereference_clause (solver, ref);
+    unsigned first = INVALID_LIT, second = INVALID_LIT;
+    for (all_literals_in_clause (other, c)) {
+      if (values[other])
+        continue;
+      if (other == lit)
+        continue;
+      if (first == INVALID_LIT)
+        first = other;
+      else {
+        KISSAT_assert (second == INVALID_LIT);
+        second = other;
+      }
+    }
+    KISSAT_assert (first != INVALID_LIT);
+    KISSAT_assert (second != INVALID_LIT);
+    litpair pair;
+    if (first < second)
+      pair = (litpair){.lits = {first, second}};
+    else {
+      KISSAT_assert (second < first);
+      pair = (litpair){.lits = {second, first}};
+    }
+    LOG ("literal %s conditional binary clause %s %s", LOGLIT (lit),
+         LOGLIT (first), LOGLIT (second));
+    PUSH_STACK (*condbin, pair);
+  }
+}
+
+static bool less_litpair (litpair p, litpair q) {
+  const unsigned a = p.lits[0], b = q.lits[0];
+  if (a < b)
+    return true;
+  if (a > b)
+    return false;
+  const unsigned c = p.lits[1], d = q.lits[1];
+  return c < d;
+}
+
+#define RADIDX_SORT_PAIR_LIMIT 32
+
+static void sort_pairs (kissat *solver, litpairs *pairs) {
+  const size_t size = SIZE_STACK (*pairs);
+  if (size < 32)
+    SORT_STACK (litpair, *pairs, less_litpair);
+  else
+    for (int i = 1; i >= 0; i--)
+      RADIX_STACK (litpair, uint64_t, *pairs, rank_litpair);
+}
+
+static bool find_litpair_second_literal (unsigned lit, const litpair *begin,
+                                         const litpair *end) {
+  const litpair *l = begin, *r = end;
+  while (l != r) {
+    const litpair *m = l + (r - l) / 2;
+    KISSAT_assert (begin <= m), KISSAT_assert (m < end);
+    unsigned other = m->lits[1];
+    if (other < lit)
+      l = m + 1;
+    else if (other > lit)
+      r = m;
+    else
+      return true;
+  }
+  return false;
+}
+
+static void search_condeq (closure *closure, unsigned lit, unsigned pos_lit,
+                           const litpair *pos_begin, const litpair *pos_end,
+                           unsigned neg_lit, const litpair *neg_begin,
+                           const litpair *neg_end, litpairs *condeq) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (neg_lit == NOT (pos_lit));
+  KISSAT_assert (pos_begin < pos_end);
+  KISSAT_assert (neg_begin < neg_end);
+  KISSAT_assert (pos_begin->lits[0] == pos_lit);
+  KISSAT_assert (neg_begin->lits[0] == neg_lit);
+  KISSAT_assert (pos_end <= neg_begin || neg_end <= pos_begin);
+  for (const litpair *p = pos_begin; p != pos_end; p++) {
+    const unsigned other = p->lits[1];
+    const unsigned not_other = NOT (other);
+    if (find_litpair_second_literal (not_other, neg_begin, neg_end)) {
+      unsigned first, second;
+      if (NEGATED (pos_lit))
+        first = neg_lit, second = other;
+      else
+        first = pos_lit, second = not_other;
+      LOG ("found conditional %s equivalence %s = %s", LOGLIT (lit),
+           LOGLIT (first), LOGLIT (second));
+      KISSAT_assert (!NEGATED (first));
+      KISSAT_assert (first < second);
+      check_ternary (closure, lit, first, NOT (second));
+      check_ternary (closure, lit, NOT (first), second);
+      litpair equivalence = {.lits = {first, second}};
+      PUSH_STACK (*condeq, equivalence);
+      if (NEGATED (second)) {
+        litpair inverse_equivalence = {.lits = {NOT (second), NOT (first)}};
+        PUSH_STACK (*condeq, inverse_equivalence);
+      } else {
+        litpair inverse_equivalence = {.lits = {second, first}};
+        PUSH_STACK (*condeq, inverse_equivalence);
+      }
+    }
+  }
+#ifndef LOGGING
+  (void) lit;
+#endif
+}
+
+static void extract_condeq_pairs (closure *closure, unsigned lit,
+                                  litpairs *condbin, litpairs *condeq) {
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  kissat *const solver = closure->solver;
+#endif
+  const litpair *const begin = BEGIN_STACK (*condbin);
+  const litpair *const end = END_STACK (*condbin);
+  const litpair *pos_begin = begin;
+  unsigned next_lit;
+  for (;;) {
+    if (pos_begin == end)
+      return;
+    next_lit = pos_begin->lits[0];
+    if (!NEGATED (next_lit))
+      break;
+    pos_begin++;
+  }
+  for (;;) {
+    KISSAT_assert (pos_begin != end);
+    KISSAT_assert (next_lit == pos_begin->lits[0]);
+    KISSAT_assert (!NEGATED (next_lit));
+    const unsigned pos_lit = next_lit;
+    const litpair *pos_end = pos_begin + 1;
+    for (;;) {
+      if (pos_end == end)
+        return;
+      next_lit = pos_end->lits[0];
+      if (next_lit != pos_lit)
+        break;
+      pos_end++;
+    }
+    KISSAT_assert (pos_end != end);
+    KISSAT_assert (next_lit == pos_end->lits[0]);
+    const unsigned neg_lit = NOT (pos_lit);
+    if (next_lit != neg_lit) {
+      if (NEGATED (next_lit)) {
+        pos_begin = pos_end + 1;
+        for (;;) {
+          if (pos_begin == end)
+            return;
+          next_lit = pos_begin->lits[0];
+          if (!NEGATED (next_lit))
+            break;
+          pos_begin++;
+        }
+      } else
+        pos_begin = pos_end;
+      continue;
+    }
+    const litpair *const neg_begin = pos_end;
+    const litpair *neg_end = neg_begin + 1;
+    while (neg_end != end) {
+      next_lit = neg_end->lits[0];
+      if (next_lit != neg_lit)
+        break;
+      neg_end++;
+    }
+#ifdef LOGGING
+    if (kissat_logging (solver)) {
+      for (const litpair *p = pos_begin; p != pos_end; p++)
+        LOG ("conditional %s binary clause %s %s with positive %s",
+             LOGLIT (lit), LOGLIT (p->lits[0]), LOGLIT (p->lits[1]),
+             LOGLIT (pos_lit));
+      for (const litpair *p = neg_begin; p != neg_end; p++)
+        LOG ("conditional %s binary clause %s %s with negative %s",
+             LOGLIT (lit), LOGLIT (p->lits[0]), LOGLIT (p->lits[1]),
+             LOGLIT (neg_lit));
+    }
+#endif
+    const size_t pos_size = pos_end - pos_begin;
+    const size_t neg_size = neg_end - neg_begin;
+    if (pos_size <= neg_size) {
+      LOG ("searching negation of %zu conditional binary clauses "
+           "with positive %s in %zu conditional binary clauses with %s",
+           pos_size, LOGLIT (pos_lit), neg_size, LOGLIT (neg_lit));
+      search_condeq (closure, lit, pos_lit, pos_begin, pos_end, neg_lit,
+                     neg_begin, neg_end, condeq);
+    } else {
+      LOG ("searching negation of %zu conditional binary clauses "
+           "with negative %s in %zu conditional binary clauses with %s",
+           neg_size, LOGLIT (neg_lit), pos_size, LOGLIT (pos_lit));
+      search_condeq (closure, lit, neg_lit, neg_begin, neg_end, pos_lit,
+                     pos_begin, pos_end, condeq);
+    }
+    if (neg_end == end)
+      return;
+    KISSAT_assert (next_lit == neg_end->lits[0]);
+    if (NEGATED (next_lit)) {
+      pos_begin = neg_end + 1;
+      for (;;) {
+        if (pos_begin == end)
+          return;
+        next_lit = pos_begin->lits[0];
+        if (!NEGATED (next_lit))
+          break;
+        pos_begin++;
+      }
+    } else
+      pos_begin = neg_end;
+  }
+}
+
+static void find_conditional_equivalences (closure *closure, unsigned lit,
+                                           watches *watches,
+                                           litpairs *condbin,
+                                           litpairs *condeq) {
+  KISSAT_assert (EMPTY_STACK (*condbin));
+  KISSAT_assert (EMPTY_STACK (*condeq));
+  KISSAT_assert (SIZE_WATCHES (*watches) > 1);
+  kissat *const solver = closure->solver;
+  copy_conditional_equivalences (solver, lit, watches, condbin);
+  sort_pairs (solver, condbin);
+#ifdef LOGGING
+  if (kissat_logging (solver)) {
+    for (all_stack (litpair, pair, *condbin))
+      LOG ("sorted conditional %s binary clause %s %s", LOGLIT (lit),
+           LOGLIT (pair.lits[0]), LOGLIT (pair.lits[1]));
+    LOG ("found %zu conditional %s binary clauses", SIZE_STACK (*condbin),
+         LOGLIT (lit));
+  }
+#endif
+  extract_condeq_pairs (closure, lit, condbin, condeq);
+  sort_pairs (solver, condeq);
+#ifdef LOGGING
+  if (kissat_logging (solver)) {
+    for (all_stack (litpair, pair, *condeq))
+      LOG ("sorted conditional %s equivalence %s = %s", LOGLIT (lit),
+           LOGLIT (pair.lits[0]), LOGLIT (pair.lits[1]));
+    LOG ("found %zu conditional %s equivalences", SIZE_STACK (*condeq),
+         LOGLIT (lit));
+  }
+#endif
+}
+
+static void merge_condeq (closure *closure, unsigned cond, litpairs *condeq,
+                          litpairs *not_condeq) {
+  kissat *solver = closure->solver;
+  KISSAT_assert (!NEGATED (cond));
+  const litpair *const begin_condeq = BEGIN_STACK (*condeq);
+  const litpair *const end_condeq = END_STACK (*condeq);
+  const litpair *const begin_not_condeq = BEGIN_STACK (*not_condeq);
+  const litpair *const end_not_condeq = END_STACK (*not_condeq);
+  const litpair *p = begin_condeq;
+  const litpair *q = begin_not_condeq;
+  while (p != end_condeq) {
+    litpair cond_pair = *p++;
+    const unsigned lhs = cond_pair.lits[0];
+    const unsigned then_lit = cond_pair.lits[1];
+    KISSAT_assert (!NEGATED (lhs));
+    while (q != end_not_condeq && q->lits[0] < lhs)
+      q++;
+    while (q != end_not_condeq && q->lits[0] == lhs) {
+      litpair not_cond_pair = *q++;
+      const unsigned else_lit = not_cond_pair.lits[1];
+      new_ite_gate (closure, lhs, cond, then_lit, else_lit);
+      if (solver->inconsistent)
+        return;
+    }
+  }
+}
+
+static void extract_ite_gates_of_literal (closure *closure, unsigned lit,
+                                          unsigned not_lit,
+                                          watches *lit_watches,
+                                          watches *not_lit_watches) {
+#ifndef KISSAT_NDEBUG
+  kissat *solver = closure->solver;
+#endif
+  litpairs *condbin = closure->condbin;
+  litpairs *condeq = closure->condeq;
+  find_conditional_equivalences (closure, lit, lit_watches, condbin + 0,
+                                 condeq + 0);
+  if (EMPTY_STACK (condeq[0]))
+    goto CLEAN_UP;
+  find_conditional_equivalences (closure, not_lit, not_lit_watches,
+                                 condbin + 1, condeq + 1);
+  if (EMPTY_STACK (condeq[1]))
+    goto CLEAN_UP;
+  if (NEGATED (lit))
+    merge_condeq (closure, not_lit, condeq + 0, condeq + 1);
+  else
+    merge_condeq (closure, lit, condeq + 1, condeq + 0);
+CLEAN_UP:
+  CLEAR_STACK (condbin[0]);
+  CLEAR_STACK (condbin[1]);
+  CLEAR_STACK (condeq[0]);
+  CLEAR_STACK (condeq[1]);
+}
+
+static void extract_ite_gates_of_variable (closure *closure, unsigned idx) {
+  kissat *const solver = closure->solver;
+  const unsigned lit = LIT (idx);
+  const unsigned not_lit = NOT (lit);
+  watches *lit_watches = &WATCHES (lit);
+  watches *not_lit_watches = &WATCHES (not_lit);
+  const size_t size_lit_watches = SIZE_WATCHES (*lit_watches);
+  const size_t size_not_lit_watches = SIZE_WATCHES (*not_lit_watches);
+  if (size_lit_watches <= size_not_lit_watches) {
+    if (size_lit_watches > 1)
+      extract_ite_gates_of_literal (closure, lit, not_lit, lit_watches,
+                                    not_lit_watches);
+  } else {
+    if (size_not_lit_watches > 1)
+      extract_ite_gates_of_literal (closure, not_lit, lit, not_lit_watches,
+                                    lit_watches);
+  }
+}
+
+#else
+
+static void mark_third_literal_in_ternary_clauses (
+    kissat *solver, const value *const values, unsigneds *marked,
+    mark *marks, unsigned a, unsigned b) {
+  KISSAT_assert (!solver->watching);
+  KISSAT_assert (EMPTY_STACK (*marked));
+  watches *a_watches = &WATCHES (a);
+  watches *b_watches = &WATCHES (b);
+  const size_t size_a = SIZE_WATCHES (*a_watches);
+  const size_t size_b = SIZE_WATCHES (*b_watches);
+  watches *watches = size_a <= size_b ? a_watches : b_watches;
+  const watch *const begin = BEGIN_WATCHES (*watches);
+  const watch *const end = END_WATCHES (*watches);
+  for (const watch *p = begin; p != end; p++) {
+    const watch watch = *p;
+    KISSAT_assert (!watch.type.binary);
+    const reference ref = watch.large.ref;
+    clause *c = kissat_dereference_clause (solver, ref);
+    KISSAT_assert (!c->garbage);
+    unsigned third = INVALID_LIT, found = 0;
+    for (all_literals_in_clause (lit, c)) {
+      if (values[lit])
+        continue;
+      if (lit == a || lit == b) {
+        found++;
+        continue;
+      }
+      if (third != INVALID_LIT)
+        goto NEXT_WATCH;
+      third = lit;
+    }
+    KISSAT_assert (found <= 2);
+    if (found < 2)
+      goto NEXT_WATCH;
+    KISSAT_assert (third != INVALID_LIT);
+    if (third == INVALID_LIT)
+      goto NEXT_WATCH;
+    if (marks[third])
+      goto NEXT_WATCH;
+    LOGCLS (c, "marking %s as third literal in", LOGLIT (third));
+    PUSH_STACK (*marked, third);
+    marks[third] = 1;
+  NEXT_WATCH:;
+  }
+}
+
+static void extract_ite_gate (closure *closure, const value *const values,
+                              mark *const marks, unsigned lhs,
+                              unsigned cond, unsigned then_lit) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->watching);
+  unsigned a = NOT (lhs), b = cond;
+  watches *a_watches = &WATCHES (a);
+  watches *b_watches = &WATCHES (b);
+  const size_t size_a = SIZE_WATCHES (*a_watches);
+  const size_t size_b = SIZE_WATCHES (*b_watches);
+  watches *watches = size_a <= size_b ? a_watches : b_watches;
+  const watch *const begin = BEGIN_WATCHES (*watches);
+  const watch *const end = END_WATCHES (*watches);
+  for (const watch *p = begin; p != end; p++) {
+    const watch watch = *p;
+    KISSAT_assert (!watch.type.binary);
+    const reference ref = watch.large.ref;
+    clause *c = kissat_dereference_clause (solver, ref);
+    KISSAT_assert (!c->garbage);
+    unsigned else_lit = INVALID_LIT, found = 0;
+    for (all_literals_in_clause (lit, c)) {
+      if (values[lit])
+        continue;
+      if (lit == a || lit == b) {
+        found++;
+        continue;
+      }
+      if (else_lit != INVALID_LIT)
+        goto NEXT_WATCH;
+      else_lit = lit;
+    }
+    KISSAT_assert (found <= 2);
+    if (found < 2)
+      goto NEXT_WATCH;
+    KISSAT_assert (else_lit != INVALID_LIT);
+    unsigned not_else_lit = NOT (else_lit);
+    if (!marks[not_else_lit])
+      goto NEXT_WATCH;
+    LOGCLS (c, "found fourth matching");
+    check_ite_implied (closure, lhs, cond, then_lit, else_lit);
+    marks[not_else_lit] = 0;
+    new_ite_gate (closure, lhs, cond, then_lit, else_lit);
+  NEXT_WATCH:;
+  }
+  SWAP (unsigned, a, b);
+}
+
+static void extract_ite_gates_with_base_clause (closure *closure,
+                                                clause *c) {
+  KISSAT_assert (!c->garbage);
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  const value *const values = solver->values;
+  const unsigned *const largecount = closure->largecount;
+  unsigneds *lits = &closure->lits;
+  CLEAR_STACK (*lits);
+  unsigned sum = 0;
+  for (all_literals_in_clause (lit, c)) {
+    const value value = values[lit];
+    if (value < 0)
+      continue;
+    if (value > 0) {
+      LOGCLS (c, "found satisfied %s in", LOGLIT (lit));
+      kissat_mark_clause_as_garbage (solver, c);
+      return;
+    }
+    PUSH_STACK (*lits, lit);
+    sum ^= lit;
+  }
+  const size_t size = SIZE_STACK (*lits);
+  KISSAT_assert (size <= 3);
+  if (size < 3)
+    return;
+  mark *const marks = solver->marks;
+  unsigneds *marked = &solver->analyzed;
+  for (all_stack (unsigned, lhs, *lits)) {
+    if (NEGATED (lhs))
+      continue;
+    if (largecount[lhs] < 2)
+      continue;
+    const unsigned not_lhs = NOT (lhs);
+    if (largecount[not_lhs] < 2)
+      continue;
+    for (all_stack (unsigned, not_cond, *lits)) {
+      if (not_cond == lhs)
+        continue;
+      if (!NEGATED (not_cond))
+        continue;
+      if (largecount[not_cond] < 2)
+        continue;
+      const unsigned cond = NOT (not_cond);
+      if (largecount[cond] < 2)
+        continue;
+      const unsigned not_then_lit = sum ^ lhs ^ not_cond;
+      const unsigned then_lit = NOT (not_then_lit);
+      if (!largecount[then_lit])
+        continue;
+      LOGCLS (c, "found first ITE gate '%s := %s ? %s : ...' gate base",
+              LOGLIT (lhs), LOGLIT (cond), LOGLIT (then_lit));
+      clause *d = find_ternary_clause (solver, not_lhs, not_cond, then_lit);
+      if (!d)
+        continue;
+      LOGCLS (d, "found matching second ITE gate");
+      mark_third_literal_in_ternary_clauses (solver, values, marked, marks,
+                                             lhs, cond);
+      extract_ite_gate (closure, values, marks, lhs, cond, then_lit);
+      unmark_all (marked, marks);
+    }
+  }
+}
+
+#endif
+
+static void extract_and_gates (closure *closure) {
+  kissat *const solver = closure->solver;
+  if (!GET_OPTION (congruenceands))
+    return;
+  START (extractands);
+#ifndef KISSAT_QUIET
+  const statistics *s = &solver->statistics_;
+  const uint64_t matched_before = s->congruent_matched_ands;
+  const uint64_t gates_before = s->congruent_gates_ands;
+#endif
+  init_and_gate_extraction (closure);
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+  for (all_clauses (c)) {
+    if (TERMINATED (congruence_terminated_1))
+      break;
+    if (solver->inconsistent)
+      break;
+    if (last_irredundant && last_irredundant < c)
+      break;
+    if (c->redundant)
+      continue;
+    if (c->garbage)
+      continue;
+    extract_and_gates_with_base_clause (closure, c);
+  }
+  reset_and_gate_extraction (closure);
+#ifndef KISSAT_QUIET
+  const uint64_t matched = s->congruent_matched_ands - matched_before;
+  const uint64_t extracted = s->congruent_gates_ands - gates_before;
+  const uint64_t found = matched + extracted;
+  kissat_phase (solver, "congruence", GET (closures),
+                "found %" PRIu64 " AND gates (%" PRIu64
+                " extracted %.0f%% + %" PRIu64 " matched %.0f%%)",
+                found, extracted, kissat_percent (extracted, found),
+                matched, kissat_percent (matched, found));
+#endif
+  STOP (extractands);
+}
+
+static void extract_xor_gates (closure *closure) {
+  kissat *const solver = closure->solver;
+  if (!GET_OPTION (congruencexors))
+    return;
+  START (extractxors);
+  references candidates;
+  INIT_STACK (candidates);
+  init_xor_gate_extraction (closure, &candidates);
+  SHRINK_STACK (candidates);
+#ifndef KISSAT_QUIET
+  const statistics *s = &solver->statistics_;
+  const uint64_t matched_before = s->congruent_matched_xors;
+  const uint64_t gates_before = s->congruent_gates_xors;
+#endif
+  for (all_stack (reference, ref, candidates)) {
+    if (TERMINATED (congruence_terminated_2))
+      break;
+    if (solver->inconsistent)
+      break;
+    clause *c = kissat_dereference_clause (solver, ref);
+    if (c->garbage)
+      continue;
+    extract_xor_gates_with_base_clause (closure, c);
+  }
+  reset_xor_gate_extraction (closure);
+  RELEASE_STACK (candidates);
+#ifndef KISSAT_QUIET
+  const uint64_t matched = s->congruent_matched_xors - matched_before;
+  const uint64_t extracted = s->congruent_gates_xors - gates_before;
+  const uint64_t found = matched + extracted;
+  kissat_phase (solver, "congruence", GET (closures),
+                "found %" PRIu64 " XOR gates (%" PRIu64
+                " extracted %.0f%% + %" PRIu64 " matched %.0f%%)",
+                found, extracted, kissat_percent (extracted, found),
+                matched, kissat_percent (matched, found));
+#endif
+  STOP (extractxors);
+}
+
+static void extract_ite_gates (closure *closure) {
+  kissat *const solver = closure->solver;
+  if (!GET_OPTION (congruenceites))
+    return;
+  START (extractites);
+  references candidates;
+  INIT_STACK (candidates);
+  init_ite_gate_extraction (closure, &candidates);
+#ifndef KISSAT_QUIET
+  const statistics *s = &solver->statistics_;
+  const uint64_t matched_before = s->congruent_matched_ites;
+  const uint64_t gates_before = s->congruent_gates_ites;
+#endif
+#ifdef MERGE_CONDITIONAL_EQUIVALENCES
+  for (all_variables (idx))
+    if (ACTIVE (idx)) {
+      extract_ite_gates_of_variable (closure, idx);
+      if (solver->inconsistent)
+        break;
+    }
+#else
+  for (all_stack (reference, ref, candidates)) {
+    if (TERMINATED (congruence_terminated_3))
+      break;
+    if (solver->inconsistent)
+      break;
+    clause *c = kissat_dereference_clause (solver, ref);
+    if (c->garbage)
+      continue;
+    extract_ite_gates_with_base_clause (closure, c);
+  }
+#endif
+  reset_ite_gate_extraction (closure);
+  RELEASE_STACK (candidates);
+#ifndef KISSAT_QUIET
+  const uint64_t matched = s->congruent_matched_ites - matched_before;
+  const uint64_t extracted = s->congruent_gates_ites - gates_before;
+  const uint64_t found = matched + extracted;
+  kissat_phase (solver, "congruence", GET (closures),
+                "found %" PRIu64 " ITE gates (%" PRIu64
+                " extracted %.0f%% + %" PRIu64 " matched %.0f%%)",
+                found, extracted, kissat_percent (extracted, found),
+                matched, kissat_percent (matched, found));
+#endif
+  STOP (extractites);
+}
+
+static void init_extraction (closure *closure) {
+  kissat *const solver = closure->solver;
+  kissat_enter_dense_mode (solver, &closure->binaries);
+}
+
+static void reset_extraction (closure *closure) {
+  kissat *const solver = closure->solver;
+  kissat_resume_sparse_mode (solver, false, &closure->binaries);
+  RELEASE_STACK (closure->binaries);
+}
+
+static void extract_gates (closure *closure) {
+  kissat *const solver = closure->solver;
+  START (extract);
+  KISSAT_assert (!solver->level);
+#ifndef KISSAT_QUIET
+  const statistics *s = &solver->statistics_;
+  const uint64_t before = s->congruent_gates + s->congruent_matched;
+#endif
+  init_extraction (closure);
+  extract_binaries (closure);
+  KISSAT_assert (!solver->inconsistent);
+  extract_and_gates (closure);
+  if (!solver->inconsistent && !TERMINATED (congruence_terminated_4)) {
+    extract_xor_gates (closure);
+    if (!solver->inconsistent && !TERMINATED (congruence_terminated_5))
+      extract_ite_gates (closure);
+  }
+  reset_extraction (closure);
+#ifndef KISSAT_QUIET
+  const uint64_t after = s->congruent_gates + s->congruent_matched;
+  const uint64_t found = after - before;
+  kissat_phase (solver, "congruence", GET (closures),
+                "found %" PRIu64 " gates (%.2f%% variables)", found,
+                kissat_percent (found, solver->active));
+#endif
+  STOP (extract);
+}
+
+static void find_units (closure *closure) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (kissat_propagated (solver));
+  closure->units = solver->propagate;
+  unsigneds *marked = &solver->analyzed;
+  mark *const marks = solver->marks;
+  size_t units = 0;
+  for (all_variables (idx)) {
+  RESTART:
+    if (!ACTIVE (idx))
+      continue;
+    unsigned lit = LIT (idx);
+    for (unsigned sign = 0; sign != 2; sign++, lit++) {
+      watches *const watches = &WATCHES (lit);
+      const watch *p = BEGIN_WATCHES (*watches);
+      const watch *const end = END_WATCHES (*watches);
+      KISSAT_assert (EMPTY_STACK (*marked));
+      while (p != end) {
+        const watch watch = *p++;
+        if (!watch.type.binary)
+          break;
+        const unsigned other = watch.binary.lit;
+        const unsigned not_other = NOT (other);
+        if (marks[not_other]) {
+          LOG ("binary clauses %s %s and %s %s yield unit %s", LOGLIT (lit),
+               LOGLIT (other), LOGLIT (lit), LOGLIT (not_other),
+               LOGLIT (lit));
+          units++;
+          bool failed = !learn_congruence_unit (closure, lit);
+          unmark_all (marked, marks);
+          if (failed)
+            return;
+          else
+            goto RESTART;
+        }
+        if (marks[other])
+          continue;
+        marks[other] = 1;
+        PUSH_STACK (*marked, other);
+      }
+      unmark_all (marked, marks);
+    }
+  }
+  KISSAT_assert (EMPTY_STACK (*marked));
+#ifndef KISSAT_QUIET
+  kissat_very_verbose (solver, "found %zu units", units);
+#else
+  (void) units;
+#endif
+}
+
+static void find_equivalences (closure *closure) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+  unsigneds *const marked = &solver->analyzed;
+  mark *const marks = solver->marks;
+  KISSAT_assert (EMPTY_STACK (*marked));
+  for (all_variables (idx)) {
+  RESTART:
+    if (!ACTIVE (idx))
+      continue;
+    const unsigned lit = LIT (idx);
+    watches *lit_watches = &WATCHES (lit);
+    const watch *p = BEGIN_WATCHES (*lit_watches);
+    const watch *const end_lit_watches = END_WATCHES (*lit_watches);
+    KISSAT_assert (EMPTY_STACK (*marked));
+    while (p != end_lit_watches) {
+      const watch watch = *p++;
+      if (!watch.type.binary)
+        break;
+      const unsigned other = watch.binary.lit;
+      if (lit > other)
+        continue;
+      if (marks[other])
+        continue;
+      marks[other] = 1;
+      PUSH_STACK (*marked, other);
+    }
+    if (EMPTY_STACK (*marked))
+      continue;
+    const unsigned not_lit = NOT (lit);
+    watches *not_lit_watches = &WATCHES (not_lit);
+    p = BEGIN_WATCHES (*not_lit_watches);
+    const watch *const end_not_lit_watches = END_WATCHES (*not_lit_watches);
+    while (p != end_not_lit_watches) {
+      const watch watch = *p++;
+      if (!watch.type.binary)
+        break;
+      const unsigned other = watch.binary.lit;
+      if (not_lit > other)
+        continue;
+      if (lit == other)
+        continue;
+      const unsigned not_other = NOT (other);
+      if (marks[not_other]) {
+        unsigned lit_repr = find_repr (closure, lit);
+        unsigned other_repr = find_repr (closure, other);
+        if (lit_repr != other_repr) {
+          if (merge_literals (closure, lit, other))
+            INC (congruent_equivalences);
+          unmark_all (marked, marks);
+          if (solver->inconsistent)
+            return;
+          else
+            goto RESTART;
+        }
+      }
+    }
+    unmark_all (marked, marks);
+  }
+  KISSAT_assert (EMPTY_STACK (*marked));
+#ifndef KISSAT_QUIET
+  size_t found = SIZE_FIFO (closure->schedule);
+  kissat_very_verbose (solver, "found %zu equivalences", found);
+#endif
+}
+
+static bool simplify_gates (closure *closure, unsigned lit) {
+  kissat *const solver = closure->solver;
+  LOG ("simplifying gates with RHS literal %s", LOGLIT (lit));
+  KISSAT_assert (solver->values[lit]);
+  gates *lit_occurrences = closure->occurrences + lit;
+  for (all_pointers (gate, g, *lit_occurrences))
+    if (!simplify_gate (closure, g))
+      return false;
+  RELEASE_STACK (*lit_occurrences);
+  return true;
+}
+
+static bool rewrite_gates (closure *closure, unsigned dst, unsigned src) {
+  kissat *const solver = closure->solver;
+  LOG ("rewriting gates with RHS literal %s", LOGLIT (src));
+  gates *occurrences = closure->occurrences;
+  gates *src_occurrences = occurrences + src;
+  gates *dst_occurrences = occurrences + dst;
+  for (all_pointers (gate, g, *src_occurrences))
+    if (!rewrite_gate (closure, g, dst, src))
+      return false;
+    else if (!g->garbage && gate_contains (g, dst))
+      PUSH_STACK (*dst_occurrences, g);
+  RELEASE_STACK (*src_occurrences);
+  return true;
+}
+
+static bool propagate_unit (closure *closure, unsigned lit) {
+  kissat *const solver = closure->solver;
+  LOG ("propagation of congruence unit %s", LOGLIT (lit));
+  (void) solver;
+  KISSAT_assert (!solver->inconsistent);
+  const unsigned not_lit = NOT (lit);
+  return simplify_gates (closure, lit) && simplify_gates (closure, not_lit);
+}
+
+static bool propagate_equivalence (closure *closure, unsigned lit) {
+  kissat *const solver = closure->solver;
+  LOG ("propagation of congruence equivalence %s", CLOGREPR (lit));
+  KISSAT_assert (!solver->inconsistent);
+  if (VALUE (lit))
+    return true;
+  const unsigned lit_repr = find_repr (closure, lit);
+  if (solver->inconsistent)
+    return false;
+  const unsigned not_lit = NOT (lit);
+  const unsigned not_lit_repr = NOT (lit_repr);
+  return rewrite_gates (closure, lit_repr, lit) &&
+         rewrite_gates (closure, not_lit_repr, not_lit);
+}
+
+static bool propagate_units (closure *closure) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  const unsigned_array *const trail = &solver->trail;
+  while (closure->units != trail->end)
+    if (!propagate_unit (closure, *closure->units++))
+      return false;
+  return true;
+}
+
+static size_t propagate_units_and_equivalences (closure *closure) {
+  kissat *const solver = closure->solver;
+  KISSAT_assert (!solver->inconsistent);
+  START (merge);
+  unsigned_fifo *schedule = &closure->schedule;
+  size_t propagated = 0;
+  while (!TERMINATED (congruence_terminated_6) &&
+         propagate_units (closure) && !EMPTY_FIFO (*schedule)) {
+    propagated++;
+    unsigned lit = dequeue_next_scheduled_literal (closure);
+    if (!propagate_equivalence (closure, lit))
+      break;
+  }
+#ifndef KISSAT_QUIET
+  const size_t units = closure->units - solver->trail.begin;
+  kissat_very_verbose (solver, "propagated %zu congruence units", units);
+  kissat_very_verbose (solver, "propagated %zu congruence equivalences",
+                       propagated);
+#endif
+  STOP (merge);
+  return propagated;
+}
+
+#ifndef KISSAT_NDEBUG
+
+static void dump_closure_literal (closure *closure, unsigned ilit) {
+  kissat *const solver = closure->solver;
+  const int elit = kissat_export_literal (solver, ilit);
+  printf ("%u(%d)", ilit, elit);
+  unsigned repr_ilit = find_repr (closure, ilit);
+  if (repr_ilit != ilit) {
+    const int repr_elit = kissat_export_literal (solver, repr_ilit);
+    printf ("[%u(%d)]", repr_ilit, repr_elit);
+  }
+  const int value = VALUE (ilit);
+  KISSAT_assert (!solver->level);
+  if (value)
+    printf ("@0=%d", value);
+}
+
+static void dump_units (closure *closure) {
+  unsigned_array *trail = &closure->solver->trail;
+  size_t i = 0, propagate = closure->units - trail->begin;
+  for (all_stack (unsigned, lit, *trail)) {
+    printf ("trail[%zu] ", i);
+    dump_closure_literal (closure, lit);
+    if (i == propagate)
+      fputs (" <-- next unit to propagate", stdout);
+    fputc ('\n', stdout);
+    i++;
+  }
+}
+
+static void dump_equivalences (closure *closure) {
+  kissat *const solver = closure->solver;
+  for (all_variables (idx)) {
+    unsigned lit = LIT (idx);
+    unsigned repr = closure->repr[lit];
+    if (repr != lit)
+      printf ("repr[%u(%d)] = %u(%d)\n", lit,
+              kissat_export_literal (solver, lit), repr,
+              kissat_export_literal (solver, repr));
+  }
+}
+
+static void dump_gate (closure *closure, gate *g) {
+  const unsigned tag = g->tag;
+  const char *str;
+  switch (tag) {
+  case AND_GATE:
+    str = "AND";
+    break;
+  case ITE_GATE:
+    str = "ITE";
+    break;
+  case XOR_GATE:
+    str = "XOR";
+    break;
+  default:
+    str = "UNKNOWN";
+    break;
+  }
+  printf ("%p %s gate[%zu] ", (void *) g, str, g->id);
+  dump_closure_literal (closure, g->lhs);
+  fputs (" := ", stdout);
+  if (g->tag == ITE_GATE) {
+    dump_closure_literal (closure, g->rhs[0]);
+    fputs (" ? ", stdout);
+    dump_closure_literal (closure, g->rhs[1]);
+    fputs (" : ", stdout);
+    dump_closure_literal (closure, g->rhs[2]);
+  } else {
+    bool first = true;
+    for (all_rhs_literals_in_gate (rhs, g)) {
+      if (first)
+        first = false;
+      else if (g->tag == AND_GATE)
+        fputs (" & ", stdout);
+      else
+        fputs (" ^ ", stdout);
+      dump_closure_literal (closure, rhs);
+    }
+  }
+  fputs (g->indexed ? " removed" : " indexed", stdout);
+  if (g->garbage)
+    fputs (" garbage", stdout);
+  fputc ('\n', stdout);
+}
+
+#define LESS_GATE(G, H) ((G)->id < (H)->id)
+
+static void dump_gates (closure *closure) {
+  gates gates;
+  INIT_STACK (gates);
+  kissat *const solver = closure->solver;
+  for (unsigned pos = 0; pos != closure->hash.size; pos++) {
+    gate *g = closure->hash.table[pos];
+    if (!g)
+      continue;
+    if (g == REMOVED)
+      continue;
+    PUSH_STACK (gates, g);
+  }
+  SORT_STACK (gate *, gates, LESS_GATE);
+  for (all_pointers (gate, g, gates))
+    dump_gate (closure, g);
+  RELEASE_STACK (gates);
+}
+
+void kissat_dump_closure (closure *closure) {
+  dump_units (closure);
+  dump_equivalences (closure);
+  dump_gates (closure);
+}
+
+#endif
+
+static bool find_subsuming_clause (closure *closure, clause *c) {
+  KISSAT_assert (!c->garbage);
+  kissat *const solver = closure->solver;
+  const reference c_ref = kissat_reference_clause (solver, c);
+  const value *const values = solver->values;
+  mark *marks = solver->marks;
+  {
+    const unsigned *const end_lits = c->lits + c->size;
+    for (const unsigned *p = c->lits; p != end_lits; p++) {
+      const unsigned lit = *p;
+      KISSAT_assert (values[lit] <= 0);
+      const unsigned repr_lit = find_repr (closure, lit);
+      const value value_repr_lit = values[repr_lit];
+      KISSAT_assert (value_repr_lit <= 0);
+      if (value_repr_lit < 0)
+        continue;
+      if (marks[repr_lit])
+        continue;
+      KISSAT_assert (!marks[NOT (repr_lit)]);
+      marks[repr_lit] = 1;
+    }
+  }
+  unsigned least_occurring_literal = INVALID_LIT;
+  unsigned count_least_occurring = UINT_MAX;
+  LOGREPRCLS (c, closure->repr, "trying to forward subsume");
+  clause *subsuming = 0;
+  for (all_literals_in_clause (lit, c)) {
+    const unsigned repr_lit = find_repr (closure, lit);
+    watches *const watches = &WATCHES (repr_lit);
+    const watch *p = BEGIN_WATCHES (*watches);
+    const watch *const end = END_WATCHES (*watches);
+    const size_t count = end - p;
+    KISSAT_assert (count <= UINT_MAX);
+    if (count < count_least_occurring) {
+      count_least_occurring = count;
+      least_occurring_literal = repr_lit;
+    }
+    while (p != end) {
+      const watch watch = *p++;
+      KISSAT_assert (!watch.type.binary);
+      const reference d_ref = watch.large.ref;
+      clause *const d = kissat_dereference_clause (solver, d_ref);
+      KISSAT_assert (c != d);
+      KISSAT_assert (!d->garbage);
+      if (!c->redundant && d->redundant)
+        continue;
+      for (all_literals_in_clause (other, d)) {
+        const value value = values[other];
+        if (value < 0)
+          continue;
+        KISSAT_assert (!value);
+        const unsigned repr_other = find_repr (closure, other);
+        if (!marks[repr_other])
+          goto CONTINUE_WITH_NEXT_CLAUSE;
+      }
+      subsuming = d;
+      goto FOUND_SUBSUMING;
+    CONTINUE_WITH_NEXT_CLAUSE:;
+    }
+  }
+FOUND_SUBSUMING:
+  for (all_literals_in_clause (lit, c)) {
+    const unsigned repr_lit = find_repr (closure, lit);
+    const value value = values[repr_lit];
+    if (!value)
+      marks[repr_lit] = 0;
+  }
+  if (subsuming) {
+    LOGREPRCLS (c, closure->repr, "subsumed");
+    LOGREPRCLS (subsuming, closure->repr, "subsuming");
+    kissat_mark_clause_as_garbage (solver, c);
+    INC (congruent_subsumed);
+    return true;
+  } else {
+    KISSAT_assert (least_occurring_literal != INVALID_LIT);
+    KISSAT_assert (count_least_occurring < UINT_MAX);
+    LOGCLS (c, "forward subsumption failed of");
+    LOG ("connecting %u occurring %s", count_least_occurring,
+         LOGLIT (least_occurring_literal));
+    kissat_connect_literal (solver, least_occurring_literal, c_ref);
+    return false;
+  }
+}
+
+struct refsize {
+  reference ref;
+  unsigned size;
+};
+
+typedef struct refsize refsize;
+typedef STACK (refsize) refsizes;
+
+#define RANKREFSIZE(REFSIZE) ((REFSIZE).size)
+
+static void sort_references_by_clause_size (kissat *solver,
+                                            refsizes *candidates) {
+  RADIX_STACK (refsize, unsigned, *candidates, RANKREFSIZE);
+}
+
+static void forward_subsume_matching_clauses (closure *closure) {
+  kissat *const solver = closure->solver;
+  START (matching);
+  reset_closure (closure);
+  litpairs binaries;
+  INIT_STACK (binaries);
+  kissat_enter_dense_mode (solver, &binaries);
+  bool *matchable;
+#ifndef KISSAT_QUIET
+  unsigned count_matchable = 0;
+#endif
+  CALLOC (bool, matchable, VARS);
+  for (all_variables (idx))
+    if (ACTIVE (idx)) {
+      const unsigned lit = LIT (idx);
+      const unsigned repr = find_repr (closure, lit);
+      if (lit == repr)
+        continue;
+      const unsigned repr_idx = IDX (repr);
+      if (!matchable[idx]) {
+        LOG ("matchable %s", LOGVAR (idx));
+        matchable[idx] = true;
+#ifndef KISSAT_QUIET
+        count_matchable++;
+#endif
+      }
+      if (!matchable[repr_idx]) {
+        LOG ("matchable %s", LOGVAR (repr_idx));
+        matchable[repr_idx] = true;
+#ifndef KISSAT_QUIET
+        count_matchable++;
+#endif
+      }
+    }
+  kissat_phase (solver, "congruence", GET (closures),
+                "found %u matchable variables %.0f%%", count_matchable,
+                kissat_percent (count_matchable, solver->active));
+  size_t potential = 0;
+  refsizes candidates;
+  INIT_STACK (candidates);
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+  const value *const values = solver->values;
+  mark *const marks = solver->marks;
+  unsigneds *marked = &solver->analyzed;
+  for (all_clauses (c)) {
+    if (c->garbage)
+      continue;
+    if (last_irredundant && last_irredundant < c)
+      break;
+    potential++;
+    bool contains_matchable = false;
+    KISSAT_assert (EMPTY_STACK (*marked));
+    LOGREPRCLS (c, closure->repr, "considering");
+    for (all_literals_in_clause (lit, c)) {
+      const value value = values[lit];
+      if (value < 0)
+        continue;
+      if (value > 0) {
+        LOGCLS (c, "satisfied %s in", LOGLIT (lit));
+        kissat_mark_clause_as_garbage (solver, c);
+        break;
+      }
+      if (!contains_matchable) {
+        const unsigned lit_idx = IDX (lit);
+        if (matchable[lit_idx])
+          contains_matchable = true;
+      }
+      const unsigned repr = find_repr (closure, lit);
+      KISSAT_assert (!values[repr]);
+      if (marks[repr])
+        continue;
+      const unsigned not_repr = NOT (repr);
+      if (marks[not_repr]) {
+        LOGCLS (c, "matches both %s and %s", CLOGREPR (lit),
+                LOGLIT (not_repr));
+        kissat_mark_clause_as_garbage (solver, c);
+        break;
+      }
+      marks[repr] = 1;
+      PUSH_STACK (*marked, repr);
+    }
+    const size_t size = SIZE_STACK (*marked);
+    for (all_stack (unsigned, repr, *marked))
+      marks[repr] = 0;
+    CLEAR_STACK (*marked);
+    if (c->garbage)
+      continue;
+    if (!contains_matchable) {
+      LOGREPRCLS (c, closure->repr, "no matchable variable in");
+      continue;
+    }
+    const reference ref = kissat_reference_clause (solver, c);
+    KISSAT_assert (size <= UINT_MAX);
+    refsize refsize = {.ref = ref, .size = (unsigned)size};
+    PUSH_STACK (candidates, refsize);
+  }
+  DEALLOC (matchable, VARS);
+#ifndef KISSAT_QUIET
+  const size_t size_candidates = SIZE_STACK (candidates);
+  kissat_very_verbose (
+      solver, "considering %zu matchable subsumption candidates %.0f%%",
+      size_candidates, kissat_percent (size_candidates, potential));
+#else
+  (void) potential;
+#endif
+  sort_references_by_clause_size (solver, &candidates);
+#ifndef KISSAT_QUIET
+  size_t tried = 0, subsumed = 0;
+#endif
+  for (all_stack (refsize, refsize, candidates)) {
+    if (TERMINATED (congruence_terminated_7))
+      break;
+#ifndef KISSAT_QUIET
+    tried++;
+#endif
+    const unsigned ref = refsize.ref;
+    clause *c = kissat_dereference_clause (solver, ref);
+    if (find_subsuming_clause (closure, c)) {
+#ifndef KISSAT_QUIET
+      subsumed++;
+#endif
+    }
+  }
+  kissat_phase (solver, "congruence", GET (closures),
+                "subsumed %zu clauses out of %zu tried %.0f%%", subsumed,
+                tried, kissat_percent (subsumed, tried));
+  kissat_resume_sparse_mode (solver, false, &binaries);
+  RELEASE_STACK (candidates);
+  RELEASE_STACK (binaries);
+  STOP (matching);
+}
+
+bool kissat_congruence (kissat *solver) {
+  if (solver->inconsistent)
+    return false;
+  kissat_check_statistics (solver);
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (solver->probing);
+  KISSAT_assert (solver->watching);
+  if (!GET_OPTION (congruence))
+    return false;
+  if (!GET_OPTION (congruenceands) && !GET_OPTION (congruenceites) &&
+      !GET_OPTION (congruencexors))
+    return false;
+  if (GET_OPTION (congruenceonce) && solver->statistics_.closures)
+    return false;
+  if (TERMINATED (congruence_terminated_8))
+    return false;
+  if (DELAYING (congruence))
+    return false;
+  START (congruence);
+  INC (closures);
+  closure closure;
+  init_closure (solver, &closure);
+  extract_gates (&closure);
+  bool reset = false;
+  if (!solver->inconsistent && !TERMINATED (congruence_terminated_9)) {
+    find_units (&closure);
+    if (!solver->inconsistent && !TERMINATED (congruence_terminated_10)) {
+      find_equivalences (&closure);
+      if (!solver->inconsistent && !TERMINATED (congruence_terminated_11)) {
+        size_t propagated = propagate_units_and_equivalences (&closure);
+        if (!solver->inconsistent && propagated &&
+            !TERMINATED (congruence_terminated_12)) {
+          forward_subsume_matching_clauses (&closure);
+          reset = true;
+        }
+      }
+    }
+  }
+  if (!reset)
+    reset_closure (&closure);
+  unsigned equivalent = reset_repr (&closure);
+  kissat_phase (solver, "congruence", GET (closures),
+                "merged %u equivalent variables %.2f%%", equivalent,
+                kissat_percent (equivalent, solver->active));
+  KISSAT_assert (solver->active >= equivalent);
+#ifndef KISSAT_QUIET
+  solver->active -= equivalent;
+  REPORT (!equivalent, 'c');
+  if (!solver->inconsistent)
+    solver->active += equivalent;
+#endif
+  if (kissat_average (equivalent, solver->active) < 0.001)
+    BUMP_DELAY (congruence);
+  else
+    REDUCE_DELAY (congruence);
+  STOP (congruence);
+  kissat_check_statistics (solver);
+  return equivalent;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/congruence.h b/src/sat/kissat/congruence.h
new file mode 100644
index 000000000..79a2ff0f6
--- /dev/null
+++ b/src/sat/kissat/congruence.h
@@ -0,0 +1,14 @@
+#ifndef _congruence_h_INCLUDED
+#define _congruence_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+bool kissat_congruence (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/cover.h b/src/sat/kissat/cover.h
new file mode 100644
index 000000000..6c8eb1ee6
--- /dev/null
+++ b/src/sat/kissat/cover.h
@@ -0,0 +1,33 @@
+#ifndef _cover_h_INCLUDED
+#define _cover_h_INCLUDED
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define COVER(COND) \
+  ((COND) ? \
+\
+          (fflush (stdout), \
+           fprintf (stderr, "%s:%ld: %s: Coverage goal `%s' reached.\n", \
+                    __FILE__, (long) __LINE__, __func__, #COND), \
+           abort (), (void) 0) \
+          : (void) 0)
+
+#ifdef COVERAGE
+#define FLUSH_COVERAGE() \
+  do { \
+    void __gcov_dump (void); \
+    __gcov_dump (); \
+  } while (0)
+#else
+#define FLUSH_COVERAGE() \
+  do { \
+  } while (0)
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/decide.c b/src/sat/kissat/decide.c
new file mode 100644
index 000000000..7c2fa82d9
--- /dev/null
+++ b/src/sat/kissat/decide.c
@@ -0,0 +1,248 @@
+#include "decide.h"
+#include "inlineframes.h"
+#include "inlineheap.h"
+#include "inlinequeue.h"
+#include "print.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static unsigned last_enqueued_unassigned_variable (kissat *solver) {
+  KISSAT_assert (solver->unassigned);
+  const links *const links = solver->links;
+  const value *const values = solver->values;
+  unsigned res = solver->queue.search.idx;
+  if (values[LIT (res)]) {
+    do {
+      res = links[res].prev;
+      KISSAT_assert (!DISCONNECTED (res));
+    } while (values[LIT (res)]);
+    kissat_update_queue (solver, links, res);
+  }
+#ifdef LOGGING
+  const unsigned stamp = links[res].stamp;
+  LOG ("last enqueued unassigned %s stamp %u", LOGVAR (res), stamp);
+#endif
+#ifdef CHECK_QUEUE
+  for (unsigned i = links[res].next; !DISCONNECTED (i); i = links[i].next)
+    KISSAT_assert (VALUE (LIT (i)));
+#endif
+  return res;
+}
+
+static unsigned largest_score_unassigned_variable (kissat *solver) {
+  heap *scores = SCORES;
+  unsigned res = kissat_max_heap (scores);
+  const value *const values = solver->values;
+  while (values[LIT (res)]) {
+    kissat_pop_max_heap (solver, scores);
+    res = kissat_max_heap (scores);
+  }
+#if defined(LOGGING) || defined(CHECK_HEAP)
+  const double score = kissat_get_heap_score (scores, res);
+#endif
+  LOG ("largest score unassigned %s score %g", LOGVAR (res), score);
+#ifdef CHECK_HEAP
+  for (all_variables (idx)) {
+    if (!ACTIVE (idx))
+      continue;
+    if (VALUE (LIT (idx)))
+      continue;
+    const double idx_score = kissat_get_heap_score (scores, idx);
+    KISSAT_assert (score >= idx_score);
+  }
+#endif
+  return res;
+}
+
+void kissat_start_random_sequence (kissat *solver) {
+  if (!GET_OPTION (randec))
+    return;
+
+  if (solver->stable && !GET_OPTION (randecstable))
+    return;
+
+  if (!solver->stable && !GET_OPTION (randecfocused))
+    return;
+
+  if (solver->randec)
+    kissat_very_verbose (solver,
+                         "continuing random decision sequence "
+                         "at %s conflicts",
+                         FORMAT_COUNT (CONFLICTS));
+  else {
+    INC (random_sequences);
+    const uint64_t count = solver->statistics_.random_sequences;
+    const unsigned length = GET_OPTION (randeclength) * LOGN (count);
+    kissat_very_verbose (solver,
+                         "starting random decision sequence "
+                         "at %s conflicts for %s conflicts",
+                         FORMAT_COUNT (CONFLICTS), FORMAT_COUNT (length));
+    solver->randec = length;
+
+    UPDATE_CONFLICT_LIMIT (randec, random_sequences, LOGN, false);
+  }
+}
+
+static unsigned next_random_decision (kissat *solver) {
+  if (!VARS)
+    return INVALID_IDX;
+
+  if (solver->warming)
+    return INVALID_IDX;
+
+  if (!GET_OPTION (randec))
+    return INVALID_IDX;
+
+  if (solver->stable && !GET_OPTION (randecstable))
+    return INVALID_IDX;
+
+  if (!solver->stable && !GET_OPTION (randecfocused))
+    return INVALID_IDX;
+
+  if (!solver->randec) {
+    KISSAT_assert (solver->level);
+    if (solver->level > 1)
+      return INVALID_IDX;
+
+    uint64_t conflicts = CONFLICTS;
+    limits *limits = &solver->limits;
+    if (conflicts < limits->randec.conflicts)
+      return INVALID_IDX;
+
+    kissat_start_random_sequence (solver);
+  }
+
+  for (;;) {
+    unsigned idx = kissat_next_random32 (&solver->random) % VARS;
+    if (!ACTIVE (idx))
+      continue;
+    unsigned lit = LIT (idx);
+    if (solver->values[lit])
+      continue;
+    return idx;
+  }
+}
+
+unsigned kissat_next_decision_variable (kissat *solver) {
+#ifdef LOGGING
+  const char *type = 0;
+#endif
+  unsigned res = next_random_decision (solver);
+  if (res == INVALID_IDX) {
+    if (solver->stable) {
+#ifdef LOGGING
+      type = "maximum score";
+#endif
+      res = largest_score_unassigned_variable (solver);
+      INC (score_decisions);
+    } else {
+#ifdef LOGGING
+      type = "dequeued";
+#endif
+      res = last_enqueued_unassigned_variable (solver);
+      INC (queue_decisions);
+    }
+  } else {
+#ifdef LOGGING
+    type = "random";
+#endif
+    INC (random_decisions);
+  }
+  LOG ("next %s decision %s", type, LOGVAR (res));
+  return res;
+}
+
+int kissat_decide_phase (kissat *solver, unsigned idx) {
+  bool force = GET_OPTION (forcephase);
+
+  value *target;
+  if (force)
+    target = 0;
+  else if (!GET_OPTION (target))
+    target = 0;
+  else if (solver->stable || GET_OPTION (target) > 1)
+    target = solver->phases.target + idx;
+  else
+    target = 0;
+
+  value *saved;
+  if (force)
+    saved = 0;
+  else if (GET_OPTION (phasesaving))
+    saved = solver->phases.saved + idx;
+  else
+    saved = 0;
+
+  value res = 0;
+
+  if (!solver->stable) {
+    switch ((solver->statistics_.switched >> 1) & 7) {
+    case 1:
+      res = INITIAL_PHASE;
+      break;
+    case 3:
+      res = -INITIAL_PHASE;
+      break;
+    }
+  }
+
+  if (!res && target && (res = *target)) {
+    LOG ("%s uses target decision phase %d", LOGVAR (idx), (int) res);
+    INC (target_decisions);
+  }
+
+  if (!res && saved && (res = *saved)) {
+    LOG ("%s uses saved decision phase %d", LOGVAR (idx), (int) res);
+    INC (saved_decisions);
+  }
+
+  if (!res) {
+    res = INITIAL_PHASE;
+    LOG ("%s uses initial decision phase %d", LOGVAR (idx), (int) res);
+    INC (initial_decisions);
+  }
+  KISSAT_assert (res);
+
+  return res < 0 ? -1 : 1;
+}
+
+void kissat_decide (kissat *solver) {
+  START (decide);
+  KISSAT_assert (solver->unassigned);
+  if (solver->warming)
+    INC (warming_decisions);
+  else {
+    INC (decisions);
+    if (solver->stable)
+      INC (stable_decisions);
+    else
+      INC (focused_decisions);
+  }
+  solver->level++;
+  KISSAT_assert (solver->level != INVALID_LEVEL);
+  const unsigned idx = kissat_next_decision_variable (solver);
+  const value value = kissat_decide_phase (solver, idx);
+  unsigned lit = LIT (idx);
+  if (value < 0)
+    lit = NOT (lit);
+  kissat_push_frame (solver, lit);
+  KISSAT_assert (solver->level < SIZE_STACK (solver->frames));
+  LOG ("decide literal %s", LOGLIT (lit));
+  kissat_assign_decision (solver, lit);
+  STOP (decide);
+}
+
+void kissat_internal_assume (kissat *solver, unsigned lit) {
+  KISSAT_assert (solver->unassigned);
+  KISSAT_assert (!VALUE (lit));
+  solver->level++;
+  KISSAT_assert (solver->level != INVALID_LEVEL);
+  kissat_push_frame (solver, lit);
+  KISSAT_assert (solver->level < SIZE_STACK (solver->frames));
+  LOG ("assuming literal %s", LOGLIT (lit));
+  kissat_assign_decision (solver, lit);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/decide.h b/src/sat/kissat/decide.h
new file mode 100644
index 000000000..df368771f
--- /dev/null
+++ b/src/sat/kissat/decide.h
@@ -0,0 +1,19 @@
+#ifndef _decide_h_INCLUDED
+#define _decide_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_decide (struct kissat *);
+void kissat_start_random_sequence (struct kissat *);
+void kissat_internal_assume (struct kissat *, unsigned lit);
+unsigned kissat_next_decision_variable (struct kissat *);
+int kissat_decide_phase (struct kissat *, unsigned idx);
+
+#define INITIAL_PHASE (GET_OPTION (phase) ? 1 : -1)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/deduce.c b/src/sat/kissat/deduce.c
new file mode 100644
index 000000000..dc2ceaa53
--- /dev/null
+++ b/src/sat/kissat/deduce.c
@@ -0,0 +1,172 @@
+#include "deduce.h"
+#include "inline.h"
+#include "promote.h"
+#include "strengthen.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static inline void recompute_and_promote (kissat *solver, clause *c) {
+  KISSAT_assert (c->redundant);
+  const unsigned old_glue = c->glue;
+  const unsigned new_glue = kissat_recompute_glue (solver, c, old_glue);
+  if (new_glue < old_glue)
+    kissat_promote_clause (solver, c, new_glue);
+}
+
+static inline void mark_clause_as_used (kissat *solver, clause *c) {
+  if (!c->redundant)
+    return;
+  INC (clauses_used);
+  c->used = MAX_USED;
+  LOGCLS (c, "using");
+  recompute_and_promote (solver, c);
+  unsigned glue = MIN (c->glue, MAX_GLUE_USED);
+  solver->statistics_.used[solver->stable].glue[glue]++;
+  if (solver->stable)
+    INC (clauses_used_stable);
+  else
+    INC (clauses_used_focused);
+}
+
+bool kissat_recompute_and_promote (kissat *solver, clause *c) {
+  KISSAT_assert (c->redundant);
+  const unsigned old_glue = c->glue;
+  const unsigned new_glue = kissat_recompute_glue (solver, c, old_glue);
+  if (new_glue >= old_glue)
+    return false;
+  kissat_promote_clause (solver, c, new_glue);
+  return true;
+}
+
+static inline bool analyze_literal (kissat *solver, assigned *all_assigned,
+                                    frame *frames, unsigned lit) {
+  KISSAT_assert (VALUE (lit) < 0);
+  const unsigned idx = IDX (lit);
+  assigned *a = all_assigned + idx;
+  const unsigned level = a->level;
+  if (!level)
+    return false;
+  solver->antecedent_size++;
+  if (a->analyzed)
+    return false;
+  LOG ("analyzing literal %s", LOGLIT (lit));
+  kissat_push_analyzed (solver, all_assigned, idx);
+  KISSAT_assert (level <= solver->level);
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  PUSH_STACK (solver->resolvent, lit);
+#endif
+  solver->resolvent_size++;
+  if (level == solver->level)
+    return true;
+  KISSAT_assert (a->analyzed);
+  PUSH_STACK (solver->clause, lit);
+  LOG ("learned literal %s", LOGLIT (lit));
+  frame *f = frames + level;
+  if (f->used++)
+    return false;
+  LOG ("pulling in decision level %u", level);
+  PUSH_STACK (solver->levels, level);
+  return false;
+}
+
+clause *kissat_deduce_first_uip_clause (kissat *solver, clause *conflict) {
+  START (deduce);
+  KISSAT_assert (EMPTY_STACK (solver->analyzed));
+  KISSAT_assert (EMPTY_STACK (solver->levels));
+  KISSAT_assert (EMPTY_STACK (solver->clause));
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  CLEAR_STACK (solver->resolvent);
+#endif
+  if (conflict->size > 2)
+    mark_clause_as_used (solver, conflict);
+  PUSH_STACK (solver->clause, INVALID_LIT);
+  solver->antecedent_size = 0;
+  solver->resolvent_size = 0;
+  unsigned unresolved_on_current_level = 0, conflict_size = 0;
+  assigned *all_assigned = solver->assigned;
+  frame *frames = BEGIN_STACK (solver->frames);
+  for (all_literals_in_clause (lit, conflict)) {
+    KISSAT_assert (VALUE (lit) < 0);
+    if (LEVEL (lit))
+      conflict_size++;
+    if (analyze_literal (solver, all_assigned, frames, lit))
+      unresolved_on_current_level++;
+  }
+  KISSAT_assert (unresolved_on_current_level > 1);
+  LOG ("starting with %u unresolved literals on current decision level",
+       unresolved_on_current_level);
+  KISSAT_assert (solver->antecedent_size == solver->resolvent_size);
+  LOGRES2 ("initial");
+  const bool otfs = GET_OPTION (otfs);
+  unsigned const *t = END_ARRAY (solver->trail);
+  unsigned uip = INVALID_LIT;
+  unsigned resolved = 0;
+  assigned *a = 0;
+  for (;;) {
+    do {
+      KISSAT_assert (t > BEGIN_ARRAY (solver->trail));
+      uip = *--t;
+      a = ASSIGNED (uip);
+    } while (!a->analyzed || a->level != solver->level);
+    if (unresolved_on_current_level == 1)
+      break;
+    KISSAT_assert (a->reason != DECISION_REASON);
+    KISSAT_assert (a->level == solver->level);
+    solver->antecedent_size = 1;
+    resolved++;
+    if (a->binary) {
+      const unsigned other = a->reason;
+      LOGBINARY (uip, other, "resolving %s reason", LOGLIT (uip));
+      if (analyze_literal (solver, all_assigned, frames, other))
+        unresolved_on_current_level++;
+    } else {
+      const reference ref = a->reason;
+      LOGREF (ref, "resolving %s reason", LOGLIT (uip));
+      clause *reason = kissat_dereference_clause (solver, ref);
+      for (all_literals_in_clause (lit, reason))
+        if (lit != uip &&
+            analyze_literal (solver, all_assigned, frames, lit))
+          unresolved_on_current_level++;
+      mark_clause_as_used (solver, reason);
+    }
+    KISSAT_assert (unresolved_on_current_level > 0);
+    unresolved_on_current_level--;
+    LOG ("after resolving %s there are %u literals left "
+         "on current decision level",
+         LOGLIT (uip), unresolved_on_current_level);
+    KISSAT_assert (solver->resolvent_size > 0);
+    solver->resolvent_size--;
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+    LOG2 ("actual antecedent size %u", solver->antecedent_size);
+    REMOVE_STACK (unsigned, solver->resolvent, NOT (uip));
+    KISSAT_assert (SIZE_STACK (solver->resolvent) == solver->resolvent_size);
+    LOGRES2 ("new");
+#endif
+    if (otfs && solver->antecedent_size > 2 &&
+        solver->resolvent_size < solver->antecedent_size) {
+      KISSAT_assert (!a->binary);
+      KISSAT_assert (solver->antecedent_size && solver->resolvent_size + 1);
+      clause *reason = kissat_dereference_clause (solver, a->reason);
+      KISSAT_assert (!reason->garbage);
+      clause *res = kissat_on_the_fly_strengthen (solver, reason, uip);
+      if (resolved == 1 && solver->resolvent_size < conflict_size) {
+        KISSAT_assert (!conflict->garbage);
+        KISSAT_assert (conflict_size > 2);
+        kissat_on_the_fly_subsume (solver, res, conflict);
+      }
+      STOP (deduce);
+      return res;
+    }
+  }
+  KISSAT_assert (uip != INVALID_LIT);
+  LOG ("first unique implication point %s (1st UIP)", LOGLIT (uip));
+  KISSAT_assert (PEEK_STACK (solver->clause, 0) == INVALID_LIT);
+  POKE_STACK (solver->clause, 0, NOT (uip));
+  LOGTMP ("deduced not yet minimized 1st UIP");
+  if (!solver->probing)
+    ADD (literals_deduced, SIZE_STACK (solver->clause));
+  STOP (deduce);
+  return 0;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/deduce.h b/src/sat/kissat/deduce.h
new file mode 100644
index 000000000..1783ce955
--- /dev/null
+++ b/src/sat/kissat/deduce.h
@@ -0,0 +1,19 @@
+#ifndef _deduce_h_INCLUDED
+#define _deduce_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct clause;
+struct kissat;
+
+struct clause *kissat_deduce_first_uip_clause (struct kissat *,
+                                               struct clause *);
+
+bool kissat_recompute_and_promote (struct kissat *, struct clause *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/definition.c b/src/sat/kissat/definition.c
new file mode 100644
index 000000000..a444ef516
--- /dev/null
+++ b/src/sat/kissat/definition.c
@@ -0,0 +1,234 @@
+#include "definition.h"
+#include "allocate.h"
+#include "gates.h"
+#include "inline.h"
+#include "kitten.h"
+#include "print.h"
+
+ABC_NAMESPACE_IMPL_START
+
+typedef struct definition_extractor definition_extractor;
+
+struct definition_extractor {
+  unsigned lit;
+  kissat *solver;
+  watches *watches[2];
+};
+
+static void traverse_definition_core (void *state, unsigned id) {
+  definition_extractor *extractor = (definition_extractor*)state;
+  kissat *solver = extractor->solver;
+  watch watch;
+  watches *watches0 = extractor->watches[0];
+  watches *watches1 = extractor->watches[1];
+  const size_t size_watches0 = SIZE_WATCHES (*watches0);
+  KISSAT_assert (size_watches0 <= UINT_MAX);
+  unsigned sign;
+  if (id < size_watches0) {
+    watch = BEGIN_WATCHES (*watches0)[id];
+    LOGWATCH (extractor->lit, watch, "gate[0]");
+    sign = 0;
+  } else {
+    unsigned tmp = id - size_watches0;
+#ifndef KISSAT_NDEBUG
+    const size_t size_watches1 = SIZE_WATCHES (*watches1);
+    KISSAT_assert (size_watches1 <= UINT_MAX);
+    KISSAT_assert (tmp < size_watches1);
+#endif
+    watch = BEGIN_WATCHES (*watches1)[tmp];
+    LOGWATCH (NOT (extractor->lit), watch, "gate[1]");
+    sign = 1;
+  }
+  PUSH_STACK (solver->gates[sign], watch);
+}
+
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS)
+
+typedef struct lemma_extractor lemma_extractor;
+
+struct lemma_extractor {
+  kissat *solver;
+  unsigned lemmas;
+  unsigned unit;
+};
+
+static void traverse_one_sided_core_lemma (void *state, bool learned,
+                                           size_t size,
+                                           const unsigned *lits) {
+  if (!learned)
+    return;
+  lemma_extractor *extractor = (lemma_extractor*)state;
+  kissat *solver = extractor->solver;
+  const unsigned unit = extractor->unit;
+  unsigneds *added = &solver->added;
+  KISSAT_assert (extractor->lemmas || EMPTY_STACK (*added));
+  if (size) {
+    PUSH_STACK (*added, size + 1);
+    const size_t offset = SIZE_STACK (*added);
+    PUSH_STACK (*added, unit);
+    const unsigned *end = lits + size;
+    for (const unsigned *p = lits; p != end; p++)
+      PUSH_STACK (*added, *p);
+    unsigned *extended = &PEEK_STACK (*added, offset);
+    KISSAT_assert (offset + size + 1 == SIZE_STACK (*added));
+    CHECK_AND_ADD_LITS (size + 1, extended);
+    ADD_LITS_TO_PROOF (size + 1, extended);
+  } else {
+    kissat_learned_unit (solver, unit);
+    const unsigned *end = END_STACK (*added);
+    unsigned *begin = BEGIN_STACK (*added);
+    for (unsigned *p = begin, size; p != end; p += size) {
+      size = *p++;
+      KISSAT_assert (p + size <= end);
+      REMOVE_CHECKER_LITS (size, p);
+      DELETE_LITS_FROM_PROOF (size, p);
+    }
+    CLEAR_STACK (*added);
+  }
+  extractor->lemmas++;
+}
+
+#endif
+
+bool kissat_find_definition (kissat *solver, unsigned lit) {
+  if (!GET_OPTION (definitions))
+    return false;
+  START (definition);
+  struct kitten *kitten = solver->kitten;
+  KISSAT_assert (kitten);
+  kitten_clear (kitten);
+  const unsigned not_lit = NOT (lit);
+  definition_extractor extractor;
+  extractor.lit = lit;
+  extractor.solver = solver;
+  extractor.watches[0] = &WATCHES (lit);
+  extractor.watches[1] = &WATCHES (not_lit);
+  kitten_track_antecedents (kitten);
+  unsigned exported = 0;
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG)
+  size_t occs[2] = {0, 0};
+#endif
+  for (unsigned sign = 0; sign < 2; sign++) {
+    const unsigned except = sign ? not_lit : lit;
+    for (all_binary_large_watches (watch, *extractor.watches[sign])) {
+      if (watch.type.binary) {
+        const unsigned other = watch.binary.lit;
+        kitten_clause_with_id_and_exception (kitten, exported, 1, &other,
+                                             INVALID_LIT);
+      } else {
+        const reference ref = watch.large.ref;
+        clause *c = kissat_dereference_clause (solver, ref);
+        kitten_clause_with_id_and_exception (kitten, exported, c->size,
+                                             c->lits, except);
+      }
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG)
+      occs[sign]++;
+#endif
+      exported++;
+    }
+  }
+  bool res = false;
+  LOG ("exported %u = %zu + %zu environment clauses to sub-solver",
+       exported, occs[0], occs[1]);
+  INC (definitions_checked);
+  const size_t limit = GET_OPTION (definitionticks);
+  kitten_set_ticks_limit (kitten, limit);
+  int status = kitten_solve (kitten);
+  if (status == 20) {
+    LOG ("sub-solver result UNSAT shows definition exists");
+    uint64_t learned;
+    unsigned reduced = kitten_compute_clausal_core (kitten, &learned);
+    LOG ("1st sub-solver core of size %u original clauses out of %u",
+         reduced, exported);
+    for (int i = 2; i <= GET_OPTION (definitioncores); i++) {
+      kitten_shrink_to_clausal_core (kitten);
+      kitten_shuffle_clauses (kitten);
+      kitten_set_ticks_limit (kitten, 10 * limit);
+      int tmp = kitten_solve (kitten);
+      KISSAT_assert (!tmp || tmp == 20);
+      if (!tmp) {
+        LOG ("aborting core extraction");
+        goto ABORT;
+      }
+#ifndef KISSAT_NDEBUG
+      unsigned previous = reduced;
+#endif
+      reduced = kitten_compute_clausal_core (kitten, &learned);
+      LOG ("%s sub-solver core of size %u original clauses out of %u",
+           FORMAT_ORDINAL (i), reduced, exported);
+      KISSAT_assert (reduced <= previous);
+#if defined(KISSAT_QUIET) && defined(KISSAT_NDEBUG)
+      (void) reduced;
+#endif
+    }
+    INC (definitions_extracted);
+    kitten_traverse_core_ids (kitten, &extractor, traverse_definition_core);
+    size_t size[2];
+    size[0] = SIZE_STACK (solver->gates[0]);
+    size[1] = SIZE_STACK (solver->gates[1]);
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG)
+    KISSAT_assert (reduced == size[0] + size[1]);
+#ifdef METRICS
+    kissat_extremely_verbose (
+        solver,
+        "definition extracted[%" PRIu64 "] "
+        "size %u = %zu + %zu clauses %.0f%% "
+        "of %u = %zu + %zu (checked %" PRIu64 ")",
+        solver->statistics.definitions_extracted, reduced, size[0], size[1],
+        kissat_percent (reduced, exported), exported, occs[0], occs[1],
+        solver->statistics.definitions_checked);
+#else
+    kissat_extremely_verbose (solver,
+                              "definition extracted with core "
+                              "size %u = %zu + %zu clauses %.0f%% "
+                              "of %u = %zu + %zu",
+                              reduced, size[0], size[1],
+                              kissat_percent (reduced, exported), exported,
+                              occs[0], occs[1]);
+#endif
+#endif
+    unsigned unit = INVALID_LIT;
+    if (!size[0]) {
+      unit = not_lit;
+      KISSAT_assert (size[1]);
+    } else if (!size[1])
+      unit = lit;
+
+    if (unit != INVALID_LIT) {
+      INC (definition_units);
+
+      kissat_extremely_verbose (solver, "one sided core "
+                                        "definition extraction yields "
+                                        "failed literal");
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS)
+      if (false
+#ifndef KISSAT_NDEBUG
+          || GET_OPTION (check) > 1
+#endif
+#ifndef KISSAT_NPROOFS
+          || solver->proof
+#endif
+      ) {
+        lemma_extractor extractor;
+        extractor.solver = solver;
+        extractor.unit = unit;
+        extractor.lemmas = 0;
+        kitten_traverse_core_clauses (kitten, &extractor,
+                                      traverse_one_sided_core_lemma);
+      } else
+#endif
+        kissat_learned_unit (solver, unit);
+    }
+    solver->gate_eliminated = GATE_ELIMINATED (definitions);
+    solver->resolve_gate = true;
+    res = true;
+  } else {
+  ABORT:
+    LOG ("sub-solver failed to show that definition exists");
+  }
+  CLEAR_STACK (solver->analyzed);
+  STOP (definition);
+  return res;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/definition.h b/src/sat/kissat/definition.h
new file mode 100644
index 000000000..9d87de466
--- /dev/null
+++ b/src/sat/kissat/definition.h
@@ -0,0 +1,15 @@
+#ifndef _definition_h_INCLUDED
+#define _definition_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_find_definition (struct kissat *, unsigned lit);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/dense.c b/src/sat/kissat/dense.c
new file mode 100644
index 000000000..65c668cbc
--- /dev/null
+++ b/src/sat/kissat/dense.c
@@ -0,0 +1,239 @@
+#define INLINE_SORT
+
+#include "dense.h"
+#include "inline.h"
+#include "proprobe.h"
+#include "propsearch.h"
+#include "trail.h"
+
+#include "sort.c"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void flush_large_watches (kissat *solver, litpairs *irredundant) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (solver->watching);
+#ifndef LOGGING
+  LOG ("flushing large watches");
+  if (irredundant)
+    LOG ("flushing and saving irredundant binary clauses too");
+  else
+    LOG ("keep watching irredundant binary clauses");
+#endif
+  const value *const values = solver->values;
+  mark *const marks = solver->marks;
+#ifndef KISSAT_NDEBUG
+  for (all_literals (lit))
+    KISSAT_assert (!marks[lit]);
+#endif
+  size_t flushed = 0, collected = 0;
+#ifdef LOGGING
+  size_t deduplicated = 0;
+#endif
+  watches *all_watches = solver->watches;
+  unsigneds *marked = &solver->analyzed;
+  for (all_literals (lit)) {
+    const value lit_value = values[lit];
+    watches *watches = all_watches + lit;
+    watch *begin = BEGIN_WATCHES (*watches), *q = begin;
+    const watch *const end_watches = END_WATCHES (*watches), *p = q;
+    KISSAT_assert (EMPTY_STACK (*marked));
+    while (p != end_watches) {
+      const watch watch = *p++;
+      if (watch.type.binary) {
+        const unsigned other = watch.binary.lit;
+        const value other_value = values[other];
+        if (!lit_value && !other_value) {
+          const mark mark = marks[other];
+          if (mark) {
+            if (lit < other) {
+              kissat_delete_binary (solver, lit, other);
+#ifdef LOGGING
+              deduplicated++;
+#endif
+            }
+          } else {
+            marks[other] = 1;
+            PUSH_STACK (*marked, other);
+            if (irredundant) {
+              const unsigned other = watch.binary.lit;
+              if (lit < other) {
+                const litpair litpair = {.lits = {lit, other}};
+                PUSH_STACK (*irredundant, litpair);
+              }
+            } else
+              *q++ = watch;
+          }
+        } else {
+          KISSAT_assert (lit_value > 0 || other_value > 0);
+          if (lit < other) {
+            kissat_delete_binary (solver, lit, other);
+            collected++;
+          }
+        }
+      } else {
+        flushed++;
+        p++;
+      }
+    }
+    if (irredundant)
+      memset (watches, 0, sizeof *watches);
+    else
+      SET_END_OF_WATCHES (*watches, q);
+    for (all_stack (unsigned, other, *marked))
+      marks[other] = 0;
+    CLEAR_ARRAY (*marked);
+  }
+  KISSAT_assert (EMPTY_STACK (*marked));
+  LOG ("flushed %zu large watches", flushed);
+  LOG ("removed %zu duplicated binary clauses", deduplicated);
+  LOG ("collected %zu satisfied binary clauses", collected);
+  if (irredundant) {
+    LOG ("saved %zu irredundant binary clauses", SIZE_STACK (*irredundant));
+    kissat_release_vectors (solver);
+  }
+  (void) collected;
+  (void) flushed;
+}
+
+void kissat_enter_dense_mode (kissat *solver, litpairs *irredundant) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (kissat_propagated (solver));
+  LOG ("entering dense mode with full occurrence lists");
+  if (irredundant)
+    flush_large_watches (solver, irredundant);
+  else
+    kissat_flush_large_watches (solver);
+  LOG ("switched to full occurrence lists");
+  solver->watching = false;
+}
+
+static void resume_watching_irredundant_binaries (kissat *solver,
+                                                  litpairs *binaries) {
+  KISSAT_assert (binaries);
+#ifdef LOGGING
+  size_t resumed_watching = 0;
+#endif
+  watches *all_watches = solver->watches;
+  for (all_stack (litpair, litpair, *binaries)) {
+    const unsigned first = litpair.lits[0];
+    const unsigned second = litpair.lits[1];
+
+    KISSAT_assert (!ELIMINATED (IDX (first)));
+    KISSAT_assert (!ELIMINATED (IDX (second)));
+
+    watches *first_watches = all_watches + first;
+    watch first_watch = kissat_binary_watch (second);
+    PUSH_WATCHES (*first_watches, first_watch);
+
+    watches *second_watches = all_watches + second;
+    watch second_watch = kissat_binary_watch (first);
+    PUSH_WATCHES (*second_watches, second_watch);
+
+#ifdef LOGGING
+    resumed_watching++;
+#endif
+  }
+  LOG ("resumed watching %zu binary clauses", resumed_watching);
+}
+
+static void
+resume_watching_large_clauses_after_elimination (kissat *solver) {
+#ifdef LOGGING
+  size_t resumed_watching_redundant = 0;
+  size_t resumed_watching_irredundant = 0;
+#endif
+  const flags *const flags = solver->flags;
+  watches *watches = solver->watches;
+  const value *const values = solver->values;
+  const assigned *const assigned = solver->assigned;
+  ward *const arena = BEGIN_STACK (solver->arena);
+
+  for (all_clauses (c)) {
+    if (c->garbage)
+      continue;
+    bool collect = false;
+    for (all_literals_in_clause (lit, c)) {
+      if (values[lit] > 0) {
+        LOGCLS (c, "%s satisfied", LOGLIT (lit));
+        collect = true;
+        break;
+      }
+      const unsigned idx = IDX (lit);
+      if (flags[idx].eliminated) {
+        LOGCLS (c, "containing eliminated %s", LOGLIT (lit));
+        collect = true;
+        break;
+      }
+    }
+    if (collect) {
+      kissat_mark_clause_as_garbage (solver, c);
+      continue;
+    }
+
+    KISSAT_assert (c->size > 2);
+
+    unsigned *lits = c->lits;
+    kissat_sort_literals (solver, values, assigned, c->size, lits);
+    c->searched = 2;
+
+    const reference ref = (ward *) c - arena;
+    const unsigned l0 = lits[0];
+    const unsigned l1 = lits[1];
+
+    kissat_push_blocking_watch (solver, watches + l0, l1, ref);
+    kissat_push_blocking_watch (solver, watches + l1, l0, ref);
+
+#ifdef LOGGING
+    if (c->redundant)
+      resumed_watching_redundant++;
+    else
+      resumed_watching_irredundant++;
+#endif
+  }
+  LOG ("resumed watching %zu irredundant and %zu redundant large clauses",
+       resumed_watching_irredundant, resumed_watching_redundant);
+}
+
+void kissat_resume_sparse_mode (kissat *solver, bool flush_eliminated,
+                                litpairs *irredundant) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->watching);
+  if (solver->inconsistent)
+    return;
+  LOG ("resuming sparse mode watching clauses");
+  kissat_flush_large_connected (solver);
+  LOG ("switched to watching clauses");
+  solver->watching = true;
+  if (irredundant) {
+    LOG ("resuming watching %zu irredundant binaries",
+         SIZE_STACK (*irredundant));
+    resume_watching_irredundant_binaries (solver, irredundant);
+  }
+  if (flush_eliminated)
+    resume_watching_large_clauses_after_elimination (solver);
+  else
+    kissat_watch_large_clauses (solver);
+  LOG ("forcing to propagate units on all clauses");
+  kissat_reset_propagate (solver);
+
+  clause *conflict;
+  if (solver->probing)
+    conflict = kissat_probing_propagate (solver, 0, true);
+  else
+    conflict = kissat_search_propagate (solver);
+
+#ifndef KISSAT_NDEBUG
+  if (conflict)
+    KISSAT_assert (solver->inconsistent);
+  else
+    KISSAT_assert (kissat_trail_flushed (solver));
+#else
+  (void) conflict;
+#endif
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/dense.h b/src/sat/kissat/dense.h
new file mode 100644
index 000000000..225d7367d
--- /dev/null
+++ b/src/sat/kissat/dense.h
@@ -0,0 +1,17 @@
+#ifndef _dense_h_INCLUDED
+#define _dense_h_INCLUDED
+
+#include "watch.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+void kissat_enter_dense_mode (struct kissat *,
+                              litpairs *saved_irredundant_binary_clauses);
+
+void kissat_resume_sparse_mode (struct kissat *, bool flush_eliminated,
+                                litpairs *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/dump.c b/src/sat/kissat/dump.c
new file mode 100644
index 000000000..104ca2e47
--- /dev/null
+++ b/src/sat/kissat/dump.c
@@ -0,0 +1,301 @@
+#include "global.h"
+
+#ifndef KISSAT_NDEBUG
+
+#include "inline.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void dump_literal (kissat *solver, unsigned ilit) {
+  const int elit = kissat_export_literal (solver, ilit);
+  printf ("%u(%d)", ilit, elit);
+  const int value = VALUE (ilit);
+  if (value) {
+    const unsigned ilit_level = LEVEL (ilit);
+    printf ("@%u=%d", ilit_level, value);
+  }
+}
+
+static void dump_binary (kissat *solver, unsigned a, unsigned b) {
+  printf ("binary clause ");
+  dump_literal (solver, a);
+  fputc (' ', stdout);
+  dump_literal (solver, b);
+  fputc ('\n', stdout);
+}
+
+static void dump_clause (kissat *solver, clause *c) {
+  if (c->redundant)
+    printf ("redundant glue %u", c->glue);
+  else
+    printf ("irredundant");
+  const reference ref = kissat_reference_clause (solver, c);
+  if (c->garbage)
+    printf (" garbage");
+  printf (" clause[%u]", ref);
+  for (all_literals_in_clause (lit, c)) {
+    fputc (' ', stdout);
+    dump_literal (solver, lit);
+  }
+  fputc ('\n', stdout);
+}
+
+static void dump_ref (kissat *solver, reference ref) {
+  clause *c = kissat_dereference_clause (solver, ref);
+  dump_clause (solver, c);
+}
+
+static void dump_trail (kissat *solver) {
+  unsigned prev = 0;
+  for (unsigned level = 0; level <= solver->level; level++) {
+    frame *frame = &FRAME (level);
+    unsigned next;
+    if (level < solver->level)
+      next = frame[1].trail;
+    else
+      next = SIZE_ARRAY (solver->trail);
+    if (next == prev)
+      printf ("frame[%u] has no assignments\n", level);
+    else {
+      printf ("frame[%u] has %u assignments\n", level, next - prev);
+      if (prev < next)
+        printf ("block[%u] = trail[%u..%u]\n", level, prev, next - 1);
+    }
+    for (unsigned i = prev; i < next; i++) {
+      printf ("trail[%u] ", i);
+      const unsigned lit = PEEK_ARRAY (solver->trail, i);
+      dump_literal (solver, lit);
+      const unsigned lit_level = LEVEL (lit);
+      KISSAT_assert (lit_level <= level);
+      if (lit_level < level)
+        printf (" out-of-order");
+      assigned *a = ASSIGNED (lit);
+      if (!lit_level) {
+        printf (" UNIT\n");
+        KISSAT_assert (!a->binary);
+        KISSAT_assert (a->reason == UNIT_REASON);
+      } else {
+        fputc (' ', stdout);
+        if (a->binary) {
+          const unsigned other = a->reason;
+          dump_binary (solver, lit, other);
+        } else if (a->reason == DECISION_REASON)
+          printf ("DECISION\n");
+        else {
+          KISSAT_assert (a->reason != UNIT_REASON);
+          const reference ref = a->reason;
+          dump_ref (solver, ref);
+        }
+      }
+    }
+    prev = next;
+  }
+}
+
+static void dump_values (kissat *solver) {
+  for (unsigned idx = 0; idx < VARS; idx++) {
+    unsigned lit = LIT (idx);
+    int value = solver->values[lit];
+    printf ("val[%u] = ", lit);
+    if (!value)
+      printf ("unassigned\n");
+    else
+      printf ("%d\n", value);
+  }
+}
+
+static void dump_queue (kissat *solver) {
+  const queue *const queue = &solver->queue;
+  printf ("queue: first %u, last %u, stamp %u, search %u (stamp %u)\n",
+          queue->first, queue->last, queue->stamp, queue->search.idx,
+          queue->search.stamp);
+  const links *const links = solver->links;
+  for (unsigned idx = queue->first; !DISCONNECTED (idx);
+       idx = links[idx].next) {
+    const struct links *l = links + idx;
+    printf ("%u ( prev %u, next %u, stamp %u )\n", idx, l->prev, l->next,
+            l->stamp);
+  }
+}
+
+static void dump_scores (kissat *solver) {
+  heap *heap = SCORES;
+  printf ("scores.vars = %u\n", heap->vars);
+  printf ("scores.size = %u\n", heap->size);
+  for (unsigned i = 0; i < SIZE_STACK (heap->stack); i++)
+    printf ("scores.stack[%u] = %u\n", i, PEEK_STACK (heap->stack, i));
+  for (unsigned i = 0; i < heap->vars; i++)
+    printf ("scores.score[%u] = %g\n", i, heap->score[i]);
+  for (unsigned i = 0; i < heap->vars; i++)
+    printf ("scores.pos[%u] = %u\n", i, heap->pos[i]);
+}
+
+static void dump_export (kissat *solver) {
+  const unsigned size = SIZE_STACK (solver->export_);
+  for (unsigned idx = 0; idx < size; idx++)
+    printf ("export[%u] = %u\n", LIT (idx),
+            PEEK_STACK (solver->export_, idx));
+}
+
+void dump_map (kissat *solver) {
+  const unsigned size = SIZE_STACK (solver->export_);
+  unsigned first = INVALID_LIT;
+  for (unsigned idx = 0; idx < size; idx++) {
+    const unsigned ilit = LIT (idx);
+    const int elit = PEEK_STACK (solver->export_, idx);
+    printf ("map[%u] -> %d", ilit, elit);
+    if (elit) {
+      const unsigned eidx = ABS (elit);
+      const import *const import = &PEEK_STACK (solver->import, eidx);
+      if (import->eliminated)
+        printf (" -> eliminated[%u]", import->lit);
+      else {
+        unsigned mlit = import->lit;
+        if (elit < 0)
+          mlit = NOT (mlit);
+        printf (" -> %u", mlit);
+      }
+    }
+    if (!LEVEL (ilit) && VALUE (ilit)) {
+      if (first == INVALID_LIT) {
+        first = ilit;
+        printf (" #");
+      } else
+        printf (" *");
+    }
+    fputc ('\n', stdout);
+  }
+}
+
+static void dump_import (kissat *solver) {
+  const unsigned size = SIZE_STACK (solver->import);
+  for (unsigned idx = 1; idx < size; idx++) {
+    import *import = &PEEK_STACK (solver->import, idx);
+    printf ("import[%u] = ", idx);
+    if (!import->imported)
+      printf ("undefined\n");
+    else if (import->eliminated) {
+      unsigned pos = import->lit;
+      printf ("eliminated[%u]", pos);
+      if (pos < SIZE_STACK (solver->eliminated)) {
+        int value = PEEK_STACK (solver->eliminated, pos);
+        if (value)
+          printf (" (assigned to %d)", value);
+      }
+      fputc ('\n', stdout);
+    } else
+      printf ("%u\n", import->lit);
+  }
+}
+
+static void dump_etrail (kissat *solver) {
+  for (unsigned i = 0; i < SIZE_STACK (solver->etrail); i++)
+    printf ("etrail[%u] = %d\n", i, (int) PEEK_STACK (solver->etrail, i));
+}
+
+static void dump_extend (kissat *solver) {
+  const extension *const begin = BEGIN_STACK (solver->extend);
+  const extension *const end = END_STACK (solver->extend);
+  for (const extension *p = begin, *q; p != end; p = q) {
+    KISSAT_assert (p->blocking);
+    printf ("extend[%zu] %d", (size_t) (p - begin), p->lit);
+    if (!p[1].blocking)
+      fputs (" :", stdout);
+    for (q = p + 1; q != end && !q->blocking; q++)
+      printf (" %d", q->lit);
+    fputc ('\n', stdout);
+  }
+}
+
+static void dump_binaries (kissat *solver) {
+  for (all_literals (lit)) {
+    if (solver->watching) {
+      for (all_binary_blocking_watches (watch, WATCHES (lit))) {
+        if (!watch.type.binary)
+          continue;
+        const unsigned other = watch.binary.lit;
+        if (lit > other)
+          continue;
+        dump_binary (solver, lit, other);
+      }
+    } else {
+      for (all_binary_large_watches (watch, WATCHES (lit))) {
+        if (!watch.type.binary)
+          continue;
+        const unsigned other = watch.binary.lit;
+        if (lit > other)
+          continue;
+        dump_binary (solver, lit, other);
+      }
+    }
+  }
+}
+
+static void dump_clauses (kissat *solver) {
+  for (all_clauses (c))
+    dump_clause (solver, c);
+}
+
+void kissat_dump_vectors (kissat *solver) {
+  vectors *vectors = &solver->vectors;
+  unsigneds *stack = &vectors->stack;
+  printf ("vectors.size = %zu\n", SIZE_STACK (*stack));
+  printf ("vectors.capacity = %zu\n", CAPACITY_STACK (*stack));
+  printf ("vectors.usable = %zu\n", vectors->usable);
+  const unsigned *const begin = BEGIN_STACK (*stack);
+  const unsigned *const end = END_STACK (*stack);
+  if (begin == end)
+    return;
+  fputc ('-', stdout);
+  for (const unsigned *p = begin + 1; p != end; p++)
+    if (*p == INVALID_LIT)
+      fputs (" -", stdout);
+    else
+      printf (" %u", *p);
+  fputc ('\n', stdout);
+}
+
+int kissat_dump (kissat *solver) {
+  if (!solver)
+    return 0;
+  printf ("vars = %u\n", solver->vars);
+  printf ("size = %u\n", solver->size);
+  printf ("level = %u\n", solver->level);
+  printf ("active = %u\n", solver->active);
+  printf ("assigned = %u\n", kissat_assigned (solver));
+  printf ("unassigned = %u\n", solver->unassigned);
+  dump_import (solver);
+  dump_export (solver);
+#ifdef LOGGING
+  if (solver->compacting)
+    dump_map (solver);
+#endif
+  dump_etrail (solver);
+  dump_extend (solver);
+  dump_trail (solver);
+  printf ("stable = %u\n", (unsigned) solver->stable);
+  if (solver->stable)
+    dump_scores (solver);
+  else
+    dump_queue (solver);
+  dump_values (solver);
+  printf ("binary = %" PRIu64 "\n", solver->statistics_.clauses_binary);
+  printf ("irredundant = %" PRIu64 "\n",
+          solver->statistics_.clauses_irredundant);
+  printf ("redundant = %" PRIu64 "\n",
+          solver->statistics_.clauses_redundant);
+  dump_binaries (solver);
+  dump_clauses (solver);
+  dump_extend (solver);
+  return 0;
+}
+
+ABC_NAMESPACE_IMPL_END
+
+#else
+ABC_NAMESPACE_IMPL_START
+int kissat_dump_dummy_to_avoid_warning;
+ABC_NAMESPACE_IMPL_END
+#endif
diff --git a/src/sat/kissat/eliminate.c b/src/sat/kissat/eliminate.c
new file mode 100644
index 000000000..7b3bb713f
--- /dev/null
+++ b/src/sat/kissat/eliminate.c
@@ -0,0 +1,607 @@
+#include "eliminate.h"
+#include "allocate.h"
+#include "backtrack.h"
+#include "collect.h"
+#include "dense.h"
+#include "forward.h"
+#include "inline.h"
+#include "inlineheap.h"
+#include "kitten.h"
+#include "print.h"
+#include "propdense.h"
+#include "report.h"
+#include "resolve.h"
+#include "terminate.h"
+#include "trail.h"
+#include "weaken.h"
+
+#include <inttypes.h>
+#include <math.h>
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_eliminating (kissat *solver) {
+  if (!solver->enabled.eliminate)
+    return false;
+  statistics *statistics = &solver->statistics_;
+  if (!statistics->clauses_irredundant)
+    return false;
+  const uint64_t conflicts = statistics->conflicts;
+  if (solver->last.conflicts.reduce == conflicts)
+    return false;
+  limits *limits = &solver->limits;
+  if (limits->eliminate.conflicts > conflicts)
+    return false;
+  if (limits->eliminate.variables.eliminate <
+      statistics->variables_eliminate)
+    return true;
+  if (limits->eliminate.variables.subsume < statistics->variables_subsume)
+    return true;
+  return false;
+}
+
+static inline double variable_score (kissat *solver, unsigned idx) {
+  const unsigned lit = LIT (idx);
+  const unsigned not_lit = NOT (lit);
+  size_t occlim = GET_OPTION (eliminateocclim);
+  size_t pos = SIZE_WATCHES (WATCHES (lit));
+  size_t neg = SIZE_WATCHES (WATCHES (not_lit));
+  if (pos > occlim)
+    pos = occlim;
+  if (neg > occlim)
+    neg = occlim;
+  double prod = pos * neg;
+  double sum = pos + neg;
+  double occlim2 = occlim * (double) occlim;
+  KISSAT_assert (prod <= occlim2);
+  double score = prod - sum;
+  KISSAT_assert (score <= occlim2);
+  double relevancy;
+  if (solver->stable)
+    relevancy = kissat_get_heap_score (&solver->scores, idx);
+  else
+    relevancy = LINK (idx).stamp;
+  double res = relevancy + score - occlim2;
+  LOG ("variable score of %s computed as "
+       "%g = %g + (%zu*%zu - %zu - %zu) - %g"
+       " = %g + %g - %g",
+       LOGVAR (idx), res, relevancy, pos, neg, pos, neg, occlim2, relevancy,
+       score, occlim2);
+  return res;
+}
+
+static inline void update_variable_score (kissat *solver, heap *schedule,
+                                          unsigned idx) {
+  KISSAT_assert (schedule->size);
+  KISSAT_assert (schedule == &solver->schedule);
+  double new_score = variable_score (solver, idx);
+  LOG ("new score %g for variable %s", new_score, LOGVAR (idx));
+  kissat_update_heap (solver, schedule, idx, -new_score);
+}
+
+void kissat_update_variable_score (kissat *solver, unsigned idx) {
+  update_variable_score (solver, &solver->schedule, idx);
+}
+
+static inline void update_after_adding_stack (kissat *solver,
+                                              unsigneds *stack) {
+  KISSAT_assert (!solver->probing);
+  heap *schedule = &solver->schedule;
+  if (!schedule->size)
+    return;
+  for (all_stack (unsigned, lit, *stack))
+    update_variable_score (solver, schedule, IDX (lit));
+}
+
+static inline void update_after_removing_variable (kissat *solver,
+                                                   unsigned idx) {
+  heap *schedule = &solver->schedule;
+  if (!schedule->size)
+    return;
+  KISSAT_assert (!solver->probing);
+  flags *f = solver->flags + idx;
+  if (f->fixed)
+    return;
+  KISSAT_assert (!f->eliminated);
+  update_variable_score (solver, schedule, idx);
+  if (!kissat_heap_contains (schedule, idx))
+    kissat_push_heap (solver, schedule, idx);
+}
+
+static inline void update_after_removing_clause (kissat *solver, clause *c,
+                                                 unsigned except) {
+  if (!solver->schedule.size)
+    return;
+  KISSAT_assert (c->garbage);
+  for (all_literals_in_clause (lit, c))
+    if (lit != except)
+      update_after_removing_variable (solver, IDX (lit));
+}
+
+void kissat_eliminate_binary (kissat *solver, unsigned lit,
+                              unsigned other) {
+  kissat_disconnect_binary (solver, other, lit);
+  kissat_delete_binary (solver, lit, other);
+  update_after_removing_variable (solver, IDX (other));
+}
+
+void kissat_eliminate_clause (kissat *solver, clause *c, unsigned lit) {
+  kissat_mark_clause_as_garbage (solver, c);
+  update_after_removing_clause (solver, c, lit);
+}
+
+static unsigned schedule_variables (kissat *solver) {
+  LOG ("initializing variable schedule");
+  KISSAT_assert (!solver->schedule.size);
+
+  kissat_resize_heap (solver, &solver->schedule, solver->vars);
+
+  flags *all_flags = solver->flags;
+
+  size_t scheduled = 0;
+  for (all_variables (idx)) {
+    flags *flags = all_flags + idx;
+    if (!flags->active)
+      continue;
+    if (!flags->eliminate)
+      continue;
+    LOG ("scheduling %s", LOGVAR (idx));
+    scheduled++;
+    update_after_removing_variable (solver, idx);
+  }
+  KISSAT_assert (scheduled == kissat_size_heap (&solver->schedule));
+#ifndef KISSAT_QUIET
+  size_t active = solver->active;
+  kissat_phase (solver, "eliminate", GET (eliminations),
+                "scheduled %zu variables %.0f%%", scheduled,
+                kissat_percent (scheduled, active));
+#endif
+  return scheduled;
+}
+
+void kissat_flush_units_while_connected (kissat *solver) {
+  const unsigned *propagate = solver->propagate;
+  const unsigned *end_trail = END_ARRAY (solver->trail);
+  KISSAT_assert (propagate <= end_trail);
+  const size_t units = end_trail - propagate;
+  if (!units)
+    return;
+#ifdef LOGGING
+  LOG ("propagating and flushing %zu units", units);
+#endif
+  if (!kissat_dense_propagate (solver))
+    return;
+  LOG ("marking and flushing unit satisfied clauses");
+
+  end_trail = END_ARRAY (solver->trail);
+  while (propagate != end_trail) {
+    const unsigned unit = *propagate++;
+    watches *unit_watches = &WATCHES (unit);
+    watch *begin = BEGIN_WATCHES (*unit_watches), *q = begin;
+    const watch *const end = END_WATCHES (*unit_watches), *p = q;
+    if (begin == end)
+      continue;
+    LOG ("marking %s satisfied clauses as garbage", LOGLIT (unit));
+    while (p != end) {
+      const watch watch = *q++ = *p++;
+      if (watch.type.binary) {
+        const unsigned other = watch.binary.lit;
+        if (!solver->values[other])
+          update_after_removing_variable (solver, IDX (other));
+      } else {
+        const reference ref = watch.large.ref;
+        clause *c = kissat_dereference_clause (solver, ref);
+        if (!c->garbage)
+          kissat_eliminate_clause (solver, c, unit);
+        KISSAT_assert (c->garbage);
+        q--;
+      }
+    }
+    KISSAT_assert (q <= end);
+    size_t flushed = end - q;
+    if (!flushed)
+      continue;
+    LOG ("flushing %zu references satisfied by %s", flushed, LOGLIT (unit));
+    SET_END_OF_WATCHES (*unit_watches, q);
+  }
+}
+
+static void connect_resolvents (kissat *solver) {
+  const value *const values = solver->values;
+  KISSAT_assert (EMPTY_STACK (solver->clause));
+  bool satisfied = false;
+#ifdef LOGGING
+  uint64_t added = 0;
+#endif
+  for (all_stack (unsigned, other, solver->resolvents)) {
+    if (other == INVALID_LIT) {
+      if (satisfied)
+        satisfied = false;
+      else {
+        LOGTMP ("temporary resolvent");
+        const size_t size = SIZE_STACK (solver->clause);
+        if (!size) {
+          KISSAT_assert (!solver->inconsistent);
+          LOG ("resolved empty clause");
+          CHECK_AND_ADD_EMPTY ();
+          ADD_EMPTY_TO_PROOF ();
+          solver->inconsistent = true;
+          break;
+        } else if (size == 1) {
+          const unsigned unit = PEEK_STACK (solver->clause, 0);
+          LOG ("resolved unit clause %s", LOGLIT (unit));
+          kissat_learned_unit (solver, unit);
+        } else {
+          KISSAT_assert (size > 1);
+          (void) kissat_new_irredundant_clause (solver);
+          update_after_adding_stack (solver, &solver->clause);
+#ifdef LOGGING
+          added++;
+#endif
+        }
+      }
+      CLEAR_STACK (solver->clause);
+    } else if (!satisfied) {
+      const value value = values[other];
+      if (value > 0) {
+        LOGTMP ("now %s satisfied resolvent", LOGLIT (other));
+        satisfied = true;
+      } else if (value < 0)
+        LOG2 ("dropping now falsified literal %s", LOGLIT (other));
+      else
+        PUSH_STACK (solver->clause, other);
+    }
+  }
+  LOG ("added %" PRIu64 " new clauses", added);
+  CLEAR_STACK (solver->resolvents);
+}
+
+static void weaken_clauses (kissat *solver, unsigned lit) {
+  const unsigned not_lit = NOT (lit);
+
+  const value *const values = solver->values;
+  KISSAT_assert (!values[lit]);
+
+  watches *pos_watches = &WATCHES (lit);
+
+  for (all_binary_large_watches (watch, *pos_watches)) {
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      const value value = values[other];
+      if (value <= 0)
+        kissat_weaken_binary (solver, lit, other);
+      kissat_eliminate_binary (solver, lit, other);
+    } else {
+      const reference ref = watch.large.ref;
+      clause *c = kissat_dereference_clause (solver, ref);
+      if (c->garbage)
+        continue;
+      bool satisfied = false;
+      for (all_literals_in_clause (other, c)) {
+        const value value = values[other];
+        if (value <= 0)
+          continue;
+        satisfied = true;
+        break;
+      }
+      if (!satisfied)
+        kissat_weaken_clause (solver, lit, c);
+      LOGCLS (c, "removing %s", LOGLIT (lit));
+      kissat_eliminate_clause (solver, c, lit);
+    }
+  }
+  RELEASE_WATCHES (*pos_watches);
+
+  watches *neg_watches = &WATCHES (not_lit);
+
+  bool optimize = !GET_OPTION (incremental);
+  for (all_binary_large_watches (watch, *neg_watches)) {
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      const value value = values[other];
+      if (!optimize && value <= 0)
+        kissat_weaken_binary (solver, not_lit, other);
+      kissat_eliminate_binary (solver, not_lit, other);
+    } else {
+      const reference ref = watch.large.ref;
+      clause *d = kissat_dereference_clause (solver, ref);
+      if (d->garbage)
+        continue;
+      bool satisfied = false;
+      for (all_literals_in_clause (other, d)) {
+        const value value = values[other];
+        if (value <= 0)
+          continue;
+        satisfied = true;
+        break;
+      }
+      if (!optimize && !satisfied)
+        kissat_weaken_clause (solver, not_lit, d);
+      LOGCLS (d, "removing %s", LOGLIT (not_lit));
+      kissat_eliminate_clause (solver, d, not_lit);
+    }
+  }
+  if (optimize && !EMPTY_WATCHES (*neg_watches))
+    kissat_weaken_unit (solver, not_lit);
+  RELEASE_WATCHES (*neg_watches);
+
+  kissat_flush_units_while_connected (solver);
+}
+
+static void try_to_eliminate_all_variables_again (kissat *solver) {
+  LOG ("trying to elimination all variables again");
+  flags *all_flags = solver->flags;
+  for (all_variables (idx)) {
+    flags *flags = all_flags + idx;
+    flags->eliminate = true;
+  }
+  solver->limits.eliminate.variables.eliminate = 0;
+}
+
+static void set_next_elimination_bound (kissat *solver, bool complete) {
+  const unsigned max_bound = GET_OPTION (eliminatebound);
+  const unsigned current_bound =
+      solver->bounds.eliminate.additional_clauses;
+  KISSAT_assert (current_bound <= max_bound);
+
+  if (complete) {
+    if (current_bound == max_bound) {
+      kissat_phase (solver, "eliminate", GET (eliminations),
+                    "completed maximum elimination bound %u",
+                    current_bound);
+      limits *limits = &solver->limits;
+      statistics *statistics = &solver->statistics_;
+      limits->eliminate.variables.eliminate =
+          statistics->variables_eliminate;
+      limits->eliminate.variables.subsume = statistics->variables_subsume;
+#ifndef KISSAT_QUIET
+      bool first = !solver->bounds.eliminate.max_bound_completed++;
+      REPORT (!first, first ? '!' : ':');
+#endif
+    } else {
+      const unsigned next_bound =
+          !current_bound ? 1 : MIN (2 * current_bound, max_bound);
+      kissat_phase (solver, "eliminate", GET (eliminations),
+                    "completed elimination bound %u next %u", current_bound,
+                    next_bound);
+      solver->bounds.eliminate.additional_clauses = next_bound;
+      try_to_eliminate_all_variables_again (solver);
+      REPORT (0, '^');
+    }
+  } else
+    kissat_phase (solver, "eliminate", GET (eliminations),
+                  "incomplete elimination bound %u", current_bound);
+}
+
+static bool can_eliminate_variable (kissat *solver, unsigned idx) {
+  flags *flags = FLAGS (idx);
+
+  if (!flags->active)
+    return false;
+  if (!flags->eliminate)
+    return false;
+
+  return true;
+}
+
+static bool eliminate_variable (kissat *solver, unsigned idx) {
+  LOG ("next elimination candidate %s", LOGVAR (idx));
+#ifdef LOGGING
+  if (GET_OPTION (log))
+    (void) variable_score (solver, idx);
+#endif
+
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (can_eliminate_variable (solver, idx));
+
+  LOG ("marking %s as not removed", LOGVAR (idx));
+  FLAGS (idx)->eliminate = false;
+
+  unsigned lit;
+  if (!kissat_generate_resolvents (solver, idx, &lit))
+    return false;
+  connect_resolvents (solver);
+  if (!solver->inconsistent)
+    weaken_clauses (solver, lit);
+  INC (eliminated);
+  kissat_mark_eliminated_variable (solver, idx);
+  if (solver->gate_eliminated) {
+    INC (gates_eliminated);
+#ifdef METRICS
+    KISSAT_assert (*solver->gate_eliminated < UINT64_MAX);
+    *solver->gate_eliminated += 1;
+#endif
+  }
+  return true;
+}
+
+static void eliminate_variables (kissat *solver) {
+  kissat_very_verbose (solver,
+                       "trying to eliminate variables with bound %u",
+                       solver->bounds.eliminate.additional_clauses);
+  KISSAT_assert (!solver->inconsistent);
+#ifndef KISSAT_QUIET
+  unsigned before = solver->active;
+  unsigned eliminated = 0;
+  uint64_t tried = 0;
+#endif
+  unsigned last_round_eliminated = 0;
+
+  SET_EFFORT_LIMIT (resolution_limit, eliminate, eliminate_resolutions);
+
+  bool complete;
+  int round = 0;
+
+  const bool forward = GET_OPTION (forward);
+
+  for (;;) {
+    round++;
+    LOG ("starting new elimination round %d", round);
+
+    if (forward) {
+      unsigned *propagate = solver->propagate;
+      complete = kissat_forward_subsume_during_elimination (solver);
+      if (solver->inconsistent)
+        break;
+      kissat_flush_large_connected (solver);
+      kissat_connect_irredundant_large_clauses (solver);
+      solver->propagate = propagate;
+      kissat_flush_units_while_connected (solver);
+      if (solver->inconsistent)
+        break;
+    } else {
+      kissat_connect_irredundant_large_clauses (solver);
+      complete = true;
+    }
+
+#ifndef KISSAT_QUIET
+    const unsigned last_round_scheduled =
+#endif
+        schedule_variables (solver);
+    kissat_very_verbose (
+        solver,
+        "scheduled %u variables %.0f%% to eliminate "
+        "in round %d",
+        last_round_scheduled,
+        kissat_percent (last_round_scheduled, solver->active), round);
+
+    unsigned last_round_eliminated = 0;
+
+    while (!solver->inconsistent &&
+           !kissat_empty_heap (&solver->schedule)) {
+      if (TERMINATED (eliminate_terminated_1)) {
+        complete = false;
+        break;
+      }
+      unsigned idx = kissat_pop_max_heap (solver, &solver->schedule);
+      if (!can_eliminate_variable (solver, idx))
+        continue;
+      statistics *s = &solver->statistics_;
+      if (s->eliminate_resolutions > resolution_limit) {
+        kissat_extremely_verbose (
+            solver,
+            "eliminate round %u hits "
+            "resolution limit %" PRIu64 " at %" PRIu64 " resolutions",
+            round, resolution_limit, s->eliminate_resolutions);
+        complete = false;
+        break;
+      }
+#ifndef KISSAT_QUIET
+      tried++;
+#endif
+      if (eliminate_variable (solver, idx))
+        last_round_eliminated++;
+      if (solver->inconsistent)
+        break;
+      kissat_flush_units_while_connected (solver);
+    }
+
+    if (last_round_eliminated) {
+      complete = false;
+#ifndef KISSAT_QUIET
+      eliminated += last_round_eliminated;
+#endif
+    }
+
+    if (!solver->inconsistent) {
+      kissat_flush_large_connected (solver);
+      kissat_dense_collect (solver);
+    }
+
+    kissat_phase (
+        solver, "eliminate", GET (eliminations),
+        "eliminated %u variables %.0f%% in round %u", last_round_eliminated,
+        kissat_percent (last_round_eliminated, last_round_scheduled),
+        round);
+    REPORT (!last_round_eliminated, 'e');
+
+    if (solver->inconsistent)
+      break;
+    kissat_release_heap (solver, &solver->schedule);
+    if (complete)
+      break;
+    if (round == GET_OPTION (eliminaterounds))
+      break;
+    if (solver->statistics_.eliminate_resolutions > resolution_limit)
+      break;
+    if (TERMINATED (eliminate_terminated_2))
+      break;
+  }
+
+  const unsigned remain = kissat_size_heap (&solver->schedule);
+  kissat_release_heap (solver, &solver->schedule);
+#ifndef KISSAT_QUIET
+  kissat_very_verbose (solver,
+                       "eliminated %u variables %.0f%% of %" PRIu64 " tried"
+                       " (%u remain %.0f%%)",
+                       eliminated, kissat_percent (eliminated, tried),
+                       tried, remain,
+                       kissat_percent (remain, solver->active));
+  kissat_phase (solver, "eliminate", GET (eliminations),
+                "eliminated %u variables %.0f%% out of %u in %d rounds",
+                eliminated, kissat_percent (eliminated, before), before,
+                round);
+#endif
+  if (!solver->inconsistent) {
+    const bool complete = !remain && !last_round_eliminated;
+    set_next_elimination_bound (solver, complete);
+    if (!complete) {
+      const flags *end = solver->flags + VARS;
+#ifndef KISSAT_QUIET
+      unsigned dropped = 0;
+#endif
+      for (struct flags *f = solver->flags; f != end; f++)
+        if (f->eliminate) {
+          f->eliminate = false;
+#ifndef KISSAT_QUIET
+          dropped++;
+#endif
+        }
+
+      kissat_very_verbose (solver, "dropping %u eliminate candidates",
+                           dropped);
+    }
+  }
+}
+
+static void init_map_and_kitten (kissat *solver) {
+  if (!GET_OPTION (definitions))
+    return;
+  KISSAT_assert (!solver->kitten);
+  solver->kitten = kitten_embedded (solver);
+}
+
+static void reset_map_and_kitten (kissat *solver) {
+  if (solver->kitten) {
+    kitten_release (solver->kitten);
+    solver->kitten = 0;
+  }
+}
+
+static void eliminate (kissat *solver) {
+  kissat_backtrack_propagate_and_flush_trail (solver);
+  KISSAT_assert (!solver->inconsistent);
+  STOP_SEARCH_AND_START_SIMPLIFIER (eliminate);
+  kissat_phase (solver, "eliminate", GET (eliminations),
+                "elimination limit of %" PRIu64 " conflicts hit",
+                solver->limits.eliminate.conflicts);
+  init_map_and_kitten (solver);
+  kissat_enter_dense_mode (solver, 0);
+  eliminate_variables (solver);
+  kissat_resume_sparse_mode (solver, true, 0);
+  reset_map_and_kitten (solver);
+  kissat_check_statistics (solver);
+  STOP_SIMPLIFIER_AND_RESUME_SEARCH (eliminate);
+}
+
+int kissat_eliminate (kissat *solver) {
+  KISSAT_assert (!solver->inconsistent);
+  INC (eliminations);
+  eliminate (solver);
+  kissat_classify (solver);
+  UPDATE_CONFLICT_LIMIT (eliminate, eliminations, NLOG2N, true);
+  solver->last.ticks.eliminate = solver->statistics_.search_ticks;
+  return solver->inconsistent ? 20 : 0;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/eliminate.h b/src/sat/kissat/eliminate.h
new file mode 100644
index 000000000..cdc73b98b
--- /dev/null
+++ b/src/sat/kissat/eliminate.h
@@ -0,0 +1,24 @@
+#ifndef _eliminate_hpp_INCLUDED
+#define _eliminate_hpp_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+struct clause;
+struct heap;
+
+void kissat_flush_units_while_connected (struct kissat *);
+
+bool kissat_eliminating (struct kissat *);
+int kissat_eliminate (struct kissat *);
+
+void kissat_eliminate_binary (struct kissat *, unsigned, unsigned);
+void kissat_eliminate_clause (struct kissat *, struct clause *, unsigned);
+void kissat_update_variable_score (struct kissat *, unsigned idx);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/equivalences.c b/src/sat/kissat/equivalences.c
new file mode 100644
index 000000000..41bf9a34c
--- /dev/null
+++ b/src/sat/kissat/equivalences.c
@@ -0,0 +1,41 @@
+#include "gates.h"
+#include "inlinevector.h"
+#include "logging.h"
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_find_equivalence_gate (kissat *solver, unsigned lit) {
+  if (!GET_OPTION (equivalences))
+    return false;
+  if (!kissat_mark_binaries (solver, lit))
+    return false;
+  value *marks = solver->marks;
+  unsigned not_lit = NOT (lit);
+  watches *watches = &WATCHES (not_lit);
+  unsigned replace = INVALID_LIT;
+  for (all_binary_large_watches (watch, *watches)) {
+    if (!watch.type.binary)
+      continue;
+    const unsigned other = watch.binary.lit;
+    const unsigned not_other = NOT (other);
+    if (!marks[not_other])
+      continue;
+    replace = other;
+    break;
+  }
+  kissat_unmark_binaries (solver, lit);
+  if (replace == INVALID_LIT)
+    return false;
+  LOG ("found equivalence gate %s = %s", LOGLIT (lit), LOGLIT (replace));
+
+  const watch watch1 = kissat_binary_watch (replace);
+  PUSH_STACK (solver->gates[1], watch1);
+
+  const watch watch0 = kissat_binary_watch (NOT (replace));
+  PUSH_STACK (solver->gates[0], watch0);
+  solver->gate_eliminated = GATE_ELIMINATED (equivalences);
+  INC (equivalences_extracted);
+  return true;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/equivalences.h b/src/sat/kissat/equivalences.h
new file mode 100644
index 000000000..30ada11a7
--- /dev/null
+++ b/src/sat/kissat/equivalences.h
@@ -0,0 +1,15 @@
+#ifndef _equivs_h_INCLUDED
+#define _equivs_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_find_equivalence_gate (struct kissat *, unsigned lit);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/error.c b/src/sat/kissat/error.c
new file mode 100644
index 000000000..8b687e604
--- /dev/null
+++ b/src/sat/kissat/error.c
@@ -0,0 +1,66 @@
+#include "error.h"
+#include "colors.h"
+#include "cover.h"
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void (*kissat_abort_function) (void);
+
+void kissat_call_function_instead_of_abort (void (*f) (void)) {
+  kissat_abort_function = f;
+}
+
+// clang-format off
+
+void
+kissat_abort (void)
+{
+  if (kissat_abort_function)
+    { FLUSH_COVERAGE (); kissat_abort_function (); } // Keep all in this line.
+  else
+    { FLUSH_COVERAGE (); abort (); }                 // Keep all in this line.
+}
+
+// clang-format on
+
+static void typed_error_message_start (const char *type) {
+  fflush (stdout);
+  TERMINAL (stderr, 2);
+  COLOR (BOLD);
+  fputs ("kissat: ", stderr);
+  COLOR (RED);
+  fputs (type, stderr);
+  fputs (": ", stderr);
+  COLOR (NORMAL);
+}
+
+void kissat_fatal_message_start (void) {
+  typed_error_message_start ("fatal error");
+}
+
+static void vprint_error (const char *type, const char *fmt, va_list *ap) {
+  typed_error_message_start (type);
+  vfprintf (stderr, fmt, *ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+}
+
+void kissat_error (const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  vprint_error ("error", fmt, &ap);
+  va_end (ap);
+}
+
+void kissat_fatal (const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  vprint_error ("fatal error", fmt, &ap);
+  va_end (ap);
+  kissat_abort ();
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/error.h b/src/sat/kissat/error.h
new file mode 100644
index 000000000..32a265f86
--- /dev/null
+++ b/src/sat/kissat/error.h
@@ -0,0 +1,23 @@
+#ifndef _error_h_INCLUDED
+#define _error_h_INCLUDED
+
+#include "attribute.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+// clang-format off
+
+void kissat_error (const char *fmt, ...) ATTRIBUTE_FORMAT (1, 2);
+void kissat_fatal (const char *fmt, ...) ATTRIBUTE_FORMAT (1, 2);
+
+void kissat_fatal_message_start (void);
+
+void kissat_call_function_instead_of_abort (void (*)(void));
+void kissat_abort (void);
+
+// clang-format on
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/extend.c b/src/sat/kissat/extend.c
new file mode 100644
index 000000000..67a0839a5
--- /dev/null
+++ b/src/sat/kissat/extend.c
@@ -0,0 +1,185 @@
+#include "colors.h"
+#include "inline.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static void undo_eliminated_assignment (kissat *solver) {
+  size_t size_etrail = SIZE_STACK (solver->etrail);
+#ifdef LOGGING
+  size_t size_eliminated = SIZE_STACK (solver->eliminated);
+#endif
+  if (!size_etrail) {
+    LOG ("all %zu eliminated variables are unassigned", size_eliminated);
+    return;
+  }
+
+  LOG ("unassigning %zu eliminated variables %.0f%%", size_etrail,
+       kissat_percent (size_etrail, size_eliminated));
+
+  value *values = BEGIN_STACK (solver->eliminated);
+
+  while (!EMPTY_STACK (solver->etrail)) {
+    const unsigned pos = POP_STACK (solver->etrail);
+    KISSAT_assert (pos < SIZE_STACK (solver->eliminated));
+    KISSAT_assert (values[pos]);
+    LOG2 ("unassigned eliminated[%u] external variable", pos);
+    values[pos] = 0;
+  }
+}
+
+static void extend_assign (kissat *solver, value *values, int lit) {
+  KISSAT_assert (lit);
+  KISSAT_assert (lit != INT_MIN);
+  const unsigned idx = ABS (lit);
+  import *import = &PEEK_STACK (solver->import, idx);
+  KISSAT_assert (import->eliminated);
+  KISSAT_assert (import->imported);
+  const unsigned pos = import->lit;
+  KISSAT_assert (pos < SIZE_STACK (solver->eliminated));
+  const value value = lit < 0 ? -1 : 1;
+  values[pos] = value;
+  KISSAT_assert (kissat_value (solver, lit) == lit);
+  LOG ("assigned eliminated[%u] external literal %d", pos, value * idx);
+  PUSH_STACK (solver->etrail, pos);
+}
+
+void kissat_extend (kissat *solver) {
+  KISSAT_assert (!EMPTY_STACK (solver->extend));
+  KISSAT_assert (!solver->extended);
+
+  START (extend);
+  solver->extended = true;
+
+  undo_eliminated_assignment (solver);
+
+  LOG ("extending solution with reconstruction stack of size %zu",
+       SIZE_STACK (solver->extend));
+
+  value *evalues = BEGIN_STACK (solver->eliminated);
+  value *ivalues = solver->values;
+
+  const import *const imports = BEGIN_STACK (solver->import);
+
+  const extension *const begin = BEGIN_STACK (solver->extend);
+  extension const *p = END_STACK (solver->extend);
+
+#ifdef LOGGING
+  size_t assigned = 0;
+  size_t flipped = 0;
+#endif
+
+  while (p != begin) {
+    unsigned pos = UINT_MAX;
+    bool satisfied = false;
+
+    int eliminated = 0;
+    int blocking = 0;
+
+    size_t size = 0;
+#ifndef LOGGING
+    (void) size;
+#endif
+    do {
+      size++;
+      KISSAT_assert (begin < p);
+      const extension ext = *--p;
+      const int elit = ext.lit;
+      if (ext.blocking)
+        blocking = elit;
+
+      if (satisfied)
+        continue;
+
+      KISSAT_assert (elit != INT_MIN);
+      const unsigned eidx = ABS (elit);
+      KISSAT_assert (eidx < SIZE_STACK (solver->import));
+      const import *const import = imports + eidx;
+      KISSAT_assert (import->imported);
+
+      if (import->eliminated) {
+        const unsigned tmp = import->lit;
+        KISSAT_assert (tmp < SIZE_STACK (solver->eliminated));
+        value value = evalues[tmp];
+
+        if (elit < 0)
+          value = -value;
+
+        if (value > 0) {
+          LOG2 ("previously assigned eliminated literal %d "
+                "satisfies clause",
+                elit);
+          satisfied = true;
+        } else if (!value && (!eliminated || pos < tmp)) {
+#ifdef LOGGING
+          if (eliminated)
+            LOG2 ("earlier unassigned eliminated literal %d", elit);
+          else
+            LOG2 ("found unassigned eliminated literal %d", elit);
+#endif
+          eliminated = elit;
+          pos = tmp;
+        }
+      } else {
+        const unsigned ilit = import->lit;
+        value value = ivalues[ilit];
+        KISSAT_assert (value);
+
+        if (elit < 0)
+          value = -value;
+
+        if (value > 0) {
+          LOG2 ("internal literal %s satisfies clause", LOGLIT (ilit));
+          satisfied = true;
+        }
+      }
+    } while (!blocking);
+
+    if (satisfied) {
+      LOGEXT2 (size, p, "satisfied");
+      continue;
+    }
+
+    if (eliminated && eliminated != blocking) {
+      LOGEXT2 (size, p,
+               "assigning eliminated unassigned external literal %d "
+               "to satisfy size %zu witness labelled clause at",
+               eliminated, size);
+      extend_assign (solver, evalues, eliminated);
+#ifdef LOGGING
+      assigned++;
+#endif
+      continue;
+    }
+
+#ifdef LOGGING
+    const unsigned blocking_idx = ABS (blocking);
+    KISSAT_assert (blocking_idx < SIZE_STACK (solver->import));
+    KISSAT_assert (imports[blocking_idx].eliminated);
+    const unsigned blocking_pos = imports[blocking_idx].lit;
+    KISSAT_assert (blocking_pos < SIZE_STACK (solver->eliminated));
+    const value blocking_value = evalues[blocking_pos];
+    LOGEXT2 (size, p,
+             "%s blocking external literal %d "
+             "to satisfy size %zu witness labelled clause at",
+             blocking_value ? "flipping" : "assigning", blocking, size);
+    if (blocking_value)
+      flipped++;
+    else
+      assigned++;
+#endif
+    extend_assign (solver, evalues, blocking);
+  }
+
+#ifdef LOGGING
+  size_t total = SIZE_STACK (solver->eliminated);
+  LOG ("assigned %zu external variables %.0f%% out of %zu eliminated",
+       assigned, kissat_percent (assigned, total), total);
+  LOG ("flipped %zu external variables %.0f%% out of %zu assigned", flipped,
+       kissat_percent (flipped, assigned), assigned);
+  LOG ("extended assignment complete");
+#endif
+
+  STOP (extend);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/extend.h b/src/sat/kissat/extend.h
new file mode 100644
index 000000000..c66d9efd2
--- /dev/null
+++ b/src/sat/kissat/extend.h
@@ -0,0 +1,35 @@
+#ifndef _extend_h_INCLUDED
+#define _extend_h_INCLUDED
+
+#include "stack.h"
+#include "utilities.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct extension extension;
+
+struct extension {
+  signed int lit : 31;
+  bool blocking : 1;
+};
+
+// clang-format off
+typedef STACK (extension) extensions;
+// clang-format on
+
+static inline extension kissat_extension (bool blocking, int lit) {
+  KISSAT_assert (ABS (lit) < (1 << 30));
+  extension res;
+  res.blocking = blocking;
+  res.lit = lit;
+  return res;
+}
+
+struct kissat;
+
+void kissat_extend (struct kissat *solver);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/factor.c b/src/sat/kissat/factor.c
new file mode 100644
index 000000000..5586243c8
--- /dev/null
+++ b/src/sat/kissat/factor.c
@@ -0,0 +1,1154 @@
+#include "factor.h"
+#include "bump.h"
+#include "clause.h"
+#include "dense.h"
+#include "heap.h"
+#include "import.h"
+#include "inline.h"
+#include "inlineheap.h"
+#include "inlinequeue.h"
+#include "inlinevector.h"
+#include "internal.h"
+#include "logging.h"
+#include "print.h"
+#include "report.h"
+#include "sort.h"
+#include "terminate.h"
+#include "vector.h"
+#include "watch.h"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#define FACTOR 1
+#define QUOTIENT 2
+#define NOUNTED 4
+
+struct quotient {
+  size_t id;
+  struct quotient *prev, *next;
+  unsigned factor;
+  statches clauses;
+  sizes matches;
+  size_t matched;
+};
+
+typedef struct quotient quotient;
+
+struct scores {
+  double *score;
+  unsigneds scored;
+};
+
+typedef struct scores scores;
+
+struct factoring {
+  kissat *solver;
+  size_t size, allocated;
+  unsigned initial;
+  unsigned *count;
+  scores *scores;
+  unsigned hops;
+  unsigned bound;
+  unsigneds fresh;
+  unsigneds counted;
+  unsigneds nounted;
+  references qlauses;
+  uint64_t limit;
+  struct {
+    quotient *first, *last;
+  } quotients;
+  heap schedule;
+};
+
+typedef struct factoring factoring;
+
+static void init_factoring (kissat *solver, factoring *factoring,
+                            uint64_t limit) {
+  memset (factoring, 0, sizeof *factoring);
+  factoring->solver = solver;
+  factoring->initial = factoring->allocated = factoring->size = LITS;
+  factoring->limit = limit;
+  factoring->bound = solver->bounds.eliminate.additional_clauses;
+  if (GET_OPTION (factorstructural))
+    factoring->hops = GET_OPTION (factorhops);
+  const unsigned hops = factoring->hops;
+  if (hops) {
+    CALLOC (scores, factoring->scores, hops);
+    for (unsigned i = 0; i != hops; i++) {
+      scores *scores = factoring->scores + i;
+      NALLOC (double, scores->score, VARS);
+      double *score = scores->score;
+      for (all_variables (idx))
+        score[idx] = -1;
+    }
+  }
+  CALLOC (unsigned, factoring->count, factoring->allocated);
+#ifndef KISSAT_NDEBUG
+  for (all_literals (lit))
+    KISSAT_assert (!solver->marks[lit]);
+#endif
+}
+
+static void release_quotients (factoring *factoring) {
+  kissat *const solver = factoring->solver;
+  mark *marks = solver->marks;
+  for (quotient *q = factoring->quotients.first, *next; q; q = next) {
+    next = q->next;
+    unsigned factor = q->factor;
+    KISSAT_assert (marks[factor] == FACTOR);
+    marks[factor] = 0;
+    RELEASE_STACK (q->clauses);
+    RELEASE_STACK (q->matches);
+    kissat_free (solver, q, sizeof *q);
+  }
+  const unsigned hops = factoring->hops;
+  if (hops) {
+    for (unsigned i = 0; i != hops; i++) {
+      scores *scores = factoring->scores + i;
+      unsigneds *scored = &scores->scored;
+      double *score = scores->score;
+      while (!EMPTY_STACK (*scored)) {
+        unsigned idx = POP_STACK (*scored);
+        score[idx] = -1;
+      }
+    }
+  }
+  factoring->quotients.first = factoring->quotients.last = 0;
+}
+
+static void release_factoring (factoring *factoring) {
+  kissat *const solver = factoring->solver;
+  KISSAT_assert (EMPTY_STACK (solver->analyzed));
+  KISSAT_assert (EMPTY_STACK (factoring->counted));
+  KISSAT_assert (EMPTY_STACK (factoring->nounted));
+  KISSAT_assert (EMPTY_STACK (factoring->qlauses));
+  DEALLOC (factoring->count, factoring->allocated);
+  RELEASE_STACK (factoring->counted);
+  RELEASE_STACK (factoring->nounted);
+  RELEASE_STACK (factoring->fresh);
+  RELEASE_STACK (factoring->qlauses);
+  release_quotients (factoring);
+  kissat_release_heap (solver, &factoring->schedule);
+  KISSAT_assert (!(factoring->allocated & 1));
+  const size_t allocated_score = factoring->allocated / 2;
+  const unsigned hops = factoring->hops;
+  if (hops) {
+    for (unsigned i = 0; i != hops; i++) {
+      scores *scores = factoring->scores + i;
+      double *score = scores->score;
+      DEALLOC (score, allocated_score);
+      RELEASE_STACK (scores->scored);
+    }
+    DEALLOC (factoring->scores, hops);
+  }
+#ifndef KISSAT_NDEBUG
+  for (all_literals (lit))
+    KISSAT_assert (!solver->marks[lit]);
+#endif
+}
+
+static void update_candidate (factoring *factoring, unsigned lit) {
+  heap *cands = &factoring->schedule;
+  kissat *const solver = factoring->solver;
+  const size_t size = SIZE_WATCHES (solver->watches[lit]);
+  if (size > 1) {
+    kissat_adjust_heap (solver, cands, lit);
+    kissat_update_heap (solver, cands, lit, size);
+    if (!kissat_heap_contains (cands, lit))
+      kissat_push_heap (solver, cands, lit);
+  } else if (kissat_heap_contains (cands, lit))
+    kissat_pop_heap (solver, cands, lit);
+}
+
+static void schedule_factorization (factoring *factoring) {
+  kissat *const solver = factoring->solver;
+  flags *flags = solver->flags;
+  for (all_variables (idx)) {
+    if (ACTIVE (idx)) {
+      struct flags *f = flags + idx;
+      const unsigned lit = LIT (idx);
+      const unsigned not_lit = NOT (lit);
+      if (f->factor & 1)
+        update_candidate (factoring, lit);
+      if (f->factor & 2)
+        update_candidate (factoring, not_lit);
+    }
+  }
+#ifndef KISSAT_QUIET
+  heap *cands = &factoring->schedule;
+  size_t size_cands = kissat_size_heap (cands);
+  kissat_very_verbose (
+      solver, "scheduled %zu factorization candidate literals %.0f %%",
+      size_cands, kissat_percent (size_cands, LITS));
+#endif
+}
+
+static quotient *new_quotient (factoring *factoring, unsigned factor) {
+  kissat *const solver = factoring->solver;
+  mark *marks = solver->marks;
+  KISSAT_assert (!marks[factor]);
+  marks[factor] = FACTOR;
+  quotient *res = (quotient*)kissat_malloc (solver, sizeof *res);
+  memset (res, 0, sizeof *res);
+  res->factor = factor;
+  quotient *last = factoring->quotients.last;
+  if (last) {
+    KISSAT_assert (factoring->quotients.first);
+    KISSAT_assert (!last->next);
+    last->next = res;
+    res->id = last->id + 1;
+  } else {
+    KISSAT_assert (!factoring->quotients.first);
+    factoring->quotients.first = res;
+  }
+  factoring->quotients.last = res;
+  res->prev = last;
+  LOG ("new quotient[%zu] with factor %s", res->id, LOGLIT (factor));
+  return res;
+}
+
+static size_t first_factor (factoring *factoring, unsigned factor) {
+  kissat *const solver = factoring->solver;
+  watches *all_watches = solver->watches;
+  watches *factor_watches = all_watches + factor;
+  KISSAT_assert (!factoring->quotients.first);
+  quotient *quotient = new_quotient (factoring, factor);
+  statches *clauses = &quotient->clauses;
+  uint64_t ticks = 0;
+  for (all_binary_large_watches (watch, *factor_watches)) {
+    PUSH_STACK (*clauses, watch);
+#ifndef KISSAT_NDEBUG
+    if (watch.type.binary)
+      continue;
+    const reference ref = watch.large.ref;
+    clause *const c = kissat_dereference_clause (solver, ref);
+    KISSAT_assert (!c->quotient);
+#endif
+    ticks++;
+  }
+  size_t res = SIZE_STACK (*clauses);
+  LOG ("quotient[0] factor %s size %zu", LOGLIT (factor), res);
+  KISSAT_assert (res > 1);
+  ADD (factor_ticks, ticks);
+  return res;
+}
+
+static void clear_nounted (kissat *solver, unsigneds *nounted) {
+  mark *marks = solver->marks;
+  for (all_stack (unsigned, lit, *nounted)) {
+    KISSAT_assert (marks[lit] & NOUNTED);
+    marks[lit] &= ~NOUNTED;
+  }
+  CLEAR_STACK (*nounted);
+}
+
+static void clear_qlauses (kissat *solver, references *qlauses) {
+  ward *const arena = BEGIN_STACK (solver->arena);
+  for (all_stack (reference, ref, *qlauses)) {
+    clause *const c = (clause *) (arena + ref);
+    KISSAT_assert (c->quotient);
+    c->quotient = false;
+  }
+  CLEAR_STACK (*qlauses);
+}
+
+static double distinct_paths (factoring *factoring, unsigned src_lit,
+                              unsigned dst_idx, unsigned hops) {
+  kissat *const solver = factoring->solver;
+  const unsigned src_idx = IDX (src_lit);
+  bool matched = (src_idx == dst_idx);
+  if (!hops)
+    return matched;
+  const unsigned next_hops = hops - 1;
+  scores *scores = &factoring->scores[next_hops];
+  double *score = scores->score;
+  double res = score[src_idx];
+  if (res >= 0)
+    return res;
+  res = matched;
+  for (unsigned sign = 0; sign != 2; sign++) {
+    const unsigned signed_src_lit = src_lit ^ sign;
+    watches *const watches = &WATCHES (signed_src_lit);
+    uint64_t ticks =
+        1 + kissat_cache_lines (SIZE_WATCHES (*watches), sizeof (watch));
+    for (all_binary_large_watches (watch, *watches)) {
+      if (watch.type.binary) {
+        const unsigned other = watch.binary.lit;
+        res += distinct_paths (factoring, other, dst_idx, next_hops);
+      } else {
+        const reference ref = watch.large.ref;
+        clause *c = kissat_dereference_clause (solver, ref);
+        ticks++;
+        for (all_literals_in_clause (other, c))
+          if (other != signed_src_lit)
+            res += distinct_paths (factoring, other, dst_idx, next_hops);
+      }
+    }
+    ADD (factor_ticks, ticks);
+  }
+  KISSAT_assert (res >= 0);
+  score[src_idx] = res;
+  unsigneds *scored = &scores->scored;
+  PUSH_STACK (*scored, src_idx);
+  LOG ("caching %g distinct paths from %s to %s in %u hops", res,
+       LOGVAR (src_idx), LOGVAR (dst_idx), hops);
+  return res;
+}
+
+static double structural_score (factoring *factoring, unsigned lit) {
+  const quotient *first_quotient = factoring->quotients.first;
+  KISSAT_assert (first_quotient);
+  const unsigned first_factor = first_quotient->factor;
+#ifndef KISSAT_NDEBUG
+  kissat *const solver = factoring->solver;
+#endif
+  const unsigned first_factor_idx = IDX (first_factor);
+  return distinct_paths (factoring, lit, first_factor_idx, factoring->hops);
+}
+
+static double watches_score (factoring *factoring, unsigned lit) {
+  kissat *const solver = factoring->solver;
+  watches *watches = solver->watches + lit;
+  double res = SIZE_WATCHES (*watches);
+  LOG ("watches score %g of %s", res, LOGLIT (lit));
+  return res;
+}
+
+static double tied_next_factor_score (factoring *factoring, unsigned lit) {
+  if (factoring->hops)
+    return structural_score (factoring, lit);
+  else
+    return watches_score (factoring, lit);
+}
+
+static unsigned next_factor (factoring *factoring,
+                             unsigned *next_count_ptr) {
+  quotient *last_quotient = factoring->quotients.last;
+  KISSAT_assert (last_quotient);
+  statches *last_clauses = &last_quotient->clauses;
+  kissat *const solver = factoring->solver;
+  watches *all_watches = solver->watches;
+  unsigned *count = factoring->count;
+  unsigneds *counted = &factoring->counted;
+  references *qlauses = &factoring->qlauses;
+  KISSAT_assert (EMPTY_STACK (*counted));
+  KISSAT_assert (EMPTY_STACK (*qlauses));
+  ward *const arena = BEGIN_STACK (solver->arena);
+  mark *marks = solver->marks;
+  const unsigned initial = factoring->initial;
+  uint64_t ticks =
+      1 + kissat_cache_lines (SIZE_STACK (*last_clauses), sizeof (watch));
+  for (all_stack (watch, quotient_watch, *last_clauses)) {
+    if (quotient_watch.type.binary) {
+      const unsigned q = quotient_watch.binary.lit;
+      watches *q_watches = all_watches + q;
+      ticks += 1 + kissat_cache_lines (SIZE_WATCHES (*q_watches),
+                                       sizeof (watch));
+      for (all_binary_large_watches (next_watch, *q_watches)) {
+        if (!next_watch.type.binary)
+          continue;
+        const unsigned next = next_watch.binary.lit;
+        if (next > initial)
+          continue;
+        if (marks[next] & FACTOR)
+          continue;
+        const unsigned next_idx = IDX (next);
+        if (!ACTIVE (next_idx))
+          continue;
+        if (!count[next])
+          PUSH_STACK (*counted, next);
+        count[next]++;
+      }
+    } else {
+      const reference c_ref = quotient_watch.large.ref;
+      clause *const c = (clause *) (arena + c_ref);
+      KISSAT_assert (!c->quotient);
+      unsigned min_lit = INVALID_LIT, factors = 0;
+      size_t min_size = 0;
+      ticks++;
+      for (all_literals_in_clause (other, c)) {
+        if (marks[other] & FACTOR) {
+          if (factors++)
+            break;
+        } else {
+          KISSAT_assert (!(marks[other] & QUOTIENT));
+          marks[other] |= QUOTIENT;
+          watches *other_watches = all_watches + other;
+          const size_t other_size = SIZE_WATCHES (*other_watches);
+          if (min_lit != INVALID_LIT && min_size <= other_size)
+            continue;
+          min_lit = other;
+          min_size = other_size;
+        }
+      }
+      KISSAT_assert (factors);
+      if (factors == 1) {
+        KISSAT_assert (min_lit != INVALID_LIT);
+        watches *min_watches = all_watches + min_lit;
+        unsigned c_size = c->size;
+        unsigneds *nounted = &factoring->nounted;
+        KISSAT_assert (EMPTY_STACK (*nounted));
+        ticks += 1 + kissat_cache_lines (SIZE_WATCHES (*min_watches),
+                                         sizeof (watch));
+        for (all_binary_large_watches (min_watch, *min_watches)) {
+          if (min_watch.type.binary)
+            continue;
+          const reference d_ref = min_watch.large.ref;
+          if (c_ref == d_ref)
+            continue;
+          clause *const d = (clause *) (arena + d_ref);
+          ticks++;
+          if (d->quotient)
+            continue;
+          if (d->size != c_size)
+            continue;
+          unsigned next = INVALID_LIT;
+          int continue_with_next_min_watch = 0;
+          for (all_literals_in_clause (other, d)) {
+            const mark mark = marks[other];
+            if (mark & QUOTIENT)
+              continue;
+            if (mark & FACTOR) {
+              continue_with_next_min_watch = 1;
+              break;
+            }
+            if (mark & NOUNTED) {
+              continue_with_next_min_watch = 1;
+              break;
+            }
+            if (next != INVALID_LIT) {
+              continue_with_next_min_watch = 1;
+              break;
+            }
+            next = other;
+          }
+          if(continue_with_next_min_watch) {
+            continue;
+          }
+          KISSAT_assert (next != INVALID_LIT);
+          if (next > initial)
+            continue;
+          const unsigned next_idx = IDX (next);
+          if (!ACTIVE (next_idx))
+            continue;
+          KISSAT_assert (!(marks[next] & (FACTOR | NOUNTED)));
+          marks[next] |= NOUNTED;
+          PUSH_STACK (*nounted, next);
+          d->quotient = true;
+          PUSH_STACK (*qlauses, d_ref);
+          if (!count[next])
+            PUSH_STACK (*counted, next);
+          count[next]++;
+        }
+        clear_nounted (solver, nounted);
+      }
+      for (all_literals_in_clause (other, c))
+        marks[other] &= ~QUOTIENT;
+    }
+    ADD (factor_ticks, ticks);
+    ticks = 0;
+    if (solver->statistics_.factor_ticks > factoring->limit)
+      break;
+  }
+  clear_qlauses (solver, qlauses);
+  unsigned next_count = 0, next = INVALID_LIT;
+  if (solver->statistics_.factor_ticks <= factoring->limit) {
+    unsigned ties = 0;
+    for (all_stack (unsigned, lit, *counted)) {
+      const unsigned lit_count = count[lit];
+      if (lit_count < next_count)
+        continue;
+      if (lit_count == next_count) {
+        KISSAT_assert (lit_count);
+        ties++;
+      } else {
+        KISSAT_assert (lit_count > next_count);
+        next_count = lit_count;
+        next = lit;
+        ties = 1;
+      }
+    }
+    if (next_count < 2) {
+      LOG ("next factor count %u smaller than 2", next_count);
+      next = INVALID_LIT;
+    } else if (ties > 1) {
+      LOG ("found %u tied next factor candidate literals with count %u",
+           ties, next_count);
+      double next_score = -1;
+      for (all_stack (unsigned, lit, *counted)) {
+        const unsigned lit_count = count[lit];
+        if (lit_count != next_count)
+          continue;
+        double lit_score = tied_next_factor_score (factoring, lit);
+        KISSAT_assert (lit_score >= 0);
+        LOG ("score %g of next factor candidate %s", lit_score,
+             LOGLIT (lit));
+        if (lit_score <= next_score)
+          continue;
+        next_score = lit_score;
+        next = lit;
+      }
+      KISSAT_assert (next_score >= 0);
+      KISSAT_assert (next != INVALID_LIT);
+      LOG ("best score %g of next factor %s", next_score, LOGLIT (next));
+    } else {
+      KISSAT_assert (ties == 1);
+      LOG ("single next factor %s with count %u", LOGLIT (next),
+           next_count);
+    }
+  }
+  for (all_stack (unsigned, lit, *counted))
+    count[lit] = 0;
+  CLEAR_STACK (*counted);
+  KISSAT_assert (next == INVALID_LIT || next_count > 1);
+  *next_count_ptr = next_count;
+  return next;
+}
+
+static void factorize_next (factoring *factoring, unsigned next,
+                            unsigned expected_next_count) {
+  quotient *last_quotient = factoring->quotients.last;
+  quotient *next_quotient = new_quotient (factoring, next);
+
+  kissat *const solver = factoring->solver;
+  watches *all_watches = solver->watches;
+  ward *const arena = BEGIN_STACK (solver->arena);
+  mark *marks = solver->marks;
+
+  KISSAT_assert (last_quotient);
+  statches *last_clauses = &last_quotient->clauses;
+  statches *next_clauses = &next_quotient->clauses;
+  sizes *matches = &next_quotient->matches;
+  references *qlauses = &factoring->qlauses;
+  KISSAT_assert (EMPTY_STACK (*qlauses));
+
+  uint64_t ticks =
+      1 + kissat_cache_lines (SIZE_STACK (*last_clauses), sizeof (watch));
+
+  size_t i = 0;
+
+  for (all_stack (watch, last_watch, *last_clauses)) {
+    if (last_watch.type.binary) {
+      const unsigned q = last_watch.binary.lit;
+      watches *q_watches = all_watches + q;
+      ticks += 1 + kissat_cache_lines (SIZE_WATCHES (*q_watches),
+                                       sizeof (watch));
+      for (all_binary_large_watches (q_watch, *q_watches))
+        if (q_watch.type.binary && q_watch.binary.lit == next) {
+          LOGBINARY (last_quotient->factor, q, "matched");
+          LOGBINARY (next, q, "keeping");
+          PUSH_STACK (*next_clauses, last_watch);
+          PUSH_STACK (*matches, i);
+          break;
+        }
+    } else {
+      const reference c_ref = last_watch.large.ref;
+      clause *const c = (clause *) (arena + c_ref);
+      KISSAT_assert (!c->quotient);
+      unsigned min_lit = INVALID_LIT, factors = 0;
+      size_t min_size = 0;
+      ticks++;
+      for (all_literals_in_clause (other, c)) {
+        if (marks[other] & FACTOR) {
+          if (factors++)
+            break;
+        } else {
+          KISSAT_assert (!(marks[other] & QUOTIENT));
+          marks[other] |= QUOTIENT;
+          watches *other_watches = all_watches + other;
+          const size_t other_size = SIZE_WATCHES (*other_watches);
+          if (min_lit != INVALID_LIT && min_size <= other_size)
+            continue;
+          min_lit = other;
+          min_size = other_size;
+        }
+      }
+      KISSAT_assert (factors);
+      if (factors == 1) {
+        KISSAT_assert (min_lit != INVALID_LIT);
+        watches *min_watches = all_watches + min_lit;
+        unsigned c_size = c->size;
+        ticks += 1 + kissat_cache_lines (SIZE_WATCHES (*min_watches),
+                                         sizeof (watch));
+        for (all_binary_large_watches (min_watch, *min_watches)) {
+          if (min_watch.type.binary)
+            continue;
+          const reference d_ref = min_watch.large.ref;
+          if (c_ref == d_ref)
+            continue;
+          clause *const d = (clause *) (arena + d_ref);
+          ticks++;
+          if (d->quotient)
+            continue;
+          if (d->size != c_size)
+            continue;
+          for (all_literals_in_clause (other, d)) {
+            const mark mark = marks[other];
+            if (mark & QUOTIENT)
+              continue;
+            if (other != next)
+              goto CONTINUE_WITH_NEXT_MIN_WATCH;
+          }
+          LOGCLS (c, "matched");
+          LOGCLS (d, "keeping");
+          PUSH_STACK (*next_clauses, min_watch);
+          PUSH_STACK (*matches, i);
+          PUSH_STACK (*qlauses, d_ref);
+          d->quotient = true;
+          break;
+        CONTINUE_WITH_NEXT_MIN_WATCH:;
+        }
+      }
+      for (all_literals_in_clause (other, c))
+        marks[other] &= ~QUOTIENT;
+    }
+    i++;
+  }
+
+  clear_qlauses (solver, qlauses);
+  ADD (factor_ticks, ticks);
+
+  KISSAT_assert (expected_next_count <= SIZE_STACK (*next_clauses));
+  (void) expected_next_count;
+}
+
+static quotient *best_quotient (factoring *factoring,
+                                size_t *best_reduction_ptr) {
+  size_t factors = 1, best_reduction = 0;
+  quotient *best = 0;
+  kissat *const solver = factoring->solver;
+  for (quotient *q = factoring->quotients.first; q; q = q->next) {
+    size_t quotients = SIZE_STACK (q->clauses);
+    size_t before_factorization = quotients * factors;
+    size_t after_factorization = quotients + factors;
+    if (before_factorization == after_factorization)
+      LOG ("quotient[%zu] factors %zu clauses into %zu thus no change",
+           factors - 1, before_factorization, after_factorization);
+    else if (before_factorization < after_factorization)
+      LOG ("quotient[%zu] factors %zu clauses into %zu thus %zu more",
+           factors - 1, before_factorization, after_factorization,
+           after_factorization - before_factorization);
+    else {
+      size_t delta = before_factorization - after_factorization;
+      LOG ("quotient[%zu] factors %zu clauses into %zu thus %zu less",
+           factors - 1, before_factorization, after_factorization, delta);
+      if (!best || best_reduction < delta) {
+        best_reduction = delta;
+        best = q;
+      }
+    }
+    factors++;
+  }
+  if (!best) {
+    LOG ("no decreasing quotient found");
+    return 0;
+  }
+  LOG ("best decreasing quotient[%zu] with reduction %zu", best->id,
+       best_reduction);
+  *best_reduction_ptr = best_reduction;
+  (void) solver;
+  return best;
+}
+
+static void resize_factoring (factoring *factoring, unsigned lit) {
+  kissat *const solver = factoring->solver;
+  KISSAT_assert (lit > NOT (lit));
+  const size_t old_size = factoring->size;
+  KISSAT_assert (lit > old_size);
+  const size_t old_allocated = factoring->allocated;
+  size_t new_size = lit + 1;
+  if (new_size > old_allocated) {
+    size_t new_allocated = 2 * old_allocated;
+    while (new_size > new_allocated)
+      new_allocated *= 2;
+    unsigned *count = factoring->count;
+    count = (unsigned*)kissat_nrealloc (solver, count, old_allocated, new_allocated,
+                             sizeof *count);
+    const size_t delta_allocated = new_allocated - old_allocated;
+    const size_t delta_bytes = delta_allocated * sizeof *count;
+    memset (count + old_size, 0, delta_bytes);
+    factoring->count = count;
+    KISSAT_assert (!(old_allocated & 1));
+    KISSAT_assert (!(new_allocated & 1));
+    const size_t old_allocated_score = old_allocated / 2;
+    const size_t new_allocated_score = new_allocated / 2;
+    for (unsigned i = 0; i != factoring->hops; i++) {
+      scores *scores = factoring->scores + i;
+      double *score = scores->score;
+      score = (double*)kissat_nrealloc (solver, score, old_allocated_score,
+                               new_allocated_score, sizeof *score);
+      for (size_t i = old_allocated_score; i != new_allocated_score; i++)
+        score[i] = -1;
+      scores->score = score;
+    }
+    factoring->allocated = new_allocated;
+  }
+  factoring->size = new_size;
+}
+
+static void flush_unmatched_clauses (kissat *solver, quotient *q) {
+  quotient *prev = q->prev;
+  sizes *q_matches = &q->matches, *prev_matches = &prev->matches;
+  statches *q_clauses = &q->clauses, *prev_clauses = &prev->clauses;
+  const size_t n = SIZE_STACK (*q_clauses);
+  KISSAT_assert (n == SIZE_STACK (*q_matches));
+  bool prev_is_first = !prev->id;
+  size_t i = 0;
+  while (i != n) {
+    size_t j = PEEK_STACK (*q_matches, i);
+    KISSAT_assert (i <= j);
+    if (!prev_is_first) {
+      size_t matches = PEEK_STACK (*prev_matches, j);
+      POKE_STACK (*prev_matches, i, matches);
+    }
+    watch watch = PEEK_STACK (*prev_clauses, j);
+    POKE_STACK (*prev_clauses, i, watch);
+    i++;
+  }
+  LOG ("flushing %zu clauses of quotient[%zu]",
+       SIZE_STACK (*prev_clauses) - n, prev->id);
+  if (!prev_is_first)
+    RESIZE_STACK (*prev_matches, n);
+  RESIZE_STACK (*prev_clauses, n);
+  (void) solver;
+}
+
+static void add_factored_divider (factoring *factoring, quotient *q,
+                                  unsigned fresh) {
+  const unsigned factor = q->factor;
+  kissat *const solver = factoring->solver;
+  LOGBINARY (fresh, factor, "factored %s divider", LOGLIT (factor));
+  kissat_new_binary_clause (solver, fresh, factor);
+  INC (clauses_factored);
+  ADD (literals_factored, 2);
+}
+
+static void add_factored_quotient (factoring *factoring, quotient *q,
+                                   unsigned not_fresh) {
+  kissat *const solver = factoring->solver;
+  LOG ("adding factored quotient[%zu] clauses", q->id);
+  for (all_stack (watch, watch, q->clauses)) {
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      LOGBINARY (not_fresh, other, "factored quotient");
+      kissat_new_binary_clause (solver, not_fresh, other);
+      ADD (literals_factored, 2);
+    } else {
+      const reference c_ref = watch.large.ref;
+      clause *const c = kissat_dereference_clause (solver, c_ref);
+      unsigneds *clause = &solver->clause;
+      KISSAT_assert (EMPTY_STACK (*clause));
+      const unsigned factor = q->factor;
+#ifndef KISSAT_NDEBUG
+      bool found = false;
+#endif
+      PUSH_STACK (*clause, not_fresh);
+      for (all_literals_in_clause (other, c)) {
+        if (other == factor) {
+#ifndef KISSAT_NDEBUG
+          found = true;
+#endif
+          continue;
+        }
+        PUSH_STACK (*clause, other);
+      }
+      KISSAT_assert (found);
+      ADD (literals_factored, c->size);
+      kissat_new_irredundant_clause (solver);
+      CLEAR_STACK (*clause);
+    }
+    INC (clauses_factored);
+  }
+}
+
+static void eagerly_remove_watch (kissat *solver, watches *watches,
+                                  watch needle) {
+  watch *p = BEGIN_WATCHES (*watches);
+  watch *end = END_WATCHES (*watches);
+  KISSAT_assert (p != end);
+  watch *last = end - 1;
+  while (p->raw != needle.raw)
+    p++, KISSAT_assert (p != end);
+  if (p != last)
+    memmove (p, p + 1, (last - p) * sizeof *p);
+  SET_END_OF_WATCHES (*watches, last);
+}
+
+static void eagerly_remove_binary (kissat *solver, watches *watches,
+                                   unsigned lit) {
+  const watch needle = kissat_binary_watch (lit);
+  eagerly_remove_watch (solver, watches, needle);
+}
+
+static void delete_unfactored (factoring *factoring, quotient *q) {
+  kissat *const solver = factoring->solver;
+  LOG ("deleting unfactored quotient[%zu] clauses", q->id);
+  const unsigned factor = q->factor;
+  for (all_stack (watch, watch, q->clauses)) {
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      LOGBINARY (factor, other, "deleting unfactored");
+      eagerly_remove_binary (solver, &WATCHES (other), factor);
+      eagerly_remove_binary (solver, &WATCHES (factor), other);
+      kissat_delete_binary (solver, factor, other);
+      ADD (literals_unfactored, 2);
+    } else {
+      const reference ref = watch.large.ref;
+      clause *c = kissat_dereference_clause (solver, ref);
+      LOGCLS (c, "deleting unfactored");
+      for (all_literals_in_clause (lit, c))
+        eagerly_remove_watch (solver, &WATCHES (lit), watch);
+      kissat_mark_clause_as_garbage (solver, c);
+      ADD (literals_unfactored, c->size);
+    }
+    INC (clauses_unfactored);
+  }
+}
+
+static void update_factored (factoring *factoring, quotient *q) {
+  kissat *const solver = factoring->solver;
+  const unsigned factor = q->factor;
+  update_candidate (factoring, factor);
+  update_candidate (factoring, NOT (factor));
+  for (all_stack (watch, watch, q->clauses)) {
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      update_candidate (factoring, other);
+    } else {
+      const reference ref = watch.large.ref;
+      clause *c = kissat_dereference_clause (solver, ref);
+      LOGCLS (c, "deleting unfactored");
+      for (all_literals_in_clause (lit, c))
+        if (lit != factor)
+          update_candidate (factoring, lit);
+    }
+  }
+}
+
+static bool apply_factoring (factoring *factoring, quotient *q) {
+  kissat *const solver = factoring->solver;
+  const unsigned fresh = kissat_fresh_literal (solver);
+  if (fresh == INVALID_LIT)
+    return false;
+  INC (factored);
+  PUSH_STACK (factoring->fresh, fresh);
+  for (quotient *p = q; p->prev; p = p->prev)
+    flush_unmatched_clauses (solver, p);
+  for (quotient *p = q; p; p = p->prev)
+    add_factored_divider (factoring, p, fresh);
+  const unsigned not_fresh = NOT (fresh);
+  add_factored_quotient (factoring, q, not_fresh);
+  for (quotient *p = q; p; p = p->prev)
+    delete_unfactored (factoring, p);
+  for (quotient *p = q; p; p = p->prev)
+    update_factored (factoring, p);
+  KISSAT_assert (fresh < not_fresh);
+  resize_factoring (factoring, not_fresh);
+  return true;
+}
+
+static void
+adjust_scores_and_phases_of_fresh_varaibles (factoring *factoring) {
+  const unsigned *begin = BEGIN_STACK (factoring->fresh);
+  const unsigned *end = END_STACK (factoring->fresh);
+  kissat *const solver = factoring->solver;
+  {
+    const unsigned *p = begin;
+    while (p != end) {
+      const unsigned lit = *p++;
+      const unsigned idx = IDX (lit);
+      LOG ("unbumping fresh[%zu] %s", (size_t) (p - begin - 1),
+           LOGVAR (idx));
+      const double score = 0;
+      kissat_update_heap (solver, &solver->scores, idx, score);
+    }
+  }
+  {
+    const unsigned *p = end;
+    links *links = solver->links;
+    queue *queue = &solver->queue;
+    while (p != begin) {
+      const unsigned lit = *--p;
+      const unsigned idx = IDX (lit);
+      kissat_dequeue_links (idx, links, queue);
+    }
+    queue->stamp = 0;
+    unsigned rest = queue->first;
+    p = end;
+    while (p != begin) {
+      const unsigned lit = *--p;
+      const unsigned idx = IDX (lit);
+      struct links *l = links + idx;
+      if (DISCONNECTED (queue->first)) {
+        KISSAT_assert (DISCONNECTED (queue->last));
+        queue->last = idx;
+      } else {
+        struct links *first = links + queue->first;
+        KISSAT_assert (DISCONNECTED (first->prev));
+        first->prev = idx;
+      }
+      l->next = queue->first;
+      queue->first = idx;
+      KISSAT_assert (DISCONNECTED (l->prev));
+      l->stamp = ++queue->stamp;
+    }
+    while (!DISCONNECTED (rest)) {
+      struct links *l = links + rest;
+      l->stamp = ++queue->stamp;
+      rest = l->next;
+    }
+    solver->queue.search.idx = queue->last;
+    solver->queue.search.stamp = queue->stamp;
+  }
+}
+
+static bool run_factorization (kissat *solver, uint64_t limit) {
+  factoring factoring;
+  init_factoring (solver, &factoring, limit);
+  schedule_factorization (&factoring);
+  bool done = false;
+#ifndef KISSAT_QUIET
+  unsigned factored = 0;
+#endif
+  uint64_t *ticks = &solver->statistics_.factor_ticks;
+  kissat_extremely_verbose (
+      solver, "factorization limit of %" PRIu64 " ticks", limit - *ticks);
+  while (!done && !kissat_empty_heap (&factoring.schedule)) {
+    const unsigned first =
+        kissat_pop_max_heap (solver, &factoring.schedule);
+    const unsigned first_idx = IDX (first);
+    if (!ACTIVE (first_idx))
+      continue;
+    if (*ticks > limit) {
+      kissat_very_verbose (solver, "factorization ticks limit hit");
+      break;
+    }
+    if (TERMINATED (factor_terminated_1))
+      break;
+    struct flags *f = solver->flags + first_idx;
+    const unsigned bit = 1u << NEGATED (first);
+    if (!(f->factor & bit))
+      continue;
+    f->factor &= ~bit;
+    const size_t first_count = first_factor (&factoring, first);
+    if (first_count > 1) {
+      for (;;) {
+        unsigned next_count;
+        const unsigned next = next_factor (&factoring, &next_count);
+        if (next == INVALID_LIT)
+          break;
+        KISSAT_assert (next_count > 1);
+        if (next_count < 2)
+          break;
+        factorize_next (&factoring, next, next_count);
+      }
+      size_t reduction;
+      quotient *q = best_quotient (&factoring, &reduction);
+      if (q && reduction > factoring.bound) {
+        if (apply_factoring (&factoring, q)) {
+#ifndef KISSAT_QUIET
+          factored++;
+#endif
+        } else
+          done = true;
+      }
+    }
+    release_quotients (&factoring);
+  }
+  bool completed = kissat_empty_heap (&factoring.schedule);
+  adjust_scores_and_phases_of_fresh_varaibles (&factoring);
+  release_factoring (&factoring);
+  REPORT (!factored, 'f');
+  return completed;
+}
+
+static void connect_clauses_to_factor (kissat *solver) {
+  const unsigned size_limit = GET_OPTION (factorsize);
+  if (size_limit < 3) {
+    kissat_extremely_verbose (solver, "only factorizing binary clauses");
+    return;
+  }
+  kissat_very_verbose (solver, "factorizing clauses of maximum size %u",
+                       size_limit);
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+  ward *const arena = BEGIN_STACK (solver->arena);
+  watches *all_watches = solver->watches;
+  unsigned *bincount, *largecount;
+  CALLOC (unsigned, bincount, LITS);
+  for (all_literals (lit)) {
+    if (!ACTIVE (IDX (lit)))
+      continue;
+    for (all_binary_large_watches (watch, WATCHES (lit))) {
+      KISSAT_assert (watch.type.binary);
+      const unsigned other = watch.type.lit;
+      if (lit > other)
+        continue;
+      bincount[lit]++;
+      bincount[other]++;
+    }
+  }
+  CALLOC (unsigned, largecount, LITS);
+  size_t initial_candidates = 0;
+  for (all_clauses (c)) {
+    if (c->garbage)
+      continue;
+    if (last_irredundant && last_irredundant < c)
+      break;
+    if (c->redundant)
+      continue;
+    if (c->size > size_limit)
+      continue;
+    for (all_literals_in_clause (lit, c))
+      largecount[lit]++;
+    initial_candidates++;
+  }
+  kissat_very_verbose (solver,
+                       "initially found %zu large clause candidates",
+                       initial_candidates);
+  size_t candidates = initial_candidates;
+  const unsigned rounds = GET_OPTION (factorcandrounds);
+  for (unsigned round = 1; round <= rounds; round++) {
+    size_t new_candidates = 0;
+    unsigned *newlargecount;
+    CALLOC (unsigned, newlargecount, LITS);
+    for (all_clauses (c)) {
+      if (c->garbage)
+        continue;
+      if (last_irredundant && last_irredundant < c)
+        break;
+      if (c->redundant)
+        continue;
+      if (c->size > size_limit)
+        continue;
+      for (all_literals_in_clause (lit, c))
+        if (bincount[lit] + largecount[lit] < 2)
+          goto CONTINUE_WITH_NEXT_CLAUSE1;
+      for (all_literals_in_clause (lit, c))
+        newlargecount[lit]++;
+      new_candidates++;
+    CONTINUE_WITH_NEXT_CLAUSE1:;
+    }
+    DEALLOC (largecount, LITS);
+    largecount = newlargecount;
+    if (candidates == new_candidates) {
+      kissat_very_verbose (solver,
+                           "no large factorization candidate clauses "
+                           "reduction in round %u",
+                           round);
+      break;
+    }
+    candidates = new_candidates;
+    kissat_very_verbose (
+        solver,
+        "reduced to %zu large factorization candidate clauses %.0f%% in "
+        "round %u",
+        candidates, kissat_percent (candidates, initial_candidates), round);
+  }
+#ifndef KISSAT_QUIET
+  size_t connected = 0;
+#endif
+  for (all_clauses (c)) {
+    if (c->garbage)
+      continue;
+    if (last_irredundant && last_irredundant < c)
+      break;
+    if (c->redundant)
+      continue;
+    if (c->size > size_limit)
+      continue;
+    int continue_with_next_clause2 = 0;
+    for (all_literals_in_clause (lit, c))
+      if (bincount[lit] + largecount[lit] < 2) {
+        continue_with_next_clause2 = 1;
+        break;
+      }
+    if(continue_with_next_clause2) {
+      continue;
+    }
+    const reference ref = (ward *) c - arena;
+    kissat_inlined_connect_clause (solver, all_watches, c, ref);
+#ifndef KISSAT_QUIET
+    connected++;
+#endif
+  }
+  DEALLOC (largecount, LITS);
+  DEALLOC (bincount, LITS);
+  kissat_very_verbose (
+      solver, "connected %zu large factorization candidate clauses %.0f%%",
+      connected, kissat_percent (candidates, initial_candidates));
+}
+
+void kissat_factor (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  if (solver->inconsistent)
+    return;
+  if (!GET_OPTION (factor))
+    return;
+  statistics *s = &solver->statistics_;
+  if (solver->limits.factor.marked >= s->literals_factor) {
+    kissat_extremely_verbose (
+        solver,
+        "factorization skipped as no literals have been marked to be added "
+        "(%" PRIu64 " < %" PRIu64,
+        solver->limits.factor.marked, s->literals_factor);
+    return;
+  }
+  START (factor);
+  INC (factorizations);
+  kissat_phase (solver, "factorization", GET (factorizations),
+                "binary clause bounded variable addition");
+  uint64_t limit = GET_OPTION (factoriniticks);
+  if (s->factorizations > 1) {
+    SET_EFFORT_LIMIT (tmp, factor, factor_ticks);
+    limit = tmp;
+  } else {
+    kissat_very_verbose (solver,
+                         "initially limiting to %" PRIu64
+                         " million factorization ticks",
+                         limit);
+    limit *= 1e6;
+    limit += s->factor_ticks;
+  }
+#ifndef KISSAT_QUIET
+  struct {
+    int64_t variables, binary, clauses, ticks;
+  } before, after, delta;
+  before.variables = s->variables_extension + s->variables_original;
+  before.binary = BINARY_CLAUSES;
+  before.clauses = IRREDUNDANT_CLAUSES;
+  before.ticks = s->factor_ticks;
+#endif
+  kissat_enter_dense_mode (solver, 0);
+  connect_clauses_to_factor (solver);
+  bool completed = run_factorization (solver, limit);
+  kissat_resume_sparse_mode (solver, false, 0);
+#ifndef KISSAT_QUIET
+  after.variables = s->variables_extension + s->variables_original;
+  after.binary = BINARY_CLAUSES;
+  after.clauses = IRREDUNDANT_CLAUSES;
+  after.ticks = s->factor_ticks;
+  delta.variables = after.variables - before.variables;
+  delta.binary = before.binary - after.binary;
+  delta.clauses = before.clauses - after.clauses;
+  delta.ticks = after.ticks - before.ticks;
+  kissat_very_verbose (solver, "used %f million factorization ticks",
+                       delta.ticks * 1e-6);
+  kissat_phase (solver, "factorization", GET (factorizations),
+                "introduced %" PRId64 " extension variables %.0f%%",
+                delta.variables,
+                kissat_percent (delta.variables, before.variables));
+  kissat_phase (solver, "factorization", GET (factorizations),
+                "removed %" PRId64 " binary clauses %.0f%%", delta.binary,
+                kissat_percent (delta.binary, before.binary));
+  kissat_phase (solver, "factorization", GET (factorizations),
+                "removed %" PRId64 " large clauses %.0f%%", delta.clauses,
+                kissat_percent (delta.clauses, before.clauses));
+#endif
+  if (completed)
+    solver->limits.factor.marked = s->literals_factor;
+  STOP (factor);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/factor.h b/src/sat/kissat/factor.h
new file mode 100644
index 000000000..fd433c8eb
--- /dev/null
+++ b/src/sat/kissat/factor.h
@@ -0,0 +1,14 @@
+#ifndef _factor_h_INCLUDED
+#define _factor_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+void kissat_factor (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/fastassign.h b/src/sat/kissat/fastassign.h
new file mode 100644
index 000000000..c0ad7b9ce
--- /dev/null
+++ b/src/sat/kissat/fastassign.h
@@ -0,0 +1,46 @@
+#ifndef _fastassign_h_INCLUDED
+#define _fastassign_h_INCLUDED
+
+#define FAST_ASSIGN
+
+#include "inline.h"
+#include "inlineassign.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+static inline void kissat_fast_binary_assign (
+    kissat *solver, const bool probing, const unsigned level, value *values,
+    assigned *assigned, unsigned lit, unsigned other) {
+  if (GET_OPTION (jumpreasons) && level && solver->classification.bigbig) {
+    unsigned other_idx = IDX (other);
+    struct assigned *a = assigned + other_idx;
+    if (a->binary) {
+      LOGBINARY (lit, other, "jumping %s reason", LOGLIT (lit));
+      INC (jumped_reasons);
+      other = a->reason;
+    }
+  }
+  kissat_fast_assign (solver, probing, level, values, assigned, true, lit,
+                      other);
+  LOGBINARY (lit, other, "assign %s reason", LOGLIT (lit));
+}
+
+static inline void
+kissat_fast_assign_reference (kissat *solver, value *values,
+                              assigned *assigned, unsigned lit,
+                              reference ref, clause *reason) {
+  KISSAT_assert (reason == kissat_dereference_clause (solver, ref));
+  const unsigned level =
+      kissat_assignment_level (solver, values, assigned, lit, reason);
+  KISSAT_assert (level <= solver->level);
+  KISSAT_assert (ref != DECISION_REASON);
+  KISSAT_assert (ref != UNIT_REASON);
+  kissat_fast_assign (solver, solver->probing, level, values, assigned,
+                      false, lit, ref);
+  LOGREF (ref, "assign %s reason", LOGLIT (lit));
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/fastel.c b/src/sat/kissat/fastel.c
new file mode 100644
index 000000000..a6de22f82
--- /dev/null
+++ b/src/sat/kissat/fastel.c
@@ -0,0 +1,938 @@
+#include "fastel.h"
+#include "dense.h"
+#include "eliminate.h"
+#include "inline.h"
+#include "internal.h"
+#include "print.h"
+#include "rank.h"
+#include "report.h"
+#include "terminate.h"
+#include "weaken.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static bool fast_forward_subsumed (kissat *solver, clause *c) {
+  KISSAT_assert (!c->garbage);
+  KISSAT_assert (!c->redundant);
+  unsigned max_occurring = INVALID_LIT;
+  size_t max_occurrence = 0;
+  watches *all_watches = solver->watches;
+  mark *marks = solver->marks;
+  value *values = solver->values;
+  for (all_literals_in_clause (other, c)) {
+    const unsigned other_idx = IDX (other);
+    if (!ACTIVE (other_idx))
+      continue;
+    watches *other_watches = all_watches + other;
+    size_t other_occurrence = SIZE_WATCHES (*other_watches);
+    if (other_occurrence <= max_occurrence)
+      continue;
+    max_occurrence = other_occurrence;
+    max_occurring = other;
+    marks[other] = 1;
+  }
+  bool subsumed = false;
+  const size_t fasteloccs = GET_OPTION (fasteloccs);
+  for (all_literals_in_clause (other, c)) {
+    if (other == max_occurring)
+      continue;
+    const unsigned other_idx = IDX (other);
+    if (!ACTIVE (other_idx))
+      continue;
+    watches *other_watches = all_watches + other;
+    const size_t size_other_watches = SIZE_WATCHES (*other_watches);
+    if (size_other_watches > fasteloccs)
+      continue;
+    for (all_binary_large_watches (watch, *other_watches)) {
+      if (watch.type.binary) {
+        const unsigned other2 = watch.type.lit;
+        if (marks[other2]) {
+          LOGBINARY (other, other2, "subsuming");
+          subsumed = true;
+          break;
+        }
+      } else {
+        const reference d_ref = watch.large.ref;
+        clause *d = kissat_dereference_clause (solver, d_ref);
+        if (d == c)
+          continue;
+        if (d->garbage)
+          continue;
+        if (d->size > c->size)
+          continue;
+        KISSAT_assert (!d->redundant);
+        subsumed = true;
+        for (all_literals_in_clause (other2, d)) {
+          if (values[other2] < 0)
+            continue;
+          if (!marks[other2]) {
+            subsumed = false;
+            break;
+          }
+        }
+        if (subsumed)
+          LOGCLS (d, "subsuming");
+      }
+    }
+    if (subsumed)
+      break;
+  }
+  for (all_literals_in_clause (other, c))
+    marks[other] = 0;
+  if (subsumed) {
+    LOGCLS (c, "subsumed");
+    kissat_mark_clause_as_garbage (solver, c);
+    INC (subsumed);
+    INC (fast_subsumed);
+  }
+  return subsumed;
+}
+
+static size_t flush_occurrences (kissat *solver, unsigned lit) {
+  const size_t fasteloccs = GET_OPTION (fasteloccs);
+  const size_t fastelclslim = GET_OPTION (fastelclslim);
+  const size_t fastelsub = GET_OPTION (fastelsub);
+  const value *const values = solver->values;
+  const flags *const all_flags = solver->flags;
+  watches *watches = &WATCHES (lit);
+  watch *begin = BEGIN_WATCHES (*watches);
+  watch *end = END_WATCHES (*watches);
+  watch *q = begin, *p = q;
+  size_t res = 0;
+  while (p != end) {
+    const watch watch = *q++ = *p++;
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      if (values[other] > 0)
+        continue;
+      const unsigned other_idx = IDX (other);
+      const flags *other_flags = all_flags + other_idx;
+      if (other_flags->eliminated) {
+        q--;
+        continue;
+      }
+    } else {
+      const reference ref = watch.large.ref;
+      clause *c = kissat_dereference_clause (solver, ref);
+      if (c->garbage) {
+        q--;
+        continue;
+      }
+      if (c->size > fastelclslim) {
+        res = fasteloccs + 1;
+        break;
+      }
+      for (all_literals_in_clause (other, c)) {
+        value other_value = values[other];
+        if (other_value > 0) {
+          LOGCLS (c, "%s satisfied", LOGLIT (other));
+          kissat_mark_clause_as_garbage (solver, c);
+          q--;
+          continue;
+        }
+      }
+      if (fastelsub && fast_forward_subsumed (solver, c)) {
+        q--;
+        continue;
+      }
+    }
+    if (++res > fasteloccs)
+      break;
+  }
+  if (q < p) {
+    while (p != end)
+      *q++ = *p++;
+    SET_END_OF_WATCHES (*watches, q);
+  }
+  return res;
+}
+
+static void do_fast_resolve_binary_binary (kissat *solver, unsigned pivot,
+                                           unsigned clit, unsigned dlit) {
+  KISSAT_assert (!FLAGS (IDX (clit))->eliminated);
+  KISSAT_assert (!FLAGS (IDX (dlit))->eliminated);
+  if (clit == NOT (dlit)) {
+    LOG ("resolvent tautological");
+    return;
+  }
+  value *values = solver->values;
+  value cval = values[clit];
+  if (cval > 0) {
+    LOG ("1st antecedent satisfied");
+    return;
+  }
+  value dval = values[dlit];
+  if (dval > 0) {
+    LOG ("2nd antecedent satisfied");
+    return;
+  }
+  if (cval < 0 && dval < 0) {
+    KISSAT_assert (!solver->inconsistent);
+    solver->inconsistent = true;
+    LOG ("resolved empty clause");
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    return;
+  }
+  if (cval < 0) {
+    LOG ("resolved unit clause %s", LOGLIT (dlit));
+    INC (eliminate_units);
+    kissat_learned_unit (solver, dlit);
+    return;
+  }
+  if (dval < 0) {
+    LOG ("resolved unit clause %s", LOGLIT (clit));
+    INC (eliminate_units);
+    kissat_learned_unit (solver, clit);
+    return;
+  }
+  if (clit == dlit) {
+    LOG ("resolved unit clause %s", LOGLIT (clit));
+    INC (eliminate_units);
+    kissat_learned_unit (solver, clit);
+    return;
+  }
+  KISSAT_assert (!cval);
+  KISSAT_assert (!dval);
+  unsigneds *clause = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*clause));
+  PUSH_STACK (*clause, clit);
+  PUSH_STACK (*clause, dlit);
+  LOGTMP ("%s resolvent", LOGVAR (pivot));
+#ifndef LOGGING
+  (void) pivot;
+#endif
+  kissat_new_irredundant_clause (solver);
+  CLEAR_STACK (*clause);
+}
+
+static void do_fast_resolve_binary_large (kissat *solver, unsigned pivot,
+                                          unsigned lit, clause *c) {
+  KISSAT_assert (!FLAGS (IDX (lit))->eliminated);
+  if (c->garbage)
+    return;
+  KISSAT_assert (!c->redundant);
+  value *values = solver->values;
+  value lit_val = values[lit];
+  if (lit_val > 0) {
+    LOG ("binary clause antecedent satisfied");
+    return;
+  }
+  unsigneds *clause = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*clause));
+  if (!lit_val)
+    PUSH_STACK (*clause, lit);
+  bool satisfied = false, tautological = false;
+  const unsigned not_lit = NOT (lit);
+  for (all_literals_in_clause (other, c)) {
+    const unsigned idx_other = IDX (other);
+    if (idx_other == pivot)
+      continue;
+    if (other == lit)
+      continue;
+    if (other == not_lit) {
+      LOG ("resolvent tautological");
+      tautological = true;
+      break;
+    }
+    value other_val = values[other];
+    if (other_val < 0)
+      continue;
+    if (other_val > 0) {
+      LOG ("large clause antecedent satisfied");
+      kissat_mark_clause_as_garbage (solver, c);
+      satisfied = true;
+      break;
+    }
+    PUSH_STACK (*clause, other);
+  }
+  if (satisfied || tautological) {
+    CLEAR_STACK (*clause);
+    return;
+  }
+  size_t size = SIZE_STACK (*clause);
+  if (!size) {
+    KISSAT_assert (!solver->inconsistent);
+    solver->inconsistent = true;
+    LOG ("resolved empty clause");
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    return;
+  }
+  if (size == 1) {
+    const unsigned unit = PEEK_STACK (*clause, 0);
+    CLEAR_STACK (*clause);
+    LOG ("resolved unit clause %s", LOGLIT (unit));
+    INC (eliminate_units);
+    kissat_learned_unit (solver, unit);
+    return;
+  }
+  LOGTMP ("%s resolvent", LOGVAR (pivot));
+  kissat_new_irredundant_clause (solver);
+  CLEAR_STACK (*clause);
+}
+
+static void do_fast_resolve_large_large (kissat *solver, unsigned pivot,
+                                         clause *c, clause *d) {
+  if (c->garbage)
+    return;
+  if (d->garbage)
+    return;
+  KISSAT_assert (!c->redundant);
+  KISSAT_assert (!d->redundant);
+  value *values = solver->values;
+  mark *marks = solver->marks;
+  unsigneds *clause = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*clause));
+  bool satisfied = false, tautological = false;
+  for (all_literals_in_clause (other, c)) {
+    const unsigned idx_other = IDX (other);
+    if (idx_other == pivot)
+      continue;
+    value other_val = values[other];
+    if (other_val < 0)
+      continue;
+    if (other_val > 0) {
+      LOG ("1st antecedent satisfied");
+      satisfied = true;
+      break;
+    }
+    PUSH_STACK (*clause, other);
+    marks[other] = 1;
+  }
+  if (satisfied || tautological) {
+    for (all_stack (unsigned, other, *clause))
+      marks[other] = 0;
+    CLEAR_STACK (*clause);
+    return;
+  }
+  size_t marked = SIZE_STACK (*clause);
+  for (all_literals_in_clause (other, d)) {
+    const unsigned idx_other = IDX (other);
+    if (idx_other == pivot)
+      continue;
+    value other_val = values[other];
+    if (other_val < 0)
+      continue;
+    if (other_val > 0) {
+      LOG ("2nd antecedent satisfied");
+      satisfied = true;
+      break;
+    }
+    mark mark_other = marks[other];
+    if (mark_other)
+      continue;
+    const unsigned not_other = NOT (other);
+    mark mark_not_other = marks[not_other];
+    if (mark_not_other) {
+      LOG ("tautological resolvent");
+      tautological = true;
+      break;
+    }
+    PUSH_STACK (*clause, other);
+  }
+  if (satisfied || tautological) {
+    for (all_stack (unsigned, other, *clause))
+      marks[other] = 0;
+    CLEAR_STACK (*clause);
+    return;
+  }
+  size_t size = SIZE_STACK (*clause);
+  if (!size) {
+    KISSAT_assert (!solver->inconsistent);
+    solver->inconsistent = true;
+    LOG ("resolved empty clause");
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    return;
+  }
+  if (size == 1) {
+    const unsigned unit = PEEK_STACK (*clause, 0);
+    CLEAR_STACK (*clause);
+    marks[unit] = 0;
+    LOG ("resolved unit clause %s", LOGLIT (unit));
+    INC (eliminate_units);
+    kissat_learned_unit (solver, unit);
+    return;
+  }
+  LOGTMP ("%s resolvent", LOGVAR (pivot));
+  kissat_new_irredundant_clause (solver);
+  RESIZE_STACK (*clause, marked);
+  for (all_stack (unsigned, other, *clause))
+    marks[other] = 0;
+  CLEAR_STACK (*clause);
+}
+
+static void do_fast_resolve (kissat *solver, unsigned pivot, watch cwatch,
+                             watch dwatch) {
+  KISSAT_assert (!solver->inconsistent);
+  LOGWATCH (LIT (pivot), cwatch, "1st fast %s elimination antecedent",
+            LOGVAR (pivot));
+  LOGWATCH (NOT (LIT (pivot)), dwatch, "1st fast %s elimination antecedent",
+            LOGVAR (pivot));
+  const unsigned clit = cwatch.binary.lit;
+  const unsigned dlit = dwatch.binary.lit;
+  const reference cref = cwatch.large.ref;
+  const reference dref = dwatch.large.ref;
+  const bool cbin = cwatch.type.binary;
+  const bool dbin = dwatch.type.binary;
+  clause *c = cbin ? 0 : kissat_dereference_clause (solver, cref);
+  clause *d = dbin ? 0 : kissat_dereference_clause (solver, dref);
+  if (cbin && dbin)
+    do_fast_resolve_binary_binary (solver, pivot, clit, dlit);
+  else if (cbin && !dbin)
+    do_fast_resolve_binary_large (solver, pivot, clit, d);
+  else if (!cbin && dbin)
+    do_fast_resolve_binary_large (solver, pivot, dlit, c);
+  else {
+    KISSAT_assert (!cbin), KISSAT_assert (!dbin);
+    do_fast_resolve_large_large (solver, pivot, c, d);
+  }
+}
+
+static void fast_delete_and_weaken_clauses (kissat *solver, unsigned lit) {
+  watches *all_watches = solver->watches;
+  watches *lit_watches = all_watches + lit;
+  value *values = solver->values;
+  for (all_binary_large_watches (watch, *lit_watches)) {
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      const value value = values[other];
+      if (value <= 0)
+        kissat_weaken_binary (solver, lit, other);
+      kissat_delete_binary (solver, lit, other);
+    } else {
+      const reference ref = watch.large.ref;
+      clause *c = kissat_dereference_clause (solver, ref);
+      if (!c->garbage) {
+        bool satisfied = false;
+        for (all_literals_in_clause (other, c))
+          if (values[other] > 0) {
+            satisfied = true;
+            break;
+          }
+        if (!satisfied)
+          kissat_weaken_clause (solver, lit, c);
+        kissat_mark_clause_as_garbage (solver, c);
+      }
+    }
+  }
+  RELEASE_WATCHES (*lit_watches);
+}
+
+static void do_fast_eliminate (kissat *solver, unsigned pivot) {
+  LOG ("fast variable elimination of %s", LOGVAR (pivot));
+  const unsigned lit = LIT (pivot);
+  const unsigned not_lit = NOT (lit);
+  watches *all_watches = solver->watches;
+  watches *lit_watches = all_watches + lit;
+  watches *not_lit_watches = all_watches + not_lit;
+  LOG ("occurs %zu positively", SIZE_WATCHES (*lit_watches));
+  LOG ("occurs %zu negatively", SIZE_WATCHES (*not_lit_watches));
+  watch *begin_lit_watches = BEGIN_WATCHES (*lit_watches);
+  watch *begin_not_lit_watches = BEGIN_WATCHES (*not_lit_watches);
+  watch *end_lit_watches = END_WATCHES (*lit_watches);
+  watch *end_not_lit_watches = END_WATCHES (*not_lit_watches);
+  for (watch *p = begin_lit_watches; p < end_lit_watches; p++)
+    for (watch *q = begin_not_lit_watches; q < end_not_lit_watches; q++) {
+      do_fast_resolve (solver, pivot, *p, *q);
+      if (solver->inconsistent)
+        return;
+      watches *new_all_watches = solver->watches;
+      const size_t i = p - begin_lit_watches;
+      const size_t j = q - begin_not_lit_watches;
+      all_watches = new_all_watches;
+      lit_watches = all_watches + lit;
+      not_lit_watches = all_watches + not_lit;
+      begin_lit_watches = BEGIN_WATCHES (*lit_watches);
+      begin_not_lit_watches = BEGIN_WATCHES (*not_lit_watches);
+      end_lit_watches = END_WATCHES (*lit_watches);
+      end_not_lit_watches = END_WATCHES (*not_lit_watches);
+      p = begin_lit_watches + i;
+      q = begin_not_lit_watches + j;
+    }
+  KISSAT_assert (!solver->inconsistent);
+  INC (eliminated);
+  INC (fast_eliminated);
+  kissat_mark_eliminated_variable (solver, pivot);
+  fast_delete_and_weaken_clauses (solver, lit);
+  fast_delete_and_weaken_clauses (solver, not_lit);
+}
+
+static bool can_fast_resolve_binary_binary (kissat *solver, unsigned clit,
+                                            unsigned dlit) {
+  KISSAT_assert (!FLAGS (IDX (clit))->eliminated);
+  KISSAT_assert (!FLAGS (IDX (dlit))->eliminated);
+  if (clit == NOT (dlit))
+    return false;
+  value *values = solver->values;
+  value cval = values[clit];
+  if (cval > 0)
+    return false;
+  value dval = values[dlit];
+  if (dval > 0)
+    return false;
+  if (cval < 0 && dval < 0) {
+    KISSAT_assert (!solver->inconsistent);
+    solver->inconsistent = true;
+    LOG ("resolved empty clause");
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    return false;
+  }
+  if (cval < 0) {
+    LOG ("resolved unit clause %s", LOGLIT (dlit));
+    INC (eliminate_units);
+    kissat_learned_unit (solver, dlit);
+    return false;
+  }
+  if (dval < 0) {
+    LOG ("resolved unit clause %s", LOGLIT (clit));
+    INC (eliminate_units);
+    kissat_learned_unit (solver, clit);
+    return false;
+  }
+  if (clit == dlit) {
+    LOG ("resolved unit clause %s", LOGLIT (clit));
+    INC (eliminate_units);
+    kissat_learned_unit (solver, clit);
+    return false;
+  }
+  KISSAT_assert (!cval);
+  KISSAT_assert (!dval);
+  return true;
+}
+
+static bool can_fast_resolve_binary_large (kissat *solver, unsigned pivot,
+                                           unsigned lit, clause *c) {
+  KISSAT_assert (!FLAGS (IDX (lit))->eliminated);
+  if (c->garbage)
+    return false;
+  KISSAT_assert (!c->redundant);
+  value *values = solver->values;
+  value lit_val = values[lit];
+  if (lit_val > 0)
+    return false;
+  const unsigned not_lit = NOT (lit);
+  bool found_lit = false;
+  for (all_literals_in_clause (other, c)) {
+    if (other == lit)
+      found_lit = true;
+    if (other == not_lit)
+      return false;
+    value other_val = values[other];
+    if (other_val > 0) {
+      LOG ("large clause antecedent satisfied");
+      kissat_mark_clause_as_garbage (solver, c);
+      return false;
+    }
+  }
+  if (found_lit) {
+    unsigneds *clause = &solver->clause;
+    KISSAT_assert (EMPTY_STACK (*clause));
+    for (all_literals_in_clause (other, c)) {
+      const unsigned idx = IDX (other);
+      if (idx == pivot)
+        continue;
+      value value = values[other];
+      if (value < 0)
+        continue;
+      KISSAT_assert (!value);
+      PUSH_STACK (*clause, other);
+    }
+    LOGTMP ("self-subsuming resolvent");
+    INC (strengthened);
+    INC (fast_strengthened);
+    const size_t size = SIZE_STACK (*clause);
+    const reference ref = kissat_reference_clause (solver, c);
+    if (!size) {
+      KISSAT_assert (!solver->inconsistent);
+      solver->inconsistent = true;
+      LOG ("resolved empty clause");
+      CHECK_AND_ADD_EMPTY ();
+      ADD_EMPTY_TO_PROOF ();
+    } else if (size == 1) {
+      const unsigned unit = PEEK_STACK (*clause, 0);
+      LOG ("resolved %s unit clause", LOGLIT (unit));
+      INC (eliminate_units);
+      kissat_learned_unit (solver, unit);
+    } else
+      kissat_new_irredundant_clause (solver);
+    CLEAR_STACK (*clause);
+    c = kissat_dereference_clause (solver, ref);
+    LOGCLS (c, "self-subsuming antecedent");
+    kissat_mark_clause_as_garbage (solver, c);
+    return false;
+  }
+  return true;
+}
+
+static bool can_fast_resolve_large_large (kissat *solver, unsigned pivot,
+                                          clause *c, clause *d) {
+  if (c->garbage)
+    return false;
+  if (d->garbage)
+    return false;
+  KISSAT_assert (!c->redundant);
+  KISSAT_assert (!d->redundant);
+  value *values = solver->values;
+  mark *marks = solver->marks;
+  bool satisfied = false;
+  unsigneds *clause = &solver->clause;
+  KISSAT_assert (EMPTY_STACK (*clause));
+  for (all_literals_in_clause (other, c)) {
+    const unsigned idx_other = IDX (other);
+    if (idx_other == pivot)
+      continue;
+    value other_val = values[other];
+    if (other_val < 0)
+      continue;
+    if (other_val > 0) {
+      satisfied = true;
+      LOGCLS (c, "%s satisfied", LOGLIT (other));
+      kissat_mark_clause_as_garbage (solver, c);
+      break;
+    }
+    KISSAT_assert (!marks[other]);
+    marks[other] = 1;
+    PUSH_STACK (*clause, other);
+  }
+  bool tautological = false;
+  if (!satisfied) {
+    for (all_literals_in_clause (other, d)) {
+      const unsigned idx_other = IDX (other);
+      if (idx_other == pivot)
+        continue;
+      value other_val = values[other];
+      if (other_val < 0)
+        continue;
+      if (other_val > 0) {
+        satisfied = true;
+        LOGCLS (d, "%s satisfied", LOGLIT (other));
+        kissat_mark_clause_as_garbage (solver, d);
+        break;
+      }
+      const unsigned not_other = NOT (other);
+      const mark mark_not_other = marks[not_other];
+      if (mark_not_other) {
+        tautological = true;
+        break;
+      }
+      const mark other_mark = marks[other];
+      if (other_mark)
+        continue;
+      PUSH_STACK (*clause, other);
+    }
+  }
+  for (all_literals_in_clause (other, c))
+    marks[other] = 0;
+  bool strengthened = false;
+  if (!satisfied && !tautological) {
+    const size_t size = SIZE_STACK (*clause);
+    if (!size) {
+      KISSAT_assert (!solver->inconsistent);
+      solver->inconsistent = true;
+      LOG ("resolved empty clause");
+      CHECK_AND_ADD_EMPTY ();
+      ADD_EMPTY_TO_PROOF ();
+      strengthened = true;
+    } else if (size == 1) {
+      const unsigned unit = PEEK_STACK (*clause, 0);
+      LOG ("resolved %s unit clause", LOGLIT (unit));
+      INC (eliminate_units);
+      kissat_learned_unit (solver, unit);
+      strengthened = true;
+    } else {
+      bool c_subsumed = false, d_subsumed = false;
+      bool marked = false;
+      if (size < c->size) {
+        marked = true;
+        for (all_stack (unsigned, other, *clause))
+          marks[other] = 1;
+        size_t count = 0;
+        for (all_literals_in_clause (other, c))
+          if (marks[other])
+            count++;
+        c_subsumed = (count >= size);
+      }
+      if (size < d->size) {
+        if (!marked) {
+          marked = true;
+          for (all_stack (unsigned, other, *clause))
+            marks[other] = 1;
+        }
+        size_t count = 0;
+        for (all_literals_in_clause (other, d))
+          if (marks[other])
+            count++;
+        d_subsumed = (count >= size);
+      }
+      if (marked) {
+        for (all_stack (unsigned, other, *clause))
+          marks[other] = 0;
+      }
+      if (c_subsumed || d_subsumed) {
+        LOGTMP ("self-subsuming resolvent");
+        INC (strengthened);
+        INC (fast_strengthened);
+        const reference c_ref = kissat_reference_clause (solver, c);
+        const reference d_ref = kissat_reference_clause (solver, d);
+        kissat_new_irredundant_clause (solver);
+        strengthened = true;
+        if (c_subsumed) {
+          c = kissat_dereference_clause (solver, c_ref);
+          LOGCLS (c, "self-subsuming antecedent");
+          kissat_mark_clause_as_garbage (solver, c);
+        }
+        if (d_subsumed) {
+          d = kissat_dereference_clause (solver, d_ref);
+          LOGCLS (d, "self-subsuming antecedent");
+          kissat_mark_clause_as_garbage (solver, d);
+        }
+        if (c_subsumed && d_subsumed)
+          INC (fast_subsumed);
+      }
+    }
+  }
+  CLEAR_STACK (*clause);
+  return !satisfied && !tautological && !strengthened;
+}
+
+static bool can_fast_resolve (kissat *solver, unsigned pivot, watch cwatch,
+                              watch dwatch) {
+  KISSAT_assert (!solver->inconsistent);
+  const unsigned clit = cwatch.binary.lit;
+  const unsigned dlit = dwatch.binary.lit;
+  const reference cref = cwatch.large.ref;
+  const reference dref = dwatch.large.ref;
+  const bool cbin = cwatch.type.binary;
+  const bool dbin = dwatch.type.binary;
+  clause *c = cbin ? 0 : kissat_dereference_clause (solver, cref);
+  clause *d = dbin ? 0 : kissat_dereference_clause (solver, dref);
+  if (cbin && dbin)
+    return can_fast_resolve_binary_binary (solver, clit, dlit);
+  if (cbin && !dbin)
+    return can_fast_resolve_binary_large (solver, pivot, clit, d);
+  if (!cbin && dbin)
+    return can_fast_resolve_binary_large (solver, pivot, dlit, c);
+  KISSAT_assert (!cbin), KISSAT_assert (!dbin);
+  return can_fast_resolve_large_large (solver, pivot, c, d);
+}
+
+static bool resolvents_limited (kissat *solver, unsigned pivot,
+                                size_t limit) {
+  const unsigned lit = LIT (pivot);
+  const unsigned not_lit = NOT (lit);
+  watches *all_watches = solver->watches;
+  watches *lit_watches = all_watches + lit;
+  watches *not_lit_watches = all_watches + not_lit;
+  watch *begin_lit_watches = BEGIN_WATCHES (*lit_watches);
+  watch *begin_not_lit_watches = BEGIN_WATCHES (*not_lit_watches);
+  watch *end_lit_watches = END_WATCHES (*lit_watches);
+  watch *end_not_lit_watches = END_WATCHES (*not_lit_watches);
+  size_t resolved = 0;
+  for (watch *p = begin_lit_watches; p < end_lit_watches; p++)
+    for (watch *q = begin_not_lit_watches; q < end_not_lit_watches; q++) {
+      if (can_fast_resolve (solver, pivot, *p, *q) && ++resolved > limit)
+        return false;
+      if (solver->inconsistent)
+        return false;
+      watches *new_all_watches = solver->watches;
+      const size_t i = p - begin_lit_watches;
+      const size_t j = q - begin_not_lit_watches;
+      all_watches = new_all_watches;
+      lit_watches = all_watches + lit;
+      not_lit_watches = all_watches + not_lit;
+      begin_lit_watches = BEGIN_WATCHES (*lit_watches);
+      begin_not_lit_watches = BEGIN_WATCHES (*not_lit_watches);
+      end_lit_watches = END_WATCHES (*lit_watches);
+      end_not_lit_watches = END_WATCHES (*not_lit_watches);
+      p = begin_lit_watches + i;
+      q = begin_not_lit_watches + j;
+    }
+  return true;
+}
+
+static bool try_to_fast_eliminate (kissat *solver, unsigned pivot) {
+  KISSAT_assert (!solver->inconsistent);
+  if (!ACTIVE (pivot))
+    return false;
+  const unsigned lit = LIT (pivot);
+  const unsigned not_lit = NOT (lit);
+  const size_t fasteloccs = GET_OPTION (fasteloccs);
+  const size_t pos = flush_occurrences (solver, lit);
+  if (pos > fasteloccs)
+    return false;
+  const size_t neg = flush_occurrences (solver, not_lit);
+  if (neg > fasteloccs)
+    return false;
+  const size_t sum = pos + neg;
+  const size_t product = pos * neg;
+  if (sum > fasteloccs)
+    return false;
+  const size_t fastelim = GET_OPTION (fastelim);
+  if (product <= fastelim) {
+    do_fast_eliminate (solver, pivot);
+    return true;
+  }
+  if (resolvents_limited (solver, pivot, fastelim)) {
+    do_fast_eliminate (solver, pivot);
+    return true;
+  }
+  return false;
+}
+
+static void flush_eliminated_binary_clauses_of_literal (kissat *solver,
+                                                        unsigned lit) {
+  flags *all_flags = solver->flags;
+  watches *watches = &WATCHES (lit);
+  watch *begin = BEGIN_WATCHES (*watches);
+  watch *end = END_WATCHES (*watches);
+  watch *q = begin, *p = q;
+  while (p != end) {
+    watch watch = *q++ = *p++;
+    if (!watch.type.binary)
+      continue;
+    const unsigned other = watch.binary.lit;
+    const unsigned other_idx = IDX (other);
+    flags *other_flags = all_flags + other_idx;
+    if (other_flags->eliminated)
+      q--;
+  }
+  SET_END_OF_WATCHES (*watches, q);
+}
+
+static void flush_eliminated_binary_clauses (kissat *solver) {
+  for (all_variables (idx)) {
+    const unsigned lit = LIT (idx);
+    const unsigned not_lit = NOT (lit);
+    flush_eliminated_binary_clauses_of_literal (solver, lit);
+    flush_eliminated_binary_clauses_of_literal (solver, not_lit);
+  }
+}
+
+struct candidate {
+  unsigned pivot;
+  unsigned score;
+};
+
+typedef struct candidate candidate;
+typedef STACK (candidate) candidates;
+
+#define RANK_CANDIDATE(CANDIDATE) ((CANDIDATE).score)
+
+void kissat_fast_variable_elimination (kissat *solver) {
+  if (solver->inconsistent)
+    return;
+  if (!GET_OPTION (fastel))
+    return;
+#ifndef KISSAT_QUIET
+  const unsigned variables_before = solver->active;
+#endif
+  KISSAT_assert (!solver->level);
+  START (fastel);
+  kissat_enter_dense_mode (solver, 0);
+  kissat_connect_irredundant_large_clauses (solver);
+  const unsigned fastelrounds = GET_OPTION (fastelrounds);
+  const size_t fasteloccs = GET_OPTION (fasteloccs);
+#ifndef KISSAT_QUIET
+  unsigned eliminated = 0;
+#endif
+  unsigned round = 0;
+  candidates candidates;
+  INIT_STACK (candidates);
+  bool done = false;
+  do {
+    if (round++ >= fastelrounds)
+      break;
+    kissat_extremely_verbose (
+        solver, "gathering candidates for fast elimination round %u",
+        round);
+    KISSAT_assert (EMPTY_STACK (candidates));
+    flags *all_flags = solver->flags;
+    for (all_variables (pivot)) {
+      flags *pivot_flags = all_flags + pivot;
+      if (!pivot_flags->active)
+        continue;
+      if (!pivot_flags->eliminate)
+        continue;
+      const unsigned lit = LIT (pivot);
+      const size_t pos = flush_occurrences (solver, lit);
+      if (pos > fasteloccs)
+        continue;
+      const unsigned not_lit = LIT (pivot);
+      const size_t neg = flush_occurrences (solver, not_lit);
+      if (neg > fasteloccs)
+        continue;
+      const unsigned score = pos + neg;
+      if (score > fasteloccs)
+        continue;
+      candidate candidate = {pivot, score};
+      PUSH_STACK (candidates, candidate);
+    }
+#ifndef KISSAT_QUIET
+    const size_t size_candidates = SIZE_STACK (candidates);
+    const size_t active_variables = solver->active;
+    kissat_extremely_verbose (
+        solver, "gathered %zu candidates %.0f%% in elimination round %u",
+        size_candidates, kissat_percent (size_candidates, active_variables),
+        round);
+#endif
+    RADIX_STACK (candidate, unsigned, candidates, RANK_CANDIDATE);
+    unsigned eliminated_this_round = 0;
+    for (all_stack (candidate, candidate, candidates)) {
+      const unsigned pivot = candidate.pivot;
+      flags *pivot_flags = all_flags + pivot;
+      if (!pivot_flags->active)
+        continue;
+      if (!pivot_flags->eliminate)
+        continue;
+      if (TERMINATED (fastel_terminated_1)) {
+        done = true;
+        break;
+      }
+      if (try_to_fast_eliminate (solver, pivot))
+        eliminated_this_round++;
+      if (solver->inconsistent) {
+        done = true;
+        break;
+      }
+      pivot_flags->eliminate = false;
+      kissat_flush_units_while_connected (solver);
+      if (solver->inconsistent) {
+        done = true;
+        break;
+      }
+    }
+    CLEAR_STACK (candidates);
+#ifndef KISSAT_QUIET
+    eliminated += eliminated_this_round;
+    kissat_very_verbose (
+        solver, "fast eliminated %u of %zu candidates %.0f%% in round %u",
+        eliminated_this_round, size_candidates,
+        kissat_percent (eliminated_this_round, size_candidates), round);
+#endif
+    if (!eliminated_this_round)
+      done = true;
+  } while (!done);
+  RELEASE_STACK (candidates);
+  for (all_variables (idx))
+    FLAGS (idx)->eliminate = true;
+  flush_eliminated_binary_clauses (solver);
+  kissat_resume_sparse_mode (solver, true, 0);
+#ifndef KISSAT_QUIET
+  const unsigned original_variables = solver->statistics.variables_original;
+  const unsigned variables_after = solver->active;
+  kissat_verbose (
+      solver,
+      "[fastel] "
+      "fast elimination of %u variables %.0f%% (%u remain %.0f%%)",
+      eliminated, kissat_percent (eliminated, variables_before),
+      variables_after,
+      kissat_percent (variables_after, original_variables));
+#endif
+  STOP (fastel);
+  REPORT (!eliminated, 'e');
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/fastel.h b/src/sat/kissat/fastel.h
new file mode 100644
index 000000000..56d711edd
--- /dev/null
+++ b/src/sat/kissat/fastel.h
@@ -0,0 +1,11 @@
+#ifndef _fastel_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+void kissat_fast_variable_elimination (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/fifo.h b/src/sat/kissat/fifo.h
new file mode 100644
index 000000000..b94cfa628
--- /dev/null
+++ b/src/sat/kissat/fifo.h
@@ -0,0 +1,102 @@
+#ifndef _fifo_h_INCLUDED
+#define _fifo_h_INCLUDED
+
+#include "stack.h"
+
+#include <string.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define FIFO(TYPE) \
+  struct { \
+    TYPE *begin; \
+    TYPE *end; \
+    TYPE *start; \
+    TYPE *limit; \
+    TYPE *allocated; \
+  }
+
+#define BEGIN_FIFO(F) ((F).begin)
+#define END_FIFO(F) ((F).end)
+#define START_FIFO(F) ((F).start)
+#define LIMIT_FIFO(F) ((F).limit)
+#define ALLOCATED_FIFO(F) ((F).allocated)
+
+#define INIT_FIFO(F) memset (&(F), 0, sizeof (F))
+
+#define EMPTY_FIFO(F) (END_FIFO (F) == BEGIN_FIFO (F))
+#define FULL_FIFO(F) (END_FIFO (F) == ALLOCATED_FIFO (F))
+#define SIZE_FIFO(F) (END_FIFO (F) - BEGIN_FIFO (F))
+
+#define MOVABLE_FIFO(F) (BEGIN_FIFO (F) == LIMIT_FIFO (F))
+#define CAPACITY_FIFO(F) (ALLOCATED_FIFO (F) - START_FIFO (F))
+
+#define ENLARGE_FIFO(T, F)                       \
+  do { \
+    size_t OLD_BEGIN_OFFSET = BEGIN_FIFO (F) - START_FIFO (F); \
+    size_t OLD_END_OFFSET = END_FIFO (F) - START_FIFO (F); \
+    size_t OLD_CAPACITY = CAPACITY_FIFO (F); \
+    size_t NEW_CAPACITY = OLD_CAPACITY ? 2 * OLD_CAPACITY : 2; \
+    size_t OLD_BYTES = OLD_CAPACITY * sizeof *BEGIN_FIFO (F); \
+    size_t NEW_BYTES = NEW_CAPACITY * sizeof *BEGIN_FIFO (F); \
+    START_FIFO (F) = \
+      (T*) kissat_realloc (solver, START_FIFO (F), OLD_BYTES, NEW_BYTES); \
+    ALLOCATED_FIFO (F) = START_FIFO (F) + NEW_CAPACITY; \
+    LIMIT_FIFO (F) = START_FIFO (F) + NEW_CAPACITY / 2; \
+    BEGIN_FIFO (F) = START_FIFO (F) + OLD_BEGIN_OFFSET; \
+    END_FIFO (F) = START_FIFO (F) + OLD_END_OFFSET; \
+    KISSAT_assert (BEGIN_FIFO (F) < LIMIT_FIFO (F)); \
+  } while (0)
+
+#define MOVE_FIFO(F) \
+  do { \
+    size_t SIZE = SIZE_FIFO (F); \
+    size_t BYTES = SIZE * sizeof *BEGIN_FIFO (F); \
+    memmove (START_FIFO (F), BEGIN_FIFO (F), BYTES); \
+    BEGIN_FIFO (F) = START_FIFO (F); \
+    END_FIFO (F) = BEGIN_FIFO (F) + SIZE; \
+  } while (0)
+
+#define ENQUEUE_FIFO(T, F, E)                    \
+  do { \
+    if (FULL_FIFO (F)) \
+      ENLARGE_FIFO (T, F);  \
+    *END_FIFO (F)++ = (E); \
+  } while (0)
+
+#define DEQUEUE_FIFO(F, E) \
+  do { \
+    KISSAT_assert (!EMPTY_FIFO (F)); \
+    (E) = *BEGIN_FIFO (F)++; \
+    if (MOVABLE_FIFO (F)) \
+      MOVE_FIFO (F); \
+  } while (0)
+
+#define POP_FIFO(F) (KISSAT_assert (!EMPTY_FIFO (F)), *--END_FIFO (F))
+
+#define RELEASE_FIFO(F) \
+  do { \
+    size_t CAPACITY = CAPACITY_FIFO (F); \
+    size_t BYTES = CAPACITY * sizeof *BEGIN_FIFO (F); \
+    kissat_free (solver, START_FIFO (F), BYTES); \
+    INIT_FIFO (F); \
+  } while (0)
+
+#define CLEAR_FIFO(F) \
+  do { \
+    BEGIN_FIFO (F) = END_FIFO (F) = START_FIFO (F); \
+  } while (0)
+
+struct unsigned_fifo {
+  unsigned *begin, *end;
+  unsigned *start, *limit, *allocated;
+};
+
+typedef struct unsigned_fifo unsigned_fifo;
+
+#define all_fifo all_stack
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/file.c b/src/sat/kissat/file.c
new file mode 100644
index 000000000..e4486783d
--- /dev/null
+++ b/src/sat/kissat/file.c
@@ -0,0 +1,322 @@
+#include "file.h"
+#include "keatures.h"
+#include "utilities.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef WIN32
+#define unlink _unlink
+#define access _access
+#define R_OK 4
+#define W_OK 2
+#else
+#include <unistd.h>
+#endif
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_file_exists (const char *path) {
+  if (!path)
+    return false;
+  struct stat buf;
+  if (stat (path, &buf))
+    return false;
+  return true;
+}
+
+bool kissat_file_readable (const char *path) {
+  if (!path)
+    return false;
+  struct stat buf;
+  if (stat (path, &buf))
+    return false;
+  if (access (path, R_OK))
+    return false;
+  return true;
+}
+
+bool kissat_file_writable (const char *path) {
+  int res;
+  if (!path)
+    res = 1;
+  else if (!strcmp (path, "/dev/null"))
+    res = 0;
+  else {
+    if (!*path)
+      res = 2;
+    else {
+      struct stat buf;
+      const char *p = strrchr (path, '/');
+      if (!p) {
+        if (stat (path, &buf)) {
+          if (errno == ENOENT)
+            res = 0;
+          else
+            res = -2;
+        } else if (S_ISDIR (buf.st_mode))
+          res = 3;
+        else if (access (path, W_OK))
+          res = 4;
+        else
+          res = 0;
+      } else if (!p[1])
+        res = 5;
+      else {
+        const size_t len = p - path;
+        char *dirname = (char*)malloc (len + 1);
+        if (dirname) {
+          strncpy (dirname, path, len);
+          dirname[len] = 0;
+          if (stat (dirname, &buf))
+            res = 6;
+          else if (!S_ISDIR (buf.st_mode))
+            res = 7;
+          else if (access (dirname, W_OK))
+            res = 8;
+          else if (stat (path, &buf)) {
+            if (errno == ENOENT)
+              res = 0;
+            else
+              res = -3;
+          } else if (access (path, W_OK))
+            res = 9;
+          else
+            res = 0;
+          free (dirname);
+        } else
+          res = 10;
+      }
+    }
+  }
+  return !res;
+}
+
+size_t kissat_file_size (const char *path) {
+  struct stat buf;
+  if (stat (path, &buf))
+    return 0;
+  return (size_t) buf.st_size;
+}
+
+bool kissat_find_executable (const char *name) {
+  const size_t name_len = strlen (name);
+  const char *environment = getenv ("PATH");
+  if (!environment)
+    return false;
+  const size_t dirs_len = strlen (environment);
+  char *dirs = (char*)malloc (dirs_len + 1);
+  if (!dirs)
+    return false;
+  strcpy (dirs, environment);
+  bool res = false;
+  const char *end = dirs + dirs_len + 1;
+  for (char *dir = dirs, *q; !res && dir != end; dir = q) {
+    for (q = dir; *q && *q != ':'; q++)
+      KISSAT_assert (q + 1 < end);
+    *q++ = 0;
+    const size_t path_len = (q - dir) + name_len;
+    char *path = (char*)malloc (path_len + 1);
+    if (!path) {
+      free (dirs);
+      return false;
+    }
+    sprintf (path, "%s/%s", dir, name);
+    KISSAT_assert (strlen (path) == path_len);
+    res = kissat_file_readable (path);
+    free (path);
+  }
+  free (dirs);
+  return res;
+}
+
+static int bz2sig[] = {0x42, 0x5A, 0x68, EOF};
+static int gzsig[] = {0x1F, 0x8B, EOF};
+static int lzmasig[] = {0x5D, 0x00, 0x00, 0x80, 0x00, EOF};
+static int sig7z[] = {0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C, EOF};
+static int xzsig[] = {0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00, 0x00, EOF};
+static int Zsig[] = {0x1F, 0x9D, 0x90, EOF};
+
+static bool match_signature (const char *path, const int *sig) {
+  KISSAT_assert (path);
+  FILE *tmp = fopen (path, "r");
+  if (!tmp)
+    return false;
+  bool res = true;
+  for (const int *p = sig; res && (*p != EOF); p++)
+    res = (getc (tmp) == *p);
+  fclose (tmp);
+  return res;
+}
+
+#ifdef KISSAT_HAS_COMPRESSION
+
+static FILE *open_pipe (const char *fmt, const char *path,
+                        const char *mode) {
+  size_t name_len = 0;
+  while (fmt[name_len] && fmt[name_len] != ' ')
+    name_len++;
+  char *name = (char*)malloc (name_len + 1);
+  if (!name)
+    return 0;
+  strncpy (name, fmt, name_len);
+  name[name_len] = 0;
+  bool found = kissat_find_executable (name);
+  free (name);
+  if (!found)
+    return 0;
+  char *cmd = (char*)malloc (strlen (fmt) + strlen (path));
+  if (!cmd)
+    return 0;
+  sprintf (cmd, fmt, path);
+  FILE *res = popen (cmd, mode);
+  free (cmd);
+  return res;
+}
+
+static FILE *read_pipe (const char *fmt, const int *sig, const char *path) {
+  if (!kissat_file_readable (path))
+    return 0;
+  if (sig && !match_signature (path, sig))
+    return 0;
+  return open_pipe (fmt, path, "r");
+}
+
+#ifndef SAFE
+
+static FILE *write_pipe (const char *fmt, const char *path) {
+  return open_pipe (fmt, path, "w");
+}
+
+#endif
+
+#endif
+
+void kissat_read_already_open_file (file *file, FILE *f, const char *path) {
+  file->file = f;
+  file->close = false;
+  file->reading = true;
+  file->compressed = false;
+  file->path = path;
+  file->bytes = 0;
+}
+
+void kissat_write_already_open_file (file *file, FILE *f,
+                                     const char *path) {
+  file->file = f;
+  file->close = false;
+  file->reading = false;
+  file->compressed = false;
+  file->path = path;
+  file->bytes = 0;
+}
+
+#ifndef KISSAT_HAS_COMPRESSION
+
+bool kissat_looks_like_a_compressed_file (const char *path) {
+#define RETURN_TRUE_IF_COMPRESSED(SUFFIX, SIGNATURE) \
+  if (kissat_has_suffix (path, SUFFIX) && \
+      match_signature (path, SIGNATURE)) \
+  return true
+
+  RETURN_TRUE_IF_COMPRESSED (".bz2", bz2sig);
+  RETURN_TRUE_IF_COMPRESSED (".gz", gzsig);
+  RETURN_TRUE_IF_COMPRESSED (".lzma", lzmasig);
+  RETURN_TRUE_IF_COMPRESSED (".7z", sig7z);
+  RETURN_TRUE_IF_COMPRESSED (".xz", xzsig);
+  RETURN_TRUE_IF_COMPRESSED (".Z", Zsig);
+
+  return false;
+}
+
+#endif
+
+bool kissat_open_to_read_file (file *file, const char *path) {
+#ifdef KISSAT_HAS_COMPRESSION
+#define READ_PIPE(SUFFIX, CMD, SIG) \
+  do { \
+    if (kissat_has_suffix (path, SUFFIX)) { \
+      file->file = read_pipe (CMD, SIG, path); \
+      if (!file->file) \
+        break; \
+      file->close = true; \
+      file->reading = true; \
+      file->compressed = true; \
+      file->path = path; \
+      file->bytes = 0; \
+      return true; \
+    } \
+  } while (0)
+  READ_PIPE (".bz2", "bzip2 -c -d %s", bz2sig);
+  READ_PIPE (".gz", "gzip -c -d %s", gzsig);
+  READ_PIPE (".lzma", "lzma -c -d %s", lzmasig);
+  READ_PIPE (".7z", "7z x -so %s 2>/dev/null", sig7z);
+  READ_PIPE (".xz", "xz -c -d %s", xzsig);
+  READ_PIPE (".Z", "gzip -c -d %s", Zsig);
+#endif
+  file->file = fopen (path, "r");
+  if (!file->file)
+    return false;
+  file->close = true;
+  file->reading = true;
+  file->compressed = false;
+  file->path = path;
+  file->bytes = 0;
+
+  return true;
+}
+
+bool kissat_open_to_write_file (file *file, const char *path) {
+#if defined(KISSAT_HAS_COMPRESSION) && !defined(SAFE)
+#define WRITE_PIPE(SUFFIX, CMD) \
+  do { \
+    if (kissat_has_suffix (path, SUFFIX)) { \
+      if (SUFFIX[1] == '7' && kissat_file_readable (path) && \
+          unlink (path)) \
+        return false; \
+      file->file = write_pipe (CMD, path); \
+      if (!file->file) \
+        return false; \
+      file->close = true; \
+      file->reading = false; \
+      file->compressed = true; \
+      file->path = path; \
+      file->bytes = 0; \
+      return true; \
+    } \
+  } while (0)
+  WRITE_PIPE (".bz2", "bzip2 -c > %s");
+  WRITE_PIPE (".gz", "gzip -c > %s");
+  WRITE_PIPE (".lzma", "lzma -c > %s");
+  WRITE_PIPE (".7z", "7z a -si %s 2>/dev/null");
+  WRITE_PIPE (".xz", "xz -c > %s");
+#endif
+  file->file = fopen (path, "w");
+  if (!file->file)
+    return false;
+  file->close = true;
+  file->reading = false;
+  file->compressed = false;
+  file->path = path;
+  file->bytes = 0;
+  return true;
+}
+
+void kissat_close_file (file *file) {
+  KISSAT_assert (file);
+  KISSAT_assert (file->file);
+#ifdef KISSAT_HAS_COMPRESSION
+  if (file->close && file->compressed)
+    pclose (file->file);
+#else
+  KISSAT_assert (!file->compressed);
+#endif
+  if (file->close && !file->compressed)
+    fclose (file->file);
+  file->file = 0;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/file.h b/src/sat/kissat/file.h
new file mode 100644
index 000000000..7658fa7d2
--- /dev/null
+++ b/src/sat/kissat/file.h
@@ -0,0 +1,129 @@
+#ifndef _file_h_INCLUDED
+#define _file_h_INCLUDED
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "attribute.h"
+#include "keatures.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+bool kissat_file_exists (const char *path);
+bool kissat_file_readable (const char *path);
+bool kissat_file_writable (const char *path);
+size_t kissat_file_size (const char *path);
+bool kissat_find_executable (const char *name);
+
+typedef struct file file;
+
+struct file {
+  FILE *file;
+  bool close;
+  bool reading;
+  bool compressed;
+  const char *path;
+  uint64_t bytes;
+};
+
+void kissat_read_already_open_file (file *, FILE *, const char *path);
+void kissat_write_already_open_file (file *, FILE *, const char *path);
+
+bool kissat_open_to_read_file (file *, const char *path);
+bool kissat_open_to_write_file (file *, const char *path);
+
+void kissat_close_file (file *);
+
+#ifndef KISSAT_HAS_COMPRESSION
+
+bool kissat_looks_like_a_compressed_file (const char *path);
+
+#endif
+
+// clang-format off
+
+static inline size_t
+kissat_read (file *, void *, size_t) ATTRIBUTE_ALWAYS_INLINE;
+
+static inline size_t
+kissat_write (file *, void *, size_t) ATTRIBUTE_ALWAYS_INLINE;
+
+static inline int kissat_getc (file *) ATTRIBUTE_ALWAYS_INLINE;
+
+static inline int kissat_putc (file *, int) ATTRIBUTE_ALWAYS_INLINE;
+
+static inline void kissat_flush (file *) ATTRIBUTE_ALWAYS_INLINE;
+
+// clang-format on
+
+static inline size_t kissat_read (file *file, void *ptr, size_t bytes) {
+  KISSAT_assert (file);
+  KISSAT_assert (file->file);
+  KISSAT_assert (file->reading);
+#ifdef KISSAT_HAS_UNLOCKEDIO
+  size_t res = fread_unlocked (ptr, 1, bytes, file->file);
+#else
+  size_t res = fread (ptr, 1, bytes, file->file);
+#endif
+  file->bytes += res;
+  return res;
+}
+
+static inline size_t kissat_write (file *file, void *ptr, size_t bytes) {
+  KISSAT_assert (file);
+  KISSAT_assert (file->file);
+  KISSAT_assert (!file->reading);
+#ifdef KISSAT_HAS_UNLOCKEDIO
+  size_t res = fwrite_unlocked (ptr, 1, bytes, file->file);
+#else
+  size_t res = fwrite (ptr, 1, bytes, file->file);
+#endif
+  file->bytes += res;
+  return res;
+}
+
+static inline int kissat_getc (file *file) {
+  KISSAT_assert (file);
+  KISSAT_assert (file->file);
+  KISSAT_assert (file->reading);
+#ifdef KISSAT_HAS_UNLOCKEDIO
+  int res = getc_unlocked (file->file);
+#else
+  int res = getc (file->file);
+#endif
+  if (res != EOF)
+    file->bytes++;
+  return res;
+}
+
+static inline int kissat_putc (file *file, int ch) {
+  KISSAT_assert (file);
+  KISSAT_assert (file->file);
+  KISSAT_assert (!file->reading);
+#ifdef KISSAT_HAS_UNLOCKEDIO
+  int res = putc_unlocked (ch, file->file);
+#else
+  int res = putc (ch, file->file);
+#endif
+  if (res != EOF)
+    file->bytes++;
+  return ch;
+}
+
+static inline void kissat_flush (file *file) {
+  KISSAT_assert (file);
+  KISSAT_assert (file->file);
+  KISSAT_assert (!file->reading);
+#ifdef KISSAT_HAS_UNLOCKEDIO
+  fflush_unlocked (file->file);
+#else
+  fflush (file->file);
+#endif
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/flags.c b/src/sat/kissat/flags.c
new file mode 100644
index 000000000..86a6d6186
--- /dev/null
+++ b/src/sat/kissat/flags.c
@@ -0,0 +1,119 @@
+#include "inline.h"
+#include "inlineheap.h"
+#include "inlinequeue.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static inline void activate_literal (kissat *solver, unsigned lit) {
+  const unsigned idx = IDX (lit);
+  flags *f = FLAGS (idx);
+  if (f->active)
+    return;
+  lit = STRIP (lit);
+  LOG ("activating %s", LOGVAR (idx));
+  f->active = true;
+  KISSAT_assert (!f->fixed);
+  KISSAT_assert (!f->eliminated);
+  solver->active++;
+  INC (variables_activated);
+  kissat_enqueue (solver, idx);
+  const double score = 1.0 - 1.0 / solver->statistics_.variables_activated;
+  kissat_update_heap (solver, &solver->scores, idx, score);
+  if (solver->stable) {
+    const unsigned lit = LIT (idx);
+    if (!VALUE (lit))
+      kissat_push_heap (solver, &solver->scores, idx);
+  }
+  KISSAT_assert (solver->unassigned < UINT_MAX);
+  solver->unassigned++;
+  kissat_mark_removed_literal (solver, lit);
+  kissat_mark_added_literal (solver, lit);
+  KISSAT_assert (!VALUE (lit));
+  KISSAT_assert (!VALUE (NOT (lit)));
+  KISSAT_assert (!SAVED (idx));
+  KISSAT_assert (!TARGET (idx));
+  KISSAT_assert (!BEST (idx));
+}
+
+static inline void deactivate_variable (kissat *solver, flags *f,
+                                        unsigned idx) {
+  KISSAT_assert (solver->flags + idx == f);
+  LOG ("deactivating %s", LOGVAR (idx));
+  KISSAT_assert (f->active);
+  KISSAT_assert (f->eliminated || f->fixed);
+  f->active = false;
+  KISSAT_assert (solver->active > 0);
+  solver->active--;
+  kissat_dequeue (solver, idx);
+  if (kissat_heap_contains (SCORES, idx))
+    kissat_pop_heap (solver, SCORES, idx);
+}
+
+void kissat_activate_literal (kissat *solver, unsigned lit) {
+  activate_literal (solver, lit);
+}
+
+void kissat_activate_literals (kissat *solver, unsigned size,
+                               unsigned *lits) {
+  for (unsigned i = 0; i < size; i++)
+    activate_literal (solver, lits[i]);
+}
+
+void kissat_mark_fixed_literal (kissat *solver, unsigned lit) {
+  KISSAT_assert (VALUE (lit) > 0);
+  const unsigned idx = IDX (lit);
+  LOG ("marking internal %s as fixed", LOGVAR (idx));
+  flags *f = FLAGS (idx);
+  KISSAT_assert (f->active);
+  KISSAT_assert (!f->eliminated);
+  KISSAT_assert (!f->fixed);
+  f->fixed = true;
+  deactivate_variable (solver, f, idx);
+  INC (units);
+  int elit = kissat_export_literal (solver, lit);
+  KISSAT_assert (elit);
+  PUSH_STACK (solver->units, elit);
+  LOG ("pushed external unit literal %d (internal %u)", elit, lit);
+}
+
+void kissat_mark_eliminated_variable (kissat *solver, unsigned idx) {
+  const unsigned lit = LIT (idx);
+  KISSAT_assert (!VALUE (lit));
+  LOG ("marking internal %s as eliminated", LOGVAR (idx));
+  flags *f = FLAGS (idx);
+  KISSAT_assert (f->active);
+  KISSAT_assert (!f->eliminated);
+  KISSAT_assert (!f->fixed);
+  f->eliminated = true;
+  deactivate_variable (solver, f, idx);
+  int elit = kissat_export_literal (solver, lit);
+  KISSAT_assert (elit);
+  KISSAT_assert (elit != INT_MIN);
+  unsigned eidx = ABS (elit);
+  import *import = &PEEK_STACK (solver->import, eidx);
+  KISSAT_assert (!import->eliminated);
+  KISSAT_assert (import->imported);
+  KISSAT_assert (STRIP (import->lit) == STRIP (lit));
+  size_t pos = SIZE_STACK (solver->eliminated);
+  KISSAT_assert (pos < (1u << 30));
+  import->lit = pos;
+  import->eliminated = true;
+  PUSH_STACK (solver->eliminated, (value) 0);
+  LOG ("marked external variable %u as eliminated", eidx);
+  KISSAT_assert (solver->unassigned > 0);
+  solver->unassigned--;
+}
+
+void kissat_mark_removed_literals (kissat *solver, unsigned size,
+                                   unsigned *lits) {
+  for (unsigned i = 0; i < size; i++)
+    kissat_mark_removed_literal (solver, lits[i]);
+}
+
+void kissat_mark_added_literals (kissat *solver, unsigned size,
+                                 unsigned *lits) {
+  for (unsigned i = 0; i < size; i++)
+    kissat_mark_added_literal (solver, lits[i]);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/flags.h b/src/sat/kissat/flags.h
new file mode 100644
index 000000000..33248314a
--- /dev/null
+++ b/src/sat/kissat/flags.h
@@ -0,0 +1,42 @@
+#ifndef _flags_h_INCLUDED
+#define _flags_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct flags flags;
+
+struct flags {
+  bool active : 1;
+  bool backbone0 : 1;
+  bool backbone1 : 1;
+  bool eliminate : 1;
+  bool eliminated : 1;
+  unsigned factor : 2;
+  bool fixed : 1;
+  bool subsume : 1;
+  bool sweep : 1;
+  bool transitive : 1;
+};
+
+#define FLAGS(IDX) (KISSAT_assert ((IDX) < VARS), (solver->flags + (IDX)))
+
+#define ACTIVE(IDX) (FLAGS (IDX)->active)
+#define ELIMINATED(IDX) (FLAGS (IDX)->eliminated)
+
+struct kissat;
+
+void kissat_activate_literal (struct kissat *, unsigned);
+void kissat_activate_literals (struct kissat *, unsigned, unsigned *);
+
+void kissat_mark_eliminated_variable (struct kissat *, unsigned idx);
+void kissat_mark_fixed_literal (struct kissat *, unsigned lit);
+
+void kissat_mark_added_literals (struct kissat *, unsigned, unsigned *);
+void kissat_mark_removed_literals (struct kissat *, unsigned, unsigned *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/format.c b/src/sat/kissat/format.c
new file mode 100644
index 000000000..b091a86bb
--- /dev/null
+++ b/src/sat/kissat/format.c
@@ -0,0 +1,149 @@
+#include "format.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+char *kissat_next_format_string (kormat *format) {
+  KISSAT_assert (format->pos < NUM_FORMAT_STRINGS);
+  char *res = format->str[format->pos++];
+  if (format->pos == NUM_FORMAT_STRINGS)
+    format->pos = 0;
+  return res;
+}
+
+static void format_count (char *res, uint64_t w) {
+  if (w >= 128 && kissat_is_power_of_two (w)) {
+    unsigned l;
+    for (l = 0; ((uint64_t) 1 << l) != w; l++)
+      KISSAT_assert (l + 1 < 8 * sizeof (word));
+    sprintf (res, "2^%u", l);
+  } else if (w >= 1000 && !(w % 1000)) {
+    unsigned l;
+    for (l = 0; !(w % 10); l++)
+      w /= 10;
+    sprintf (res, "%" PRIu64 "e%u", w, l);
+  } else
+    sprintf (res, "%" PRIu64, w);
+}
+
+const char *kissat_format_count (kormat *format, uint64_t w) {
+  char *res = kissat_next_format_string (format);
+  format_count (res, w);
+  return res;
+}
+
+const char *kissat_format_value (kormat *format, bool boolean, int value) {
+  if (boolean && value)
+    return "true";
+  if (boolean && !value)
+    return "false";
+  if (value == INT_MAX)
+    return "INT_MAX";
+  if (value == INT_MIN)
+    return "INT_MIN";
+  char *res = kissat_next_format_string (format);
+  if (value < 0) {
+    *res = '-';
+    format_count (res + 1, ABS (value));
+  } else
+    format_count (res, value);
+  return res;
+}
+
+const char *kissat_format_bytes (kormat *format, uint64_t bytes) {
+  char *res = kissat_next_format_string (format);
+  if (bytes < (1u << 10))
+    sprintf (res, "%" PRIu64 " bytes", bytes);
+  else if (bytes < (1u << 20))
+    sprintf (res, "%" PRIu64 " bytes (%" PRIu64 " KB)", bytes,
+             (bytes + (1 << 9)) >> 10);
+  else if (bytes < (1u << 30))
+    sprintf (res, "%" PRIu64 " bytes (%" PRIu64 " MB)", bytes,
+             (bytes + (1u << 19)) >> 20);
+  else
+    sprintf (res, "%" PRIu64 " bytes (%" PRIu64 " GB)", bytes,
+             (bytes + (1u << 29)) >> 30);
+  return res;
+}
+
+const char *kissat_format_time (kormat *format, double seconds) {
+  if (!seconds)
+    return "0s";
+  char *res = kissat_next_format_string (format);
+  uint64_t rounded = round (seconds);
+  uint64_t minutes = rounded / 60;
+  rounded %= 60;
+  uint64_t hours = minutes / 60;
+  minutes %= 60;
+  uint64_t days = hours / 24;
+  hours %= 24;
+  char *tmp = res;
+  if (days) {
+    sprintf (res, "%" PRIu64 "d", days);
+    tmp += strlen (res);
+  }
+  if (hours) {
+    if (tmp != res)
+      *tmp++ = ' ';
+    sprintf (tmp, "%" PRIu64 "h", hours);
+    tmp += strlen (tmp);
+  }
+  if (minutes) {
+    if (tmp != res)
+      *tmp++ = ' ';
+    sprintf (tmp, "%" PRIu64 "m", minutes);
+    tmp += strlen (tmp);
+  }
+  if (rounded) {
+    if (tmp != res)
+      *tmp++ = ' ';
+    sprintf (tmp, "%" PRIu64 "s", rounded);
+  }
+  return res;
+}
+
+const char *kissat_format_signs (kormat *format, unsigned size,
+                                 word signs) {
+  char *res = kissat_next_format_string (format);
+  KISSAT_assert (size + 1 < FORMAT_STRING_SIZE);
+  char *p = res;
+  word bit = 1;
+  for (unsigned i = 0; i < size; i++, bit <<= 1)
+    *p++ = (bit & signs) ? '1' : '0';
+  *p = 0;
+  return res;
+}
+
+const char *kissat_format_ordinal (kormat *format, uint64_t ordinal) {
+  char const *suffix;
+  unsigned mod100 = ordinal % 100;
+  if (10 <= mod100 && mod100 <= 19)
+    suffix = "th";
+  else {
+    switch (mod100 % 10) {
+    case 1:
+      suffix = "st";
+      break;
+    case 2:
+      suffix = "nd";
+      break;
+    case 3:
+      suffix = "rd";
+      break;
+    default:
+      suffix = "th";
+      break;
+    }
+  }
+  char *res = kissat_next_format_string (format);
+  sprintf (res, "%" PRIu64 "%s", ordinal, suffix);
+  return res;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/format.h b/src/sat/kissat/format.h
new file mode 100644
index 000000000..62e345e3b
--- /dev/null
+++ b/src/sat/kissat/format.h
@@ -0,0 +1,47 @@
+#ifndef _format_h_INCLUDED
+#define _format_h_INCLUDED
+
+#include "utilities.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define NUM_FORMAT_STRINGS 16
+#define FORMAT_STRING_SIZE 128
+
+typedef struct kormat kormat;
+
+struct kormat {
+  unsigned pos;
+  char str[NUM_FORMAT_STRINGS][FORMAT_STRING_SIZE];
+};
+
+char *kissat_next_format_string (kormat *);
+
+char const *kissat_format_bytes (kormat *, uint64_t bytes);
+char const *kissat_format_count (kormat *, uint64_t);
+char const *kissat_format_ordinal (kormat *, uint64_t);
+char const *kissat_format_signs (kormat *, unsigned size, word);
+char const *kissat_format_time (kormat *, double seconds);
+char const *kissat_format_value (kormat *, bool boolean, int value);
+
+#define FORMAT_BYTES(BYTES) kissat_format_bytes (&solver->format, BYTES)
+
+#define FORMAT_COUNT(WORD) kissat_format_count (&solver->format, WORD)
+
+#define FORMAT_ORDINAL(WORD) kissat_format_ordinal (&solver->format, WORD)
+
+#define FORMAT_SIGNS(SIZE, SIGNS) \
+  kissat_format_signs (&solver->format, SIZE, SIGNS)
+
+#define FORMAT_TIME(SECONDS) kissat_format_time (&solver->format, SECONDS)
+
+#define FORMAT_VALUE(BOOLEAN, VALUE) \
+  kissat_format_value (&solver->format, BOOLEAN, VALUE)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/forward.c b/src/sat/kissat/forward.c
new file mode 100644
index 000000000..098de2367
--- /dev/null
+++ b/src/sat/kissat/forward.c
@@ -0,0 +1,695 @@
+#include "forward.h"
+#include "allocate.h"
+#include "eliminate.h"
+#include "inline.h"
+#include "print.h"
+#include "rank.h"
+#include "report.h"
+#include "sort.h"
+#include "terminate.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static size_t remove_duplicated_binaries_with_literal (kissat *solver,
+                                                       unsigned lit) {
+  watches *watches = &WATCHES (lit);
+  value *marks = solver->marks;
+  flags *flags = solver->flags;
+
+  watch *begin = BEGIN_WATCHES (*watches), *q = begin;
+  const watch *const end = END_WATCHES (*watches), *p = q;
+
+  while (p != end) {
+    const watch watch = *q++ = *p++;
+    KISSAT_assert (watch.type.binary);
+    const unsigned other = watch.binary.lit;
+    struct flags *f = flags + IDX (other);
+    if (!f->active)
+      continue;
+    if (!f->subsume)
+      continue;
+    const value marked = marks[other];
+    if (marked) {
+      q--;
+      if (lit < other) {
+        kissat_delete_binary (solver, lit, other);
+        INC (duplicated);
+      }
+    } else {
+      const unsigned not_other = NOT (other);
+      if (marks[not_other]) {
+        LOGBINARY (lit, other,
+                   "duplicate hyper unary resolution on %s "
+                   "first antecedent",
+                   LOGLIT (other));
+        LOGBINARY (lit, not_other,
+                   "duplicate hyper unary resolution on %s "
+                   "second antecedent",
+                   LOGLIT (not_other));
+        PUSH_STACK (solver->delayed, lit);
+      }
+      marks[other] = 1;
+    }
+  }
+
+  for (const watch *r = begin; r != q; r++)
+    marks[r->binary.lit] = 0;
+
+  if (q == end)
+    return 0;
+
+  size_t removed = end - q;
+  SET_END_OF_WATCHES (*watches, q);
+  LOG ("removed %zu watches with literal %s", removed, LOGLIT (lit));
+
+  return removed;
+}
+
+static void remove_all_duplicated_binary_clauses (kissat *solver) {
+  LOG ("removing all duplicated irredundant binary clauses");
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG)
+  size_t removed = 0;
+#endif
+  KISSAT_assert (EMPTY_STACK (solver->delayed));
+
+  const flags *const all_flags = solver->flags;
+
+  for (all_variables (idx)) {
+    const flags *const flags = all_flags + idx;
+    if (!flags->active)
+      continue;
+    if (!flags->subsume)
+      continue;
+    const unsigned int lit = LIT (idx);
+    const unsigned int not_lit = NOT (lit);
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG)
+    removed +=
+#endif
+        remove_duplicated_binaries_with_literal (solver, lit);
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG)
+    removed +=
+#endif
+        remove_duplicated_binaries_with_literal (solver, not_lit);
+  }
+  KISSAT_assert (!(removed & 1));
+
+  size_t units = SIZE_STACK (solver->delayed);
+  if (units) {
+    LOG ("found %zu hyper unary resolved units", units);
+    const value *const values = solver->values;
+    for (all_stack (unsigned, unit, solver->delayed)) {
+
+      const value value = values[unit];
+      if (value > 0) {
+        LOG ("skipping satisfied resolved unit %s", LOGLIT (unit));
+        continue;
+      }
+      if (value < 0) {
+        LOG ("found falsified resolved unit %s", LOGLIT (unit));
+        CHECK_AND_ADD_EMPTY ();
+        ADD_EMPTY_TO_PROOF ();
+        solver->inconsistent = true;
+        break;
+      }
+      LOG ("new resolved unit clause %s", LOGLIT (unit));
+      kissat_learned_unit (solver, unit);
+    }
+    CLEAR_STACK (solver->delayed);
+    if (!solver->inconsistent)
+      kissat_flush_units_while_connected (solver);
+  }
+
+  REPORT (!removed && !units, '2');
+}
+
+static void find_forward_subsumption_candidates (kissat *solver,
+                                                 references *candidates) {
+  const unsigned clslim = GET_OPTION (subsumeclslim);
+
+  const value *const values = solver->values;
+  const flags *const flags = solver->flags;
+
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+
+  for (all_clauses (c)) {
+    if (last_irredundant && c > last_irredundant)
+      break;
+    if (c->garbage)
+      continue;
+    c->subsume = false;
+    if (c->redundant)
+      continue;
+    if (c->size > clslim)
+      continue;
+    KISSAT_assert (c->size > 2);
+    unsigned subsume = 0;
+    for (all_literals_in_clause (lit, c)) {
+      const unsigned idx = IDX (lit);
+      const struct flags *f = flags + idx;
+      if (f->subsume)
+        subsume++;
+      if (values[lit] > 0) {
+        LOGCLS (c, "satisfied by %s", LOGLIT (lit));
+        kissat_mark_clause_as_garbage (solver, c);
+        KISSAT_assert (c->garbage);
+        break;
+      }
+    }
+    if (c->garbage)
+      continue;
+    if (subsume < 2)
+      continue;
+    const unsigned ref = kissat_reference_clause (solver, c);
+    PUSH_STACK (*candidates, ref);
+  }
+}
+
+static inline unsigned
+get_size_of_reference (kissat *solver, ward *const arena, reference ref) {
+  KISSAT_assert (ref < SIZE_STACK (solver->arena));
+  const clause *const c = (clause *) (arena + ref);
+  (void) solver;
+  return c->size;
+}
+
+#define GET_SIZE_OF_REFERENCE(REF) \
+  get_size_of_reference (solver, arena, (REF))
+
+static void sort_forward_subsumption_candidates (kissat *solver,
+                                                 references *candidates) {
+  reference *references = BEGIN_STACK (*candidates);
+  size_t size = SIZE_STACK (*candidates);
+  ward *const arena = BEGIN_STACK (solver->arena);
+  RADIX_SORT (reference, unsigned, size, references, GET_SIZE_OF_REFERENCE);
+}
+
+static inline bool forward_literal (kissat *solver, unsigned lit,
+                                    bool binaries, unsigned *remove,
+                                    unsigned limit) {
+  watches *watches = &WATCHES (lit);
+  const size_t size_watches = SIZE_WATCHES (*watches);
+
+  if (!size_watches)
+    return false;
+
+  if (size_watches > limit)
+    return false;
+
+  watch *begin = BEGIN_WATCHES (*watches), *q = begin;
+  const watch *const end = END_WATCHES (*watches), *p = q;
+
+  uint64_t steps = 1 + kissat_cache_lines (size_watches, sizeof (watch));
+  uint64_t checks = 0;
+
+  const value *const values = solver->values;
+  const value *const marks = solver->marks;
+  ward *const arena = BEGIN_STACK (solver->arena);
+
+  bool subsume = false;
+
+  while (p != end) {
+    const watch watch = *q++ = *p++;
+
+    if (watch.type.binary) {
+      if (!binaries)
+        continue;
+
+      const unsigned other = watch.binary.lit;
+      if (marks[other]) {
+        LOGBINARY (lit, other, "forward subsuming");
+        subsume = true;
+        break;
+      } else {
+        const unsigned not_other = NOT (other);
+        if (marks[not_other]) {
+          LOGBINARY (lit, other, "forward %s strengthener", LOGLIT (other));
+          KISSAT_assert (!subsume);
+          *remove = not_other;
+          break;
+        }
+      }
+    } else {
+      const reference ref = watch.large.ref;
+      KISSAT_assert (ref < SIZE_STACK (solver->arena));
+      clause *d = (clause *) (arena + ref);
+      steps++;
+
+      if (d->garbage) {
+        q--;
+        continue;
+      }
+
+      checks++;
+      subsume = true;
+
+      unsigned candidate = INVALID_LIT;
+
+      for (all_literals_in_clause (other, d)) {
+        if (marks[other])
+          continue;
+        const value value = values[other];
+        if (value < 0)
+          continue;
+        if (value > 0) {
+          LOGCLS (d, "satisfied by %s", LOGLIT (other));
+          kissat_mark_clause_as_garbage (solver, d);
+          KISSAT_assert (d->garbage);
+          candidate = INVALID_LIT;
+          subsume = false;
+          break;
+        }
+        if (!subsume) {
+          KISSAT_assert (candidate != INVALID_LIT);
+          candidate = INVALID_LIT;
+          break;
+        }
+        subsume = false;
+        const unsigned not_other = NOT (other);
+        if (!marks[not_other]) {
+          KISSAT_assert (candidate == INVALID_LIT);
+          break;
+        }
+        candidate = not_other;
+      }
+
+      if (d->garbage) {
+        KISSAT_assert (!subsume);
+        q--;
+        break;
+      }
+
+      if (subsume) {
+        LOGCLS (d, "forward subsuming");
+        KISSAT_assert (subsume);
+        break;
+      }
+
+      if (candidate != INVALID_LIT) {
+        LOGCLS (d, "forward %s strengthener", LOGLIT (candidate));
+        *remove = candidate;
+      }
+    }
+  }
+
+  if (p != q) {
+    while (p != end)
+      *q++ = *p++;
+
+    SET_END_OF_WATCHES (*watches, q);
+  }
+
+  ADD (subsumption_checks, checks);
+  ADD (forward_checks, checks);
+  ADD (forward_steps, steps);
+
+  return subsume;
+}
+
+static inline bool forward_marked_clause (kissat *solver, clause *c,
+                                          unsigned *remove) {
+  const unsigned limit = GET_OPTION (subsumeocclim);
+  const flags *const flags = solver->flags;
+  INC (forward_steps);
+
+  for (all_literals_in_clause (lit, c)) {
+    const unsigned idx = IDX (lit);
+    if (!flags[idx].active)
+      continue;
+
+    KISSAT_assert (!VALUE (lit));
+
+    if (forward_literal (solver, lit, true, remove, limit))
+      return true;
+
+    if (forward_literal (solver, NOT (lit), false, remove, limit))
+      return true;
+  }
+  return false;
+}
+
+static bool forward_subsumed_clause (kissat *solver, clause *c,
+                                     bool *strengthened,
+                                     unsigneds *new_binaries) {
+  KISSAT_assert (!c->garbage);
+  LOGCLS2 (c, "trying to forward subsume");
+
+  value *marks = solver->marks;
+  const value *const values = solver->values;
+  unsigned non_false = 0, unit = INVALID_LIT;
+
+  for (all_literals_in_clause (lit, c)) {
+    const value value = values[lit];
+    if (value < 0)
+      continue;
+    if (value > 0) {
+      LOGCLS (c, "satisfied by %s", LOGLIT (lit));
+      kissat_mark_clause_as_garbage (solver, c);
+      KISSAT_assert (c->garbage);
+      break;
+    }
+    marks[lit] = 1;
+    if (non_false++)
+      unit ^= lit;
+    else
+      unit = lit;
+  }
+
+  if (c->garbage || non_false <= 1)
+    for (all_literals_in_clause (lit, c))
+      marks[lit] = 0;
+
+  if (c->garbage)
+    return false;
+
+  if (!non_false) {
+    LOGCLS (c, "found falsified clause");
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    solver->inconsistent = true;
+    return false;
+  }
+
+  if (non_false == 1) {
+    KISSAT_assert (VALID_INTERNAL_LITERAL (unit));
+    LOG ("new remaining non-false literal unit clause %s", LOGLIT (unit));
+    kissat_learned_unit (solver, unit);
+    kissat_mark_clause_as_garbage (solver, c);
+    kissat_flush_units_while_connected (solver);
+    return false;
+  }
+
+  unsigned remove = INVALID_LIT;
+  const bool subsume = forward_marked_clause (solver, c, &remove);
+
+  for (all_literals_in_clause (lit, c))
+    marks[lit] = 0;
+
+  if (subsume) {
+    LOGCLS (c, "forward subsumed");
+    kissat_mark_clause_as_garbage (solver, c);
+    INC (subsumed);
+    INC (forward_subsumed);
+  } else if (remove != INVALID_LIT) {
+    *strengthened = true;
+    INC (strengthened);
+    INC (forward_strengthened);
+    LOGCLS (c, "forward strengthening by removing %s in", LOGLIT (remove));
+    if (non_false == 2) {
+      unit ^= remove;
+      KISSAT_assert (VALID_INTERNAL_LITERAL (unit));
+      LOG ("forward strengthened unit clause %s", LOGLIT (unit));
+      kissat_learned_unit (solver, unit);
+      kissat_mark_clause_as_garbage (solver, c);
+      kissat_flush_units_while_connected (solver);
+      LOGCLS (c, "%s satisfied", LOGLIT (unit));
+    } else {
+      SHRINK_CLAUSE_IN_PROOF (c, remove, INVALID_LIT);
+      CHECK_SHRINK_CLAUSE (c, remove, INVALID_LIT);
+      kissat_mark_removed_literal (solver, remove);
+      if (non_false > 3) {
+        unsigned *lits = c->lits;
+        unsigned new_size = 0;
+        for (unsigned i = 0; i < c->size; i++) {
+          const unsigned lit = lits[i];
+          if (remove == lit)
+            continue;
+          const value value = values[lit];
+          if (value < 0)
+            continue;
+          KISSAT_assert (!value);
+          lits[new_size++] = lit;
+          kissat_mark_added_literal (solver, lit);
+        }
+        KISSAT_assert (new_size == non_false - 1);
+        KISSAT_assert (new_size > 2);
+        if (!c->shrunken) {
+          c->shrunken = true;
+          lits[c->size - 1] = INVALID_LIT;
+        }
+        c->size = new_size;
+        c->searched = 2;
+        c->subsume = true;
+        LOGCLS (c, "forward strengthened");
+      } else {
+        KISSAT_assert (non_false == 3);
+        LOGCLS (c, "garbage");
+        KISSAT_assert (!c->garbage);
+        const size_t bytes = kissat_actual_bytes_of_clause (c);
+        ADD (arena_garbage, bytes);
+        c->garbage = true;
+        unsigned first = INVALID_LIT, second = INVALID_LIT;
+        for (all_literals_in_clause (lit, c)) {
+          if (lit == remove)
+            continue;
+          const value value = values[lit];
+          if (value < 0)
+            continue;
+          KISSAT_assert (!value);
+          if (first == INVALID_LIT)
+            first = lit;
+          else {
+            KISSAT_assert (second == INVALID_LIT);
+            second = lit;
+          }
+          kissat_mark_added_literal (solver, lit);
+        }
+        KISSAT_assert (first != INVALID_LIT);
+        KISSAT_assert (second != INVALID_LIT);
+        LOGBINARY (first, second, "forward strengthened");
+        kissat_watch_other (solver, first, second);
+        kissat_watch_other (solver, second, first);
+        KISSAT_assert (new_binaries);
+        KISSAT_assert (solver->statistics_.clauses_irredundant);
+        solver->statistics_.clauses_irredundant--;
+        KISSAT_assert (solver->statistics_.clauses_binary < UINT64_MAX);
+        solver->statistics_.clauses_binary++;
+        PUSH_STACK (*new_binaries, first);
+        PUSH_STACK (*new_binaries, second);
+      }
+    }
+  }
+
+  return subsume;
+}
+
+static void connect_subsuming (kissat *solver, unsigned occlim, clause *c) {
+  KISSAT_assert (!c->garbage);
+
+  unsigned min_lit = INVALID_LIT;
+  size_t min_occs = MAX_SIZE_T;
+
+  const flags *const all_flags = solver->flags;
+
+  bool subsume = true;
+
+  for (all_literals_in_clause (lit, c)) {
+    const unsigned idx = IDX (lit);
+    const flags *const flags = all_flags + idx;
+    if (!flags->active)
+      continue;
+    if (!flags->subsume) {
+      subsume = false;
+      break;
+    }
+    watches *watches = &WATCHES (lit);
+    const size_t occs = SIZE_WATCHES (*watches);
+    if (min_lit != INVALID_LIT && occs > min_occs)
+      continue;
+    min_lit = lit;
+    min_occs = occs;
+  }
+  if (!subsume)
+    return;
+
+  if (min_occs > occlim)
+    return;
+  LOG ("connecting %s with %zu occurrences", LOGLIT (min_lit), min_occs);
+  const reference ref = kissat_reference_clause (solver, c);
+  kissat_connect_literal (solver, min_lit, ref);
+}
+
+static bool forward_subsume_all_clauses (kissat *solver) {
+  references candidates;
+  INIT_STACK (candidates);
+
+  find_forward_subsumption_candidates (solver, &candidates);
+#ifndef KISSAT_QUIET
+  size_t scheduled = SIZE_STACK (candidates);
+  kissat_phase (
+      solver, "forward", GET (forward_subsumptions),
+      "scheduled %zu irredundant clauses %.0f%%", scheduled,
+      kissat_percent (scheduled, solver->statistics_.clauses_irredundant));
+#endif
+  sort_forward_subsumption_candidates (solver, &candidates);
+
+  const reference *const end_of_candidates = END_STACK (candidates);
+  reference *p = BEGIN_STACK (candidates);
+
+#ifndef KISSAT_QUIET
+  size_t subsumed = 0;
+  size_t strengthened = 0;
+  size_t checked = 0;
+#endif
+  const unsigned occlim = GET_OPTION (subsumeocclim);
+
+  unsigneds new_binaries;
+  INIT_STACK (new_binaries);
+
+  {
+    SET_EFFORT_LIMIT (steps_limit, forward, forward_steps);
+
+    ward *arena = BEGIN_STACK (solver->arena);
+
+    while (p != end_of_candidates) {
+      if (solver->statistics_.forward_steps > steps_limit)
+        break;
+      if (TERMINATED (forward_terminated_1))
+        break;
+      reference ref = *p++;
+      clause *c = (clause *) (arena + ref);
+      KISSAT_assert (kissat_clause_in_arena (solver, c));
+      KISSAT_assert (!c->garbage);
+#ifndef KISSAT_QUIET
+      checked++;
+#endif
+      bool not_subsumed_but_strengthened = false;
+      if (forward_subsumed_clause (
+              solver, c, &not_subsumed_but_strengthened, &new_binaries)) {
+#ifndef KISSAT_QUIET
+        subsumed++;
+#endif
+      } else if (not_subsumed_but_strengthened) {
+#ifndef KISSAT_QUIET
+        strengthened++;
+#endif
+      }
+      if (solver->inconsistent)
+        break;
+      if (!c->garbage)
+        connect_subsuming (solver, occlim, c);
+    }
+  }
+#ifndef KISSAT_QUIET
+  if (subsumed)
+    kissat_phase (solver, "forward", GET (forward_subsumptions),
+                  "subsumed %zu clauses %.2f%% of %zu checked %.0f%%",
+                  subsumed, kissat_percent (subsumed, checked), checked,
+                  kissat_percent (checked, scheduled));
+  if (strengthened)
+    kissat_phase (solver, "forward", GET (forward_subsumptions),
+                  "strengthened %zu clauses %.2f%% of %zu checked %.0f%%",
+                  strengthened, kissat_percent (strengthened, checked),
+                  checked, kissat_percent (checked, scheduled));
+  if (!subsumed && !strengthened)
+    kissat_phase (solver, "forward", GET (forward_subsumptions),
+                  "no clause subsumed nor strengthened "
+                  "out of %zu checked %.0f%%",
+                  checked, kissat_percent (checked, scheduled));
+#endif
+  struct flags *flags = solver->flags;
+
+  for (all_variables (idx))
+    flags[idx].subsume = false;
+
+  ward *arena = BEGIN_STACK (solver->arena);
+  unsigned reactivated = 0;
+#ifndef KISSAT_QUIET
+  size_t remain = 0;
+#endif
+  for (reference *q = BEGIN_STACK (candidates); q != end_of_candidates;
+       q++) {
+    const reference ref = *q;
+    clause *c = (clause *) (arena + ref);
+    KISSAT_assert (kissat_clause_in_arena (solver, c));
+    if (c->garbage)
+      continue;
+    if (q < p && !c->subsume)
+      continue;
+#ifndef KISSAT_QUIET
+    remain++;
+#endif
+    for (all_literals_in_clause (lit, c)) {
+      const unsigned idx = IDX (lit);
+      struct flags *f = flags + idx;
+      if (f->subsume)
+        continue;
+      LOGCLS (c,
+              "reactivating subsume flag of %s "
+              "in remaining or strengthened",
+              LOGVAR (idx));
+      f->subsume = true;
+      KISSAT_assert (reactivated < UINT_MAX);
+      reactivated++;
+    }
+  }
+
+  while (!EMPTY_STACK (new_binaries)) {
+    unsigned lits[2];
+    lits[1] = POP_STACK (new_binaries);
+    lits[0] = POP_STACK (new_binaries);
+    for (unsigned i = 0; i < 2; i++) {
+      const unsigned lit = lits[i];
+      const unsigned idx = IDX (lit);
+      struct flags *f = flags + idx;
+      if (f->subsume)
+        continue;
+      LOGBINARY (lits[0], lits[1],
+                 "reactivating subsume flag of %s "
+                 "in strengthened binary clause",
+                 LOGVAR (idx));
+      f->subsume = true;
+      KISSAT_assert (reactivated < UINT_MAX);
+      reactivated++;
+    }
+  }
+  RELEASE_STACK (new_binaries);
+
+  kissat_very_verbose (solver,
+                       "marked %u variables %.0f%% to be reconsidered "
+                       "in next forward subsumption",
+                       reactivated,
+                       kissat_percent (reactivated, solver->active));
+#ifndef KISSAT_QUIET
+  if (remain)
+    kissat_phase (solver, "forward", GET (forward_subsumptions),
+                  "%zu unchecked clauses remain %.0f%%", remain,
+                  kissat_percent (remain, scheduled));
+  else
+    kissat_phase (solver, "forward", GET (forward_subsumptions),
+                  "all %zu scheduled clauses checked", scheduled);
+#endif
+  RELEASE_STACK (candidates);
+  REPORT (!subsumed, 's');
+
+  bool completed;
+  if (solver->inconsistent)
+    completed = true;
+  else if (reactivated)
+    completed = false;
+  else
+    completed = true;
+#ifndef KISSAT_QUIET
+  kissat_very_verbose (solver, "forward subsumption considered %scomplete",
+                       completed ? "" : "in");
+#endif
+  return completed;
+}
+
+bool kissat_forward_subsume_during_elimination (kissat *solver) {
+  START (subsume);
+  START (forward);
+  KISSAT_assert (GET_OPTION (forward));
+  INC (forward_subsumptions);
+  KISSAT_assert (!solver->watching);
+  remove_all_duplicated_binary_clauses (solver);
+  bool complete = true;
+  if (!solver->inconsistent)
+    complete = forward_subsume_all_clauses (solver);
+  STOP (forward);
+  STOP (subsume);
+  return complete;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/forward.h b/src/sat/kissat/forward.h
new file mode 100644
index 000000000..193173166
--- /dev/null
+++ b/src/sat/kissat/forward.h
@@ -0,0 +1,15 @@
+#ifndef _forward_h_INCLUDED
+#define _forward_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_forward_subsume_during_elimination (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/frames.h b/src/sat/kissat/frames.h
new file mode 100644
index 000000000..fd997cda9
--- /dev/null
+++ b/src/sat/kissat/frames.h
@@ -0,0 +1,37 @@
+#ifndef _frames_h_INCLUDED
+#define _frames_h_INCLUDED
+
+#include "literal.h"
+#include "stack.h"
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct frame frame;
+typedef struct slice slice;
+
+struct frame {
+  bool promote;
+  unsigned decision;
+  unsigned trail;
+  unsigned used;
+#ifndef KISSAT_NDEBUG
+  unsigned saved;
+#endif
+};
+
+// clang-format off
+
+typedef STACK (frame) frames;
+
+// clang-format on
+
+struct kissat;
+
+#define FRAME(LEVEL) (PEEK_STACK (solver->frames, (LEVEL)))
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/gates.c b/src/sat/kissat/gates.c
new file mode 100644
index 000000000..b63d4b25b
--- /dev/null
+++ b/src/sat/kissat/gates.c
@@ -0,0 +1,108 @@
+#include "gates.h"
+#include "ands.h"
+#include "definition.h"
+#include "eliminate.h"
+#include "equivalences.h"
+#include "ifthenelse.h"
+#include "inline.h"
+
+ABC_NAMESPACE_IMPL_START
+
+size_t kissat_mark_binaries (kissat *solver, unsigned lit) {
+  value *marks = solver->marks;
+  size_t res = 0;
+  watches *watches = &WATCHES (lit);
+  for (all_binary_large_watches (watch, *watches)) {
+    if (!watch.type.binary)
+      continue;
+    const unsigned other = watch.binary.lit;
+    KISSAT_assert (!solver->values[other]);
+    if (marks[other])
+      continue;
+    marks[other] = 1;
+    res++;
+  }
+  return res;
+}
+
+void kissat_unmark_binaries (kissat *solver, unsigned lit) {
+  value *marks = solver->marks;
+  watches *watches = &WATCHES (lit);
+  for (all_binary_large_watches (watch, *watches))
+    if (watch.type.binary)
+      marks[watch.binary.lit] = 0;
+}
+
+bool kissat_find_gates (kissat *solver, unsigned lit) {
+  solver->gate_eliminated = 0;
+  solver->resolve_gate = false;
+  if (!GET_OPTION (extract))
+    return false;
+  INC (gates_checked);
+  const unsigned not_lit = NOT (lit);
+  if (EMPTY_WATCHES (WATCHES (not_lit)))
+    return false;
+  bool res = false;
+  if (kissat_find_equivalence_gate (solver, lit))
+    res = true;
+  else if (kissat_find_and_gate (solver, lit, 0))
+    res = true;
+  else if (kissat_find_and_gate (solver, not_lit, 1))
+    res = true;
+  else if (kissat_find_if_then_else_gate (solver, lit, 0))
+    res = true;
+  else if (kissat_find_if_then_else_gate (solver, not_lit, 1))
+    res = true;
+  else if (kissat_find_definition (solver, lit))
+    res = true;
+  if (res)
+    INC (gates_extracted);
+  return res;
+}
+
+static void get_antecedents (kissat *solver, unsigned lit,
+                             unsigned negative) {
+  KISSAT_assert (!solver->watching);
+  KISSAT_assert (!negative || negative == 1);
+
+  statches *gates = solver->gates + negative;
+  watches *watches = &WATCHES (lit);
+
+  statches *antecedents = solver->antecedents + negative;
+  KISSAT_assert (EMPTY_STACK (*antecedents));
+
+  const watch *const begin_gates = BEGIN_STACK (*gates);
+  const watch *const end_gates = END_STACK (*gates);
+  watch const *g = begin_gates;
+
+  const watch *const begin_watches = BEGIN_WATCHES (*watches);
+  const watch *const end_watches = END_WATCHES (*watches);
+  watch const *w = begin_watches;
+
+  while (w != end_watches) {
+    const watch watch = *w++;
+    if (g != end_gates && g->raw == watch.raw)
+      g++;
+    else
+      PUSH_STACK (*antecedents, watch);
+  }
+
+  KISSAT_assert (g == end_gates);
+#ifdef LOGGING
+  size_t size_gates = SIZE_STACK (*gates);
+  size_t size_antecedents = SIZE_STACK (*antecedents);
+  size_t size_watches = SIZE_WATCHES (*watches);
+  LOG ("got %zu antecedent %.0f%% and %zu gate clauses %.0f%% "
+       "out of %zu watches of literal %s",
+       size_antecedents, kissat_percent (size_antecedents, size_watches),
+       size_gates, kissat_percent (size_gates, size_watches), size_watches,
+       LOGLIT (lit));
+#endif
+}
+
+void kissat_get_antecedents (kissat *solver, unsigned lit) {
+  get_antecedents (solver, lit, 0);
+  get_antecedents (solver, NOT (lit), 1);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/gates.h b/src/sat/kissat/gates.h
new file mode 100644
index 000000000..8f941aa3d
--- /dev/null
+++ b/src/sat/kissat/gates.h
@@ -0,0 +1,27 @@
+#ifndef _gates_h_INCLUDED
+#define _gates_h_INCLUDED
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+struct clause;
+
+bool kissat_find_gates (struct kissat *, unsigned lit);
+void kissat_get_antecedents (struct kissat *, unsigned lit);
+
+size_t kissat_mark_binaries (struct kissat *, unsigned lit);
+void kissat_unmark_binaries (struct kissat *, unsigned lit);
+
+#ifndef METRICS
+#define GATE_ELIMINATED(...) true
+#else
+#define GATE_ELIMINATED(NAME) (&solver->statistics.NAME##_eliminated)
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/global.h b/src/sat/kissat/global.h
new file mode 100644
index 000000000..bf9c030da
--- /dev/null
+++ b/src/sat/kissat/global.h
@@ -0,0 +1,20 @@
+#ifndef ABC_SAT_KISSAT_GLOBAL_H_
+#define ABC_SAT_KISSAT_GLOBAL_H_
+
+// comment out next line to enable kissat debug mode
+#define KISSAT_NDEBUG
+
+#define KISSAT_COMPACT
+#define KISSAT_NOPTIONS
+#define KISSAT_NPROOFS
+#define KISSAT_QUIET
+
+#ifdef KISSAT_NDEBUG
+#define KISSAT_assert(ignore) ((void)0)
+#else
+#define KISSAT_assert(cond) assert(cond)
+#endif
+
+#include "misc/util/abc_global.h"
+
+#endif
diff --git a/src/sat/kissat/handle.h b/src/sat/kissat/handle.h
new file mode 100644
index 000000000..03e5529ba
--- /dev/null
+++ b/src/sat/kissat/handle.h
@@ -0,0 +1,48 @@
+#ifndef _handle_h_INCLUDED
+#define _handle_h_INCLUDED
+
+#include <signal.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+void kissat_init_signal_handler (void (*handler) (int));
+void kissat_reset_signal_handler (void);
+
+void kissat_init_alarm (void (*handler) (void));
+void kissat_reset_alarm (void);
+
+#ifdef __MINGW32__
+#define SIGNAL_SIGBUS
+#else
+#define SIGNAL_SIGBUS SIGNAL (SIGBUS)
+#endif
+
+#define SIGNALS \
+  SIGNAL (SIGABRT) \
+  SIGNAL_SIGBUS \
+  SIGNAL (SIGINT) \
+  SIGNAL (SIGSEGV) \
+  SIGNAL (SIGTERM)
+
+// clang-format off
+
+static inline const char *
+kissat_signal_name (int sig)
+{
+#define SIGNAL(SIG) \
+  if (sig == SIG) return #SIG;
+  SIGNALS
+#undef SIGNAL
+#ifndef __MINGW32__
+  if (sig == SIGALRM)
+    return "SIGALRM";
+#endif
+  return "SIGUNKNOWN";
+}
+
+// clang-format on
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/heap.c b/src/sat/kissat/heap.c
new file mode 100644
index 000000000..584c58e6b
--- /dev/null
+++ b/src/sat/kissat/heap.c
@@ -0,0 +1,112 @@
+#include "allocate.h"
+#include "inlineheap.h"
+#include "internal.h"
+#include "logging.h"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_release_heap (kissat *solver, heap *heap) {
+  RELEASE_STACK (heap->stack);
+  DEALLOC (heap->pos, heap->size);
+  DEALLOC (heap->score, heap->size);
+  memset (heap, 0, sizeof *heap);
+}
+
+#ifndef KISSAT_NDEBUG
+
+void kissat_check_heap (heap *heap) {
+  const unsigned *const stack = BEGIN_STACK (heap->stack);
+  const unsigned end = SIZE_STACK (heap->stack);
+  const unsigned *const pos = heap->pos;
+  const double *const score = heap->score;
+  for (unsigned i = 0; i < end; i++) {
+    const unsigned idx = stack[i];
+    const unsigned idx_pos = pos[idx];
+    KISSAT_assert (idx_pos == i);
+    unsigned child_pos = HEAP_CHILD (idx_pos);
+    unsigned parent_pos = HEAP_PARENT (child_pos);
+    KISSAT_assert (parent_pos == idx_pos);
+    if (child_pos < end) {
+      unsigned child = stack[child_pos];
+      KISSAT_assert (score[idx] >= score[child]);
+      if (++child_pos < end) {
+        parent_pos = HEAP_PARENT (child_pos);
+        KISSAT_assert (parent_pos == idx_pos);
+        child = stack[child_pos];
+        KISSAT_assert (score[idx] >= score[child]);
+      }
+    }
+  }
+}
+
+#endif
+
+void kissat_resize_heap (kissat *solver, heap *heap, unsigned new_size) {
+  const unsigned old_size = heap->size;
+  if (old_size >= new_size)
+    return;
+  LOG ("resizing %s heap from %u to %u",
+       (heap->tainted ? "tainted" : "untainted"), old_size, new_size);
+
+  heap->pos = (unsigned*)kissat_nrealloc (solver, heap->pos, old_size, new_size,
+                               sizeof (unsigned));
+  if (heap->tainted) {
+    heap->score = (double*)kissat_nrealloc (solver, heap->score, old_size, new_size,
+                                   sizeof (double));
+  } else {
+    if (old_size)
+      DEALLOC (heap->score, old_size);
+    heap->score = (double*)kissat_calloc (solver, new_size, sizeof (double));
+  }
+  heap->size = new_size;
+#ifdef CHECK_HEAP
+  kissat_check_heap (heap);
+#endif
+}
+
+void kissat_rescale_heap (kissat *solver, heap *heap, double factor) {
+  LOG ("rescaling scores on heap with factor %g", factor);
+  double *score = heap->score;
+  for (unsigned i = 0; i < heap->vars; i++)
+    score[i] *= factor;
+#ifndef KISSAT_NDEBUG
+  kissat_check_heap (heap);
+#endif
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+void kissat_enlarge_heap (kissat *solver, heap *heap, unsigned new_vars) {
+  const unsigned old_vars = heap->vars;
+  KISSAT_assert (old_vars < new_vars);
+  KISSAT_assert (new_vars <= heap->size);
+  const size_t delta = new_vars - heap->vars;
+  memset (heap->pos + old_vars, 0xff, delta * sizeof (unsigned));
+  heap->vars = new_vars;
+  if (heap->tainted)
+    memset (heap->score + old_vars, 0, delta * sizeof (double));
+  LOG ("enlarged heap from %u to %u", old_vars, new_vars);
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+#ifndef KISSAT_NDEBUG
+
+static void dump_heap (heap *heap) {
+  for (unsigned i = 0; i < SIZE_STACK (heap->stack); i++)
+    printf ("heap.stack[%u] = %u\n", i, PEEK_STACK (heap->stack, i));
+  for (unsigned i = 0; i < heap->vars; i++)
+    printf ("heap.pos[%u] = %u\n", i, heap->pos[i]);
+  for (unsigned i = 0; i < heap->vars; i++)
+    printf ("heap.score[%u] = %g\n", i, heap->score[i]);
+}
+
+void kissat_dump_heap (heap *heap) { dump_heap (heap); }
+
+#endif
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/heap.h b/src/sat/kissat/heap.h
new file mode 100644
index 000000000..724ff2ab3
--- /dev/null
+++ b/src/sat/kissat/heap.h
@@ -0,0 +1,90 @@
+#ifndef _heap_h_INCLUDED
+#define _heap_h_INCLUDED
+
+#include "stack.h"
+#include "utilities.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define DISCONTAIN UINT_MAX
+#define DISCONTAINED(IDX) ((int) (IDX) < 0)
+
+typedef struct heap heap;
+
+struct heap {
+  bool tainted;
+  unsigned vars;
+  unsigned size;
+  unsigneds stack;
+  double *score;
+  unsigned *pos;
+};
+
+struct kissat;
+
+void kissat_resize_heap (struct kissat *, heap *, unsigned size);
+void kissat_release_heap (struct kissat *, heap *);
+
+static inline bool kissat_heap_contains (heap *heap, unsigned idx) {
+  return idx < heap->vars && !DISCONTAINED (heap->pos[idx]);
+}
+
+static inline unsigned kissat_get_heap_pos (const heap *heap,
+                                            unsigned idx) {
+  return idx < heap->vars ? heap->pos[idx] : DISCONTAIN;
+}
+
+static inline double kissat_get_heap_score (const heap *heap,
+                                            unsigned idx) {
+  return idx < heap->vars ? heap->score[idx] : 0.0;
+}
+
+static inline bool kissat_empty_heap (heap *heap) {
+  return EMPTY_STACK (heap->stack);
+}
+
+static inline size_t kissat_size_heap (heap *heap) {
+  return SIZE_STACK (heap->stack);
+}
+
+static inline unsigned kissat_max_heap (heap *heap) {
+  KISSAT_assert (!kissat_empty_heap (heap));
+  return PEEK_STACK (heap->stack, 0);
+}
+
+void kissat_rescale_heap (struct kissat *, heap *heap, double factor);
+
+void kissat_enlarge_heap (struct kissat *, heap *, unsigned new_vars);
+
+static inline double kissat_max_score_on_heap (heap *heap) {
+  if (!heap->tainted)
+    return 0;
+  KISSAT_assert (heap->vars);
+  const double *const score = heap->score;
+  const double *const end = score + heap->vars;
+  double res = score[0];
+  for (const double *p = score + 1; p != end; p++)
+    res = MAX (res, *p);
+  return res;
+}
+
+#ifndef KISSAT_NDEBUG
+void kissat_dump_heap (heap *);
+#endif
+
+#ifndef KISSAT_NDEBUG
+void kissat_check_heap (heap *);
+#else
+#define kissat_check_heap(...) \
+  do { \
+  } while (0)
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/ifthenelse.c b/src/sat/kissat/ifthenelse.c
new file mode 100644
index 000000000..b4224422e
--- /dev/null
+++ b/src/sat/kissat/ifthenelse.c
@@ -0,0 +1,178 @@
+#include "ifthenelse.h"
+#include "eliminate.h"
+#include "gates.h"
+#include "inline.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static bool get_ternary_clause (kissat *solver, reference ref, unsigned *p,
+                                unsigned *q, unsigned *r) {
+  clause *clause = kissat_dereference_clause (solver, ref);
+  if (clause->garbage)
+    return false;
+  const value *const values = solver->values;
+  unsigned a = INVALID_LIT, b = INVALID_LIT, c = INVALID_LIT;
+  unsigned found = 0;
+  for (all_literals_in_clause (other, clause)) {
+    const value value = values[other];
+    if (value > 0) {
+      kissat_eliminate_clause (solver, clause, INVALID_LIT);
+      return false;
+    }
+    if (value < 0)
+      continue;
+    if (++found == 1)
+      a = other;
+    else if (found == 2)
+      b = other;
+    else if (found == 3)
+      c = other;
+    else
+      return false;
+  }
+  if (found != 3)
+    return false;
+  KISSAT_assert (a != INVALID_LIT);
+  KISSAT_assert (b != INVALID_LIT);
+  KISSAT_assert (c != INVALID_LIT);
+  *p = a;
+  *q = b;
+  *r = c;
+  return true;
+}
+
+static bool match_ternary_ref (kissat *solver, reference ref, unsigned a,
+                               unsigned b, unsigned c) {
+  clause *clause = kissat_dereference_clause (solver, ref);
+  if (clause->garbage)
+    return false;
+  const value *const values = solver->values;
+  unsigned found = 0;
+  for (all_literals_in_clause (other, clause)) {
+    const value value = values[other];
+    if (value > 0) {
+      kissat_eliminate_clause (solver, clause, INVALID_LIT);
+      return false;
+    }
+    if (value < 0)
+      continue;
+    if (a != other && b != other && c != other)
+      return false;
+    found++;
+  }
+  if (found == 3)
+    return true;
+  solver->resolve_gate = true;
+  return true;
+}
+
+static bool match_ternary_watch (kissat *solver, watch watch, unsigned a,
+                                 unsigned b, unsigned c) {
+  if (watch.type.binary) {
+    const unsigned other = watch.binary.lit;
+    if (other != b && other != c)
+      return false;
+    solver->resolve_gate = true;
+    return true;
+  } else {
+    const reference ref = watch.large.ref;
+    return match_ternary_ref (solver, ref, a, b, c);
+  }
+}
+
+static inline const watch *find_ternary_clause (kissat *solver,
+                                                uint64_t *steps, unsigned a,
+                                                unsigned b, unsigned c) {
+  watches *watches = &WATCHES (a);
+  const watch *const begin = BEGIN_WATCHES (*watches);
+  const watch *const end = END_WATCHES (*watches);
+  for (const watch *p = begin; p != end; p++) {
+    *steps += 1;
+    if (match_ternary_watch (solver, *p, a, b, c))
+      return p;
+  }
+  return 0;
+}
+
+bool kissat_find_if_then_else_gate (kissat *solver, unsigned lit,
+                                    unsigned negative) {
+  if (!GET_OPTION (ifthenelse))
+    return false;
+  watches *watches = &WATCHES (lit);
+  const watch *const begin = BEGIN_WATCHES (*watches);
+  const watch *const end = END_WATCHES (*watches);
+  if (begin == end)
+    return false;
+  uint64_t large_clauses = 0;
+  for (const watch *p = begin; p != end; p++)
+    if (!p->type.binary)
+      large_clauses++;
+  const uint64_t limit = GET_OPTION (eliminateocclim);
+  if (large_clauses * large_clauses > limit)
+    return false;
+  const watch *const last = end - 1;
+  uint64_t steps = 0;
+  for (const watch *p1 = begin; steps < limit && p1 != last; p1++) {
+    watch w1 = *p1;
+    if (w1.type.binary)
+      continue;
+    unsigned a1, b1, c1;
+    if (!get_ternary_clause (solver, p1->large.ref, &a1, &b1, &c1))
+      continue;
+    if (b1 == lit)
+      SWAP (unsigned, a1, b1);
+    if (c1 == lit)
+      SWAP (unsigned, a1, c1);
+    KISSAT_assert (a1 == lit);
+    for (const watch *p2 = p1 + 1; steps < limit && p2 != end; p2++) {
+      watch w2 = *p2;
+      if (w2.type.binary)
+        continue;
+      unsigned a2, b2, c2;
+      if (!get_ternary_clause (solver, p2->large.ref, &a2, &b2, &c2))
+        continue;
+      if (b2 == lit)
+        SWAP (unsigned, a2, b2);
+      if (c2 == lit)
+        SWAP (unsigned, a2, c2);
+      KISSAT_assert (a2 == lit);
+      if (STRIP (b1) == STRIP (c2))
+        SWAP (unsigned, b2, c2);
+      if (STRIP (c1) == STRIP (c2))
+        continue;
+      const unsigned not_b2 = NOT (b2);
+      if (b1 != not_b2)
+        continue;
+      solver->resolve_gate = false;
+      const unsigned not_lit = NOT (lit);
+      const unsigned not_c1 = NOT (c1);
+      const watch *const p3 =
+          find_ternary_clause (solver, &steps, not_lit, b1, not_c1);
+      if (!p3)
+        continue;
+      const unsigned not_c2 = NOT (c2);
+      const watch *const p4 =
+          find_ternary_clause (solver, &steps, not_lit, b2, not_c2);
+      if (!p4)
+        continue;
+      watch w3 = p3 < p4 ? *p3 : *p4;
+      watch w4 = p3 < p4 ? *p4 : *p3;
+      LOGWATCH (lit, w1, "1st if-then-else");
+      LOGWATCH (lit, w2, "2nd if-then-else");
+      LOGWATCH (not_lit, w3, "3rd if-then-else");
+      LOGWATCH (not_lit, w4, "4th if-then-else");
+      LOG ("found if-then-else gate %s = (%s ? %s : %s)", LOGLIT (lit),
+           LOGLIT (NOT (b1)), LOGLIT (not_c1), LOGLIT (not_c2));
+      solver->gate_eliminated = GATE_ELIMINATED (if_then_else);
+      PUSH_STACK (solver->gates[negative], w1);
+      PUSH_STACK (solver->gates[negative], w2);
+      PUSH_STACK (solver->gates[!negative], w3);
+      PUSH_STACK (solver->gates[!negative], w4);
+      INC (if_then_else_extracted);
+      return true;
+    }
+  }
+  return false;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/ifthenelse.h b/src/sat/kissat/ifthenelse.h
new file mode 100644
index 000000000..8a9437d65
--- /dev/null
+++ b/src/sat/kissat/ifthenelse.h
@@ -0,0 +1,16 @@
+#ifndef _ifthenelse_h_INCLUDED
+#define _ifthenelse_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_find_if_then_else_gate (struct kissat *, unsigned lit,
+                                    unsigned negative);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/import.c b/src/sat/kissat/import.c
new file mode 100644
index 000000000..6f70ff58f
--- /dev/null
+++ b/src/sat/kissat/import.c
@@ -0,0 +1,104 @@
+#include "internal.h"
+#include "logging.h"
+#include "resize.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static void adjust_imports_for_external_literal (kissat *solver,
+                                                 unsigned eidx) {
+  while (eidx >= SIZE_STACK (solver->import)) {
+    struct import import;
+    import.lit = 0;
+    import.extension = false;
+    import.imported = false;
+    import.eliminated = false;
+    PUSH_STACK (solver->import, import);
+  }
+}
+
+static void adjust_exports_for_external_literal (kissat *solver,
+                                                 unsigned eidx,
+                                                 bool extension) {
+  struct import *import = &PEEK_STACK (solver->import, eidx);
+  unsigned iidx = solver->vars;
+  kissat_enlarge_variables (solver, iidx + 1);
+  unsigned ilit = 2 * iidx;
+  import->extension = extension;
+  import->imported = true;
+  if (extension)
+    INC (variables_extension);
+  else
+    INC (variables_original);
+  KISSAT_assert (!import->eliminated);
+  import->lit = ilit;
+  LOG ("importing %s external variable %u as internal literal %u",
+       extension ? "extension" : "original", eidx, ilit);
+  while (iidx >= SIZE_STACK (solver->export_))
+    PUSH_STACK (solver->export_, 0);
+  POKE_STACK (solver->export_, iidx, (int) eidx);
+  LOG ("exporting internal variable %u as external literal %u", iidx, eidx);
+}
+
+static inline unsigned import_literal (kissat *solver, int elit,
+                                       bool extension) {
+  const unsigned eidx = ABS (elit);
+  adjust_imports_for_external_literal (solver, eidx);
+  struct import *import = &PEEK_STACK (solver->import, eidx);
+  if (import->eliminated)
+    return INVALID_LIT;
+  unsigned ilit;
+  if (!import->imported)
+    adjust_exports_for_external_literal (solver, eidx, extension);
+  KISSAT_assert (import->imported);
+  ilit = import->lit;
+  if (elit < 0)
+    ilit = NOT (ilit);
+  KISSAT_assert (VALID_INTERNAL_LITERAL (ilit));
+  return ilit;
+}
+
+unsigned kissat_import_literal (kissat *solver, int elit) {
+  KISSAT_assert (VALID_EXTERNAL_LITERAL (elit));
+  if (GET_OPTION (tumble))
+    return import_literal (solver, elit, false);
+  const unsigned eidx = ABS (elit);
+  KISSAT_assert (SIZE_STACK (solver->import) <= UINT_MAX);
+  unsigned other = SIZE_STACK (solver->import);
+  if (eidx < other)
+    return import_literal (solver, elit, false);
+  if (!other)
+    adjust_imports_for_external_literal (solver, other++);
+
+  unsigned ilit = 0;
+  do {
+    KISSAT_assert (VALID_EXTERNAL_LITERAL ((int) other));
+    ilit = import_literal (solver, other, false);
+  } while (other++ < eidx);
+
+  if (elit < 0)
+    ilit = NOT (ilit);
+
+  return ilit;
+}
+
+unsigned kissat_fresh_literal (kissat *solver) {
+  size_t imported = SIZE_STACK (solver->import);
+  KISSAT_assert (imported <= EXTERNAL_MAX_VAR);
+  if (imported == EXTERNAL_MAX_VAR) {
+    LOG ("can not get another external variable");
+    return INVALID_LIT;
+  }
+  KISSAT_assert (imported <= (unsigned) INT_MAX);
+  int eidx = (int) imported;
+  unsigned res = import_literal (solver, eidx, true);
+#ifndef KISSAT_NDEBUG
+  struct import *import = &PEEK_STACK (solver->import, imported);
+  KISSAT_assert (import->imported);
+  KISSAT_assert (import->extension);
+#endif
+  INC (fresh);
+  kissat_activate_literal (solver, res);
+  return res;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/import.h b/src/sat/kissat/import.h
new file mode 100644
index 000000000..87261ec2f
--- /dev/null
+++ b/src/sat/kissat/import.h
@@ -0,0 +1,14 @@
+#ifndef _import_h_INLCUDED
+#define _import_h_INLCUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+unsigned kissat_import_literal (struct kissat *solver, int lit);
+unsigned kissat_fresh_literal (struct kissat *solver);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/inline.h b/src/sat/kissat/inline.h
new file mode 100644
index 000000000..e78cdeeea
--- /dev/null
+++ b/src/sat/kissat/inline.h
@@ -0,0 +1,333 @@
+#ifndef _inline_h_INCLUDED
+#define _inline_h_INCLUDED
+
+#include "inlinevector.h"
+#include "logging.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifdef METRICS
+
+static inline size_t kissat_allocated (kissat *solver) {
+  return solver->statistics.allocated_current;
+}
+
+#endif
+
+static inline bool kissat_propagated (kissat *solver) {
+  KISSAT_assert (BEGIN_ARRAY (solver->trail) <= solver->propagate);
+  KISSAT_assert (solver->propagate <= END_ARRAY (solver->trail));
+  return solver->propagate == END_ARRAY (solver->trail);
+}
+
+static inline bool kissat_trail_flushed (kissat *solver) {
+  return !solver->unflushed && EMPTY_ARRAY (solver->trail);
+}
+
+static inline void kissat_reset_propagate (kissat *solver) {
+  solver->propagate = BEGIN_ARRAY (solver->trail);
+}
+
+static inline value kissat_fixed (kissat *solver, unsigned lit) {
+  KISSAT_assert (lit < LITS);
+  const value res = solver->values[lit];
+  if (!res)
+    return 0;
+  if (LEVEL (lit))
+    return 0;
+  return res;
+}
+
+static inline void kissat_mark_removed_literal (kissat *solver,
+                                                unsigned lit) {
+  const unsigned idx = IDX (lit);
+  flags *flags = FLAGS (idx);
+  if (flags->fixed)
+    return;
+  if (!flags->eliminate) {
+    LOG ("marking %s to be eliminated", LOGVAR (idx));
+    flags->eliminate = true;
+    INC (variables_eliminate);
+  }
+}
+
+static inline void kissat_mark_added_literal (kissat *solver,
+                                              unsigned lit) {
+  const unsigned idx = IDX (lit);
+  flags *flags = FLAGS (idx);
+  if (!flags->subsume) {
+    LOG ("marking %s to forward subsume", LOGVAR (idx));
+    flags->subsume = true;
+    INC (variables_subsume);
+  }
+  const unsigned bit = 1u << NEGATED (lit);
+  if (!(flags->factor & bit)) {
+    flags->factor |= bit;
+    LOG ("marking literal %s to factor", LOGLIT (lit));
+    INC (literals_factor);
+  }
+}
+
+static inline void
+kissat_push_large_watch (kissat *solver, watches *watches, reference ref) {
+  const watch watch = kissat_large_watch (ref);
+  PUSH_WATCHES (*watches, watch);
+}
+
+static inline void kissat_push_binary_watch (kissat *solver,
+                                             watches *watches,
+                                             unsigned other) {
+  const watch watch = kissat_binary_watch (other);
+  PUSH_WATCHES (*watches, watch);
+}
+
+static inline void kissat_push_blocking_watch (kissat *solver,
+                                               watches *watches,
+                                               unsigned blocking,
+                                               reference ref) {
+  KISSAT_assert (solver->watching);
+  const watch head = kissat_blocking_watch (blocking);
+  PUSH_WATCHES (*watches, head);
+  const watch tail = kissat_large_watch (ref);
+  PUSH_WATCHES (*watches, tail);
+}
+
+static inline void kissat_watch_other (kissat *solver, unsigned lit,
+                                       unsigned other) {
+  LOGBINARY (lit, other, "watching %s blocking %s in", LOGLIT (lit),
+             LOGLIT (other));
+  watches *watches = &WATCHES (lit);
+  kissat_push_binary_watch (solver, watches, other);
+}
+
+static inline void kissat_watch_binary (kissat *solver, unsigned a,
+                                        unsigned b) {
+  kissat_watch_other (solver, a, b);
+  kissat_watch_other (solver, b, a);
+}
+
+static inline void kissat_watch_blocking (kissat *solver, unsigned lit,
+                                          unsigned blocking,
+                                          reference ref) {
+  KISSAT_assert (solver->watching);
+  LOGREF3 (ref, "watching %s blocking %s in", LOGLIT (lit),
+           LOGLIT (blocking));
+  watches *watches = &WATCHES (lit);
+  kissat_push_blocking_watch (solver, watches, blocking, ref);
+}
+
+static inline void kissat_unwatch_blocking (kissat *solver, unsigned lit,
+                                            reference ref) {
+  KISSAT_assert (solver->watching);
+  LOGREF3 (ref, "unwatching %s in", LOGLIT (lit));
+  watches *watches = &WATCHES (lit);
+  kissat_remove_blocking_watch (solver, watches, ref);
+}
+
+static inline void kissat_disconnect_binary (kissat *solver, unsigned lit,
+                                             unsigned other) {
+  KISSAT_assert (!solver->watching);
+  watches *watches = &WATCHES (lit);
+  const watch watch = kissat_binary_watch (other);
+  REMOVE_WATCHES (*watches, watch);
+}
+
+static inline void
+kissat_disconnect_reference (kissat *solver, unsigned lit, reference ref) {
+  KISSAT_assert (!solver->watching);
+  LOGREF3 (ref, "disconnecting %s in", LOGLIT (lit));
+  const watch watch = kissat_large_watch (ref);
+  watches *watches = &WATCHES (lit);
+  REMOVE_WATCHES (*watches, watch);
+}
+
+static inline void kissat_watch_reference (kissat *solver, unsigned a,
+                                           unsigned b, reference ref) {
+  KISSAT_assert (solver->watching);
+  kissat_watch_blocking (solver, a, b, ref);
+  kissat_watch_blocking (solver, b, a, ref);
+}
+
+static inline void kissat_connect_literal (kissat *solver, unsigned lit,
+                                           reference ref) {
+  KISSAT_assert (!solver->watching);
+  LOGREF3 (ref, "connecting %s in", LOGLIT (lit));
+  watches *watches = &WATCHES (lit);
+  kissat_push_large_watch (solver, watches, ref);
+}
+
+static inline clause *kissat_unchecked_dereference_clause (kissat *solver,
+                                                           reference ref) {
+  return (clause *) &PEEK_STACK (solver->arena, ref);
+}
+
+static inline clause *kissat_dereference_clause (kissat *solver,
+                                                 reference ref) {
+  clause *res = kissat_unchecked_dereference_clause (solver, ref);
+  KISSAT_assert (kissat_clause_in_arena (solver, res));
+  return res;
+}
+
+static inline reference kissat_reference_clause (kissat *solver,
+                                                 const clause *c) {
+  KISSAT_assert (kissat_clause_in_arena (solver, c));
+  return (ward *) c - BEGIN_STACK (solver->arena);
+}
+
+static inline void kissat_inlined_connect_clause (kissat *solver,
+                                                  watches *all_watches,
+                                                  clause *c,
+                                                  reference ref) {
+  KISSAT_assert (!solver->watching);
+  KISSAT_assert (ref == kissat_reference_clause (solver, c));
+  KISSAT_assert (c == kissat_dereference_clause (solver, ref));
+  for (all_literals_in_clause (lit, c)) {
+    KISSAT_assert (!solver->watching);
+    LOGREF3 (ref, "connecting %s in", LOGLIT (lit));
+    KISSAT_assert (lit < LITS);
+    watches *lit_watches = all_watches + lit;
+    kissat_push_large_watch (solver, lit_watches, ref);
+  }
+}
+
+static inline void kissat_watch_clause (kissat *solver, clause *c) {
+  KISSAT_assert (c->searched < c->size);
+  const reference ref = kissat_reference_clause (solver, c);
+  kissat_watch_reference (solver, c->lits[0], c->lits[1], ref);
+}
+
+static inline int kissat_export_literal (kissat *solver, unsigned ilit) {
+  const unsigned iidx = IDX (ilit);
+  KISSAT_assert (iidx < (unsigned) INT_MAX);
+  int elit = PEEK_STACK (solver->export_, iidx);
+  if (!elit)
+    return 0;
+  if (NEGATED (ilit))
+    elit = -elit;
+  KISSAT_assert (VALID_EXTERNAL_LITERAL (elit));
+  return elit;
+}
+
+static inline unsigned kissat_map_literal (kissat *solver, unsigned ilit,
+                                           bool map) {
+  if (!map)
+    return ilit;
+  int elit = kissat_export_literal (solver, ilit);
+  if (!elit)
+    return INVALID_LIT;
+  const unsigned eidx = ABS (elit);
+  const import *const import = &PEEK_STACK (solver->import, eidx);
+  if (import->eliminated)
+    return INVALID_LIT;
+  unsigned mlit = import->lit;
+  if (elit < 0)
+    mlit = NOT (mlit);
+  return mlit;
+}
+
+static inline clause *kissat_last_irredundant_clause (kissat *solver) {
+  return (solver->last_irredundant == INVALID_REF)
+             ? 0
+             : kissat_dereference_clause (solver, solver->last_irredundant);
+}
+
+static inline clause *kissat_binary_conflict (kissat *solver, unsigned a,
+                                              unsigned b) {
+  LOGBINARY (a, b, "conflicting");
+  clause *res = &solver->conflict;
+  res->size = 2;
+  unsigned *lits = res->lits;
+  lits[0] = a;
+  lits[1] = b;
+  return res;
+}
+
+static inline void kissat_push_analyzed (kissat *solver, assigned *assigned,
+                                         unsigned idx) {
+  KISSAT_assert (idx < VARS);
+  struct assigned *a = assigned + idx;
+  KISSAT_assert (!a->analyzed);
+  a->analyzed = true;
+  PUSH_STACK (solver->analyzed, idx);
+  LOG2 ("%s analyzed", LOGVAR (idx));
+}
+
+static inline bool kissat_analyzed (kissat *solver) {
+  return !EMPTY_STACK (solver->analyzed);
+}
+
+static inline void
+kissat_push_removable (kissat *solver, assigned *assigned, unsigned idx) {
+  KISSAT_assert (idx < VARS);
+  struct assigned *a = assigned + idx;
+  KISSAT_assert (!a->removable);
+  a->removable = true;
+  PUSH_STACK (solver->removable, idx);
+  LOG2 ("%s removable", LOGVAR (idx));
+}
+
+static inline void kissat_push_poisoned (kissat *solver, assigned *assigned,
+                                         unsigned idx) {
+  KISSAT_assert (idx < VARS);
+  struct assigned *a = assigned + idx;
+  KISSAT_assert (!a->poisoned);
+  a->poisoned = true;
+  PUSH_STACK (solver->poisoned, idx);
+  LOG2 ("%s poisoned", LOGVAR (idx));
+}
+
+static inline void
+kissat_push_shrinkable (kissat *solver, assigned *assigned, unsigned idx) {
+  KISSAT_assert (idx < VARS);
+  struct assigned *a = assigned + idx;
+  KISSAT_assert (!a->shrinkable);
+  a->shrinkable = true;
+  PUSH_STACK (solver->shrinkable, idx);
+  LOG2 ("%s shrinkable", LOGVAR (idx));
+}
+
+static inline int kissat_checking (kissat *solver) {
+#ifndef KISSAT_NDEBUG
+#ifdef KISSAT_NOPTIONS
+  (void) solver;
+#endif
+  return GET_OPTION (check);
+#else
+  (void) solver;
+  return 0;
+#endif
+}
+
+static inline bool kissat_logging (kissat *solver) {
+#ifdef LOGGING
+#ifdef KISSAT_NOPTIONS
+  (void) solver;
+#endif
+  return GET_OPTION (log) > 0;
+#else
+  (void) solver;
+  return false;
+#endif
+}
+
+static inline bool kissat_proving (kissat *solver) {
+#ifdef KISSAT_NPROOFS
+  (void) solver;
+  return false;
+#else
+  return solver->proof != 0;
+#endif
+}
+
+static inline bool kissat_checking_or_proving (kissat *solver) {
+  return kissat_checking (solver) || kissat_proving (solver);
+}
+
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS)
+#define CHECKING_OR_PROVING
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/inlineassign.h b/src/sat/kissat/inlineassign.h
new file mode 100644
index 000000000..8ac2b7c7c
--- /dev/null
+++ b/src/sat/kissat/inlineassign.h
@@ -0,0 +1,107 @@
+#ifndef _inlineassign_h_INLCUDED
+#define _inlineassign_h_INLCUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifdef FAST_ASSIGN
+#define kissat_assign kissat_fast_assign
+#endif
+
+static inline void kissat_assign (kissat *solver, const bool probing,
+                                  const unsigned level,
+#ifdef FAST_ASSIGN
+                                  value *values, assigned *assigned,
+#endif
+                                  bool binary, unsigned lit,
+                                  unsigned reason) {
+  const unsigned not_lit = NOT (lit);
+
+  watches watches = WATCHES (not_lit);
+  if (!kissat_empty_vector (&watches)) {
+    watch *w = BEGIN_WATCHES (watches);
+#ifndef WIN32
+    __builtin_prefetch (w, 0, 1);
+#endif
+  }
+
+#ifndef FAST_ASSIGN
+  value *values = solver->values;
+#endif
+  KISSAT_assert (!values[lit]);
+  KISSAT_assert (!values[not_lit]);
+
+  values[lit] = 1;
+  values[not_lit] = -1;
+
+  KISSAT_assert (solver->unassigned > 0);
+  solver->unassigned--;
+
+  if (!level) {
+    kissat_mark_fixed_literal (solver, lit);
+    KISSAT_assert (solver->unflushed < UINT_MAX);
+    solver->unflushed++;
+    if (reason != UNIT_REASON) {
+      CHECK_AND_ADD_UNIT (lit);
+      ADD_UNIT_TO_PROOF (lit);
+      reason = UNIT_REASON;
+      binary = false;
+    }
+  }
+
+  const size_t trail = SIZE_ARRAY (solver->trail);
+  PUSH_ARRAY (solver->trail, lit);
+
+  const unsigned idx = IDX (lit);
+
+#if !defined(PROBING_PROPAGATION)
+  if (!probing) {
+    const bool negated = NEGATED (lit);
+    const value new_value = BOOL_TO_VALUE (negated);
+    value *saved = &SAVED (idx);
+    *saved = new_value;
+  }
+#endif
+
+  struct assigned b;
+
+  b.level = level;
+  b.trail = trail;
+
+  b.analyzed = false;
+  b.binary = binary;
+  b.poisoned = false;
+  b.reason = reason;
+  b.removable = false;
+  b.shrinkable = false;
+
+#ifndef FAST_ASSIGN
+  assigned *assigned = solver->assigned;
+#endif
+  struct assigned *a = assigned + idx;
+  *a = b;
+}
+
+static inline unsigned
+kissat_assignment_level (kissat *solver, value *values, assigned *assigned,
+                         unsigned lit, clause *reason) {
+  unsigned res = 0;
+  for (all_literals_in_clause (other, reason)) {
+    if (other == lit)
+      continue;
+    KISSAT_assert (values[other] < 0), (void) values;
+    const unsigned other_idx = IDX (other);
+    struct assigned *a = assigned + other_idx;
+    const unsigned level = a->level;
+    if (res < level)
+      res = level;
+  }
+#ifdef KISSAT_NDEBUG
+  (void) solver;
+#endif
+  return res;
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/inlineframes.h b/src/sat/kissat/inlineframes.h
new file mode 100644
index 000000000..09c772681
--- /dev/null
+++ b/src/sat/kissat/inlineframes.h
@@ -0,0 +1,23 @@
+#ifndef _inlineframes_h_INCLUDEDd
+#define _inlineframes_h_INCLUDEDd
+
+#include "allocate.h"
+#include "internal.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+static inline void kissat_push_frame (kissat *solver, unsigned decision) {
+  KISSAT_assert (!solver->level || decision != UINT_MAX);
+  const size_t trail = SIZE_ARRAY (solver->trail);
+  frame frame;
+  frame.decision = decision;
+  frame.promote = false;
+  frame.trail = trail;
+  frame.used = 0;
+  PUSH_STACK (solver->frames, frame);
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/inlineheap.h b/src/sat/kissat/inlineheap.h
new file mode 100644
index 000000000..cf379b488
--- /dev/null
+++ b/src/sat/kissat/inlineheap.h
@@ -0,0 +1,181 @@
+#ifndef _inlineheap_h_INCLUDED
+#define _inlineheap_h_INCLUDED
+
+#include "allocate.h"
+#include "internal.h"
+#include "logging.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define HEAP_CHILD(POS) (KISSAT_assert ((POS) < (1u << 31)), (2 * (POS) + 1))
+
+#define HEAP_PARENT(POS) (KISSAT_assert ((POS) > 0), (((POS) - 1) / 2))
+
+static inline void kissat_bubble_up (kissat *solver, heap *heap,
+                                     unsigned idx) {
+  unsigned *stack = BEGIN_STACK (heap->stack);
+  unsigned *pos = heap->pos;
+  unsigned idx_pos = pos[idx];
+  const double *const score = heap->score;
+  const double idx_score = score[idx];
+  while (idx_pos) {
+    const unsigned parent_pos = HEAP_PARENT (idx_pos);
+    const unsigned parent = stack[parent_pos];
+    if (score[parent] >= idx_score)
+      break;
+    LOG ("heap bubble up: %u@%u = %g swapped with %u@%u = %g", parent,
+         parent_pos, score[parent], idx, idx_pos, idx_score);
+    stack[idx_pos] = parent;
+    pos[parent] = idx_pos;
+    idx_pos = parent_pos;
+  }
+  stack[idx_pos] = idx;
+  pos[idx] = idx_pos;
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+static inline void kissat_bubble_down (kissat *solver, heap *heap,
+                                       unsigned idx) {
+  unsigned *stack = BEGIN_STACK (heap->stack);
+  const unsigned end = SIZE_STACK (heap->stack);
+  unsigned *pos = heap->pos;
+  unsigned idx_pos = pos[idx];
+  const double *const score = heap->score;
+  const double idx_score = score[idx];
+  for (;;) {
+    unsigned child_pos = HEAP_CHILD (idx_pos);
+    if (child_pos >= end)
+      break;
+    unsigned child = stack[child_pos];
+    double child_score = score[child];
+    const unsigned sibling_pos = child_pos + 1;
+    if (sibling_pos < end) {
+      const unsigned sibling = stack[sibling_pos];
+      const double sibling_score = score[sibling];
+      if (sibling_score > child_score) {
+        child = sibling;
+        child_pos = sibling_pos;
+        child_score = sibling_score;
+      }
+    }
+    if (child_score <= idx_score)
+      break;
+    LOG ("heap bubble down: %u@%u = %g swapped with %u@%u = %g", child,
+         child_pos, score[child], idx, idx_pos, idx_score);
+    stack[idx_pos] = child;
+    pos[child] = idx_pos;
+    idx_pos = child_pos;
+  }
+  stack[idx_pos] = idx;
+  pos[idx] = idx_pos;
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+#define HEAP_IMPORT(IDX) \
+  do { \
+    KISSAT_assert ((IDX) < UINT_MAX - 1); \
+    if (heap->vars <= (IDX)) \
+      kissat_enlarge_heap (solver, heap, (IDX) + 1); \
+  } while (0)
+
+#define CHECK_HEAP_IMPORTED(IDX)
+
+static inline void kissat_push_heap (kissat *solver, heap *heap,
+                                     unsigned idx) {
+  LOG ("push heap %u", idx);
+  KISSAT_assert (!kissat_heap_contains (heap, idx));
+  HEAP_IMPORT (idx);
+  heap->pos[idx] = SIZE_STACK (heap->stack);
+  PUSH_STACK (heap->stack, idx);
+  kissat_bubble_up (solver, heap, idx);
+}
+
+static inline void kissat_pop_heap (kissat *solver, heap *heap,
+                                    unsigned idx) {
+  LOG ("pop heap %u", idx);
+  KISSAT_assert (kissat_heap_contains (heap, idx));
+  const unsigned last = POP_STACK (heap->stack);
+  heap->pos[last] = DISCONTAIN;
+  if (last == idx)
+    return;
+  const unsigned idx_pos = heap->pos[idx];
+  heap->pos[idx] = DISCONTAIN;
+  POKE_STACK (heap->stack, idx_pos, last);
+  heap->pos[last] = idx_pos;
+  kissat_bubble_up (solver, heap, last);
+  kissat_bubble_down (solver, heap, last);
+#ifdef CHECK_HEAP
+  kissat_check_heap (heap);
+#endif
+}
+
+static inline unsigned kissat_pop_max_heap (kissat *solver, heap *heap) {
+  KISSAT_assert (!EMPTY_STACK (heap->stack));
+  unsigneds *stack = &heap->stack;
+  unsigned *const begin = BEGIN_STACK (*stack);
+  const unsigned idx = *begin;
+  KISSAT_assert (!heap->pos[idx]);
+  LOG ("pop max heap %u", idx);
+  const unsigned last = POP_STACK (*stack);
+  unsigned *const pos = heap->pos;
+  pos[last] = DISCONTAIN;
+  if (last == idx)
+    return idx;
+  pos[idx] = DISCONTAIN;
+  *begin = last;
+  pos[last] = 0;
+  kissat_bubble_down (solver, heap, last);
+#ifdef CHECK_HEAP
+  kissat_check_heap (heap);
+#endif
+  return idx;
+}
+
+static inline void kissat_adjust_heap (kissat *solver, heap *heap,
+                                       unsigned idx) {
+  const unsigned new_vars = idx + 1;
+  const unsigned old_vars = heap->vars;
+  if (new_vars <= old_vars)
+    return;
+  const unsigned old_size = heap->size;
+  if (idx >= old_size) {
+    size_t new_size = old_size ? 2 * old_size : 1;
+    while (idx >= new_size)
+      new_size *= 2;
+    KISSAT_assert (new_size < DISCONTAIN);
+    kissat_resize_heap (solver, heap, new_size);
+  }
+  kissat_enlarge_heap (solver, heap, idx + 1);
+}
+
+static inline void kissat_update_heap (kissat *solver, heap *heap,
+                                       unsigned idx, double new_score) {
+  const double old_score = kissat_get_heap_score (heap, idx);
+  if (old_score == new_score)
+    return;
+  HEAP_IMPORT (idx);
+  LOG ("update heap %u score from %g to %g", idx, old_score, new_score);
+  heap->score[idx] = new_score;
+  if (!heap->tainted) {
+    heap->tainted = true;
+    LOG ("tainted heap");
+  }
+  if (!kissat_heap_contains (heap, idx))
+    return;
+  if (new_score > old_score)
+    kissat_bubble_up (solver, heap, idx);
+  else
+    kissat_bubble_down (solver, heap, idx);
+#ifdef CHECK_HEAP
+  kissat_check_heap (heap);
+#endif
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/inlinequeue.h b/src/sat/kissat/inlinequeue.h
new file mode 100644
index 000000000..3f83dd895
--- /dev/null
+++ b/src/sat/kissat/inlinequeue.h
@@ -0,0 +1,122 @@
+#ifndef _inlinequeue_h_INCLUDED
+#define _inlinequeue_h_INCLUDED
+
+#include "internal.h"
+#include "logging.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+static inline void kissat_update_queue (kissat *solver, const links *links,
+                                        unsigned idx) {
+  KISSAT_assert (!DISCONNECTED (idx));
+  const unsigned stamp = links[idx].stamp;
+  LOG ("queue updated to %s stamped %u", LOGVAR (idx), stamp);
+  solver->queue.search.idx = idx;
+  solver->queue.search.stamp = stamp;
+}
+
+static inline void kissat_enqueue_links (kissat *solver, unsigned i,
+                                         links *links, queue *queue) {
+  struct links *p = links + i;
+  KISSAT_assert (DISCONNECTED (p->prev));
+  KISSAT_assert (DISCONNECTED (p->next));
+  const unsigned j = p->prev = queue->last;
+  queue->last = i;
+  if (DISCONNECTED (j))
+    queue->first = i;
+  else {
+    struct links *l = links + j;
+    KISSAT_assert (DISCONNECTED (l->next));
+    l->next = i;
+  }
+  if (queue->stamp == UINT_MAX) {
+    kissat_reassign_queue_stamps (solver);
+    KISSAT_assert (p->stamp == queue->stamp);
+  } else
+    p->stamp = ++queue->stamp;
+}
+
+static inline void kissat_dequeue_links (unsigned i, links *links,
+                                         queue *queue) {
+  struct links *l = links + i;
+  const unsigned j = l->prev, k = l->next;
+  l->prev = l->next = DISCONNECT;
+  if (DISCONNECTED (j)) {
+    KISSAT_assert (queue->first == i);
+    queue->first = k;
+  } else {
+    struct links *p = links + j;
+    KISSAT_assert (p->next == i);
+    p->next = k;
+  }
+  if (DISCONNECTED (k)) {
+    KISSAT_assert (queue->last == i);
+    queue->last = j;
+  } else {
+    struct links *n = links + k;
+    KISSAT_assert (n->prev == i);
+    n->prev = j;
+  }
+}
+
+static inline void kissat_enqueue (kissat *solver, unsigned idx) {
+  KISSAT_assert (idx < solver->vars);
+  links *links = solver->links, *l = links + idx;
+  l->prev = l->next = DISCONNECT;
+  kissat_enqueue_links (solver, idx, links, &solver->queue);
+  LOG ("enqueued %s stamped %u", LOGVAR (idx), l->stamp);
+  if (!VALUE (LIT (idx)))
+    kissat_update_queue (solver, links, idx);
+  kissat_check_queue (solver);
+}
+
+static inline void kissat_dequeue (kissat *solver, unsigned idx) {
+  KISSAT_assert (idx < solver->vars);
+  LOG ("dequeued %s", LOGVAR (idx));
+  links *links = solver->links;
+  if (solver->queue.search.idx == idx) {
+    struct links *l = links + idx;
+    unsigned search = l->next;
+    if (search == DISCONNECT)
+      search = l->prev;
+    if (search == DISCONNECT) {
+      solver->queue.search.idx = DISCONNECT;
+      solver->queue.search.stamp = 0;
+    } else
+      kissat_update_queue (solver, links, search);
+  }
+  kissat_dequeue_links (idx, links, &solver->queue);
+  kissat_check_queue (solver);
+}
+
+static inline void kissat_move_to_front (kissat *solver, unsigned idx) {
+  queue *queue = &solver->queue;
+  links *links = solver->links;
+  if (idx == queue->last) {
+    KISSAT_assert (DISCONNECTED (links[idx].next));
+    return;
+  }
+  KISSAT_assert (idx < solver->vars);
+  const value tmp = VALUE (LIT (idx));
+  if (tmp && queue->search.idx == idx) {
+    unsigned prev = links[idx].prev;
+    if (!DISCONNECTED (prev))
+      kissat_update_queue (solver, links, prev);
+    else {
+      unsigned next = links[idx].next;
+      KISSAT_assert (!DISCONNECTED (next));
+      kissat_update_queue (solver, links, next);
+    }
+  }
+  kissat_dequeue_links (idx, links, queue);
+  kissat_enqueue_links (solver, idx, links, queue);
+  LOG ("moved-to-front %s stamped %u", LOGVAR (idx), LINK (idx).stamp);
+  if (!tmp)
+    kissat_update_queue (solver, links, idx);
+  kissat_check_queue (solver);
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/inlinevector.h b/src/sat/kissat/inlinevector.h
new file mode 100644
index 000000000..d7242c8eb
--- /dev/null
+++ b/src/sat/kissat/inlinevector.h
@@ -0,0 +1,198 @@
+#ifndef _inlinevector_h_INCLUDED
+#define _inlinevector_h_INCLUDED
+
+#include "internal.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+static inline unsigned *kissat_begin_vector (kissat *solver,
+                                             vector *vector) {
+#ifdef KISSAT_COMPACT
+  return BEGIN_STACK (solver->vectors.stack) + vector->offset;
+#else
+  (void) solver;
+  return vector->begin;
+#endif
+}
+
+static inline unsigned *kissat_end_vector (kissat *solver, vector *vector) {
+#ifdef KISSAT_COMPACT
+  return kissat_begin_vector (solver, vector) + vector->size;
+#else
+  (void) solver;
+  return vector->end;
+#endif
+}
+
+static inline const unsigned *
+kissat_begin_const_vector (kissat *solver, const vector *vector) {
+#ifdef KISSAT_COMPACT
+  return BEGIN_STACK (solver->vectors.stack) + vector->offset;
+#else
+  (void) solver;
+  return vector->begin;
+#endif
+}
+
+static inline const unsigned *
+kissat_end_const_vector (kissat *solver, const vector *vector) {
+#ifdef KISSAT_COMPACT
+  return kissat_begin_const_vector (solver, vector) + vector->size;
+#else
+  (void) solver;
+  return vector->end;
+#endif
+}
+
+#if defined(LOGGING) || defined(TEST_VECTOR)
+
+static inline size_t kissat_offset_vector (kissat *solver, vector *vector) {
+#ifdef KISSAT_COMPACT
+  (void) solver;
+  return vector->offset;
+#else
+  unsigned *begin_vector = vector->begin;
+  unsigned *begin_stack = BEGIN_STACK (solver->vectors.stack);
+  return begin_vector ? begin_vector - begin_stack : 0;
+#endif
+}
+
+#endif
+
+static inline size_t kissat_size_vector (const vector *vector) {
+#ifdef KISSAT_COMPACT
+  return vector->size;
+#else
+  return vector->end - vector->begin;
+#endif
+}
+
+static inline bool kissat_empty_vector (vector *vector) {
+#ifdef KISSAT_COMPACT
+  return !vector->size;
+#else
+  return vector->end == vector->begin;
+#endif
+}
+
+static inline void kissat_inc_usable (kissat *solver) {
+  KISSAT_assert (MAX_SECTOR > solver->vectors.usable);
+  solver->vectors.usable++;
+}
+
+static inline void kissat_add_usable (kissat *solver, size_t inc) {
+  KISSAT_assert (MAX_SECTOR - inc >= solver->vectors.usable);
+  solver->vectors.usable += inc;
+}
+
+static inline unsigned *kissat_last_vector_pointer (kissat *solver,
+                                                    vector *vector) {
+  KISSAT_assert (!kissat_empty_vector (vector));
+#ifdef KISSAT_COMPACT
+  KISSAT_assert (vector->size);
+  unsigned *begin = kissat_begin_vector (solver, vector);
+  return begin + vector->size - 1;
+#else
+  (void) solver;
+  return vector->end - 1;
+#endif
+}
+
+#ifdef TEST_VECTOR
+
+static inline void kissat_pop_vector (kissat *solver, vector *vector) {
+  KISSAT_assert (!kissat_empty_vector (vector));
+#ifdef KISSAT_COMPACT
+  unsigned *p = kissat_last_vector_pointer (solver, vector);
+  vector->size--;
+  *p = INVALID_VECTOR_ELEMENT;
+#else
+  *--vector->end = INVALID_VECTOR_ELEMENT;
+  (void) solver;
+#endif
+  kissat_inc_usable (solver);
+}
+
+#endif
+
+static inline void kissat_release_vector (kissat *solver, vector *vector) {
+  kissat_resize_vector (solver, vector, 0);
+}
+
+static inline void kissat_dec_usable (kissat *solver) {
+  KISSAT_assert (solver->vectors.usable > 0);
+  solver->vectors.usable--;
+}
+
+static inline void kissat_push_vectors (kissat *solver, vector *vector,
+                                        unsigned e) {
+  unsigneds *stack = &solver->vectors.stack;
+  KISSAT_assert (e != INVALID_VECTOR_ELEMENT);
+  if (
+#ifdef KISSAT_COMPACT
+      !vector->size && !vector->offset
+#else
+      !vector->begin
+#endif
+  ) {
+    if (EMPTY_STACK (*stack))
+      PUSH_STACK (*stack, 0);
+    if (FULL_STACK (*stack)) {
+      unsigned *end = kissat_enlarge_vector (solver, vector);
+      KISSAT_assert (*end == INVALID_VECTOR_ELEMENT);
+      *end = e;
+      kissat_dec_usable (solver);
+    } else {
+#ifdef KISSAT_COMPACT
+      KISSAT_assert ((uint64_t) SIZE_STACK (*stack) < MAX_VECTORS);
+      vector->offset = SIZE_STACK (*stack);
+      KISSAT_assert (vector->offset);
+      *stack->end++ = e;
+#else
+      KISSAT_assert (stack->end < stack->allocated);
+      *(vector->begin = stack->end++) = e;
+#endif
+    }
+#if !defined(KISSAT_COMPACT)
+    vector->end = vector->begin;
+#endif
+  } else {
+    unsigned *end = kissat_end_vector (solver, vector);
+    if (end == END_STACK (*stack)) {
+      if (FULL_STACK (*stack)) {
+        end = kissat_enlarge_vector (solver, vector);
+        KISSAT_assert (*end == INVALID_VECTOR_ELEMENT);
+        *end = e;
+        kissat_dec_usable (solver);
+      } else
+        *stack->end++ = e;
+    } else {
+      if (*end != INVALID_VECTOR_ELEMENT)
+        end = kissat_enlarge_vector (solver, vector);
+      KISSAT_assert (*end == INVALID_VECTOR_ELEMENT);
+      *end = e;
+      kissat_dec_usable (solver);
+    }
+  }
+#ifndef KISSAT_COMPACT
+  vector->end++;
+#else
+  vector->size++;
+#endif
+  kissat_check_vectors (solver);
+}
+
+#ifdef TEST_VECTOR
+
+#define all_vector(E, V) \
+  unsigned E, *E##_PTR = kissat_begin_vector (solver, &V), \
+              *const E##_END = kissat_end_vector (solver, &V); \
+  E##_PTR != E##_END && (E = *E##_PTR, true); \
+  E##_PTR++
+
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/internal.c b/src/sat/kissat/internal.c
new file mode 100644
index 000000000..bf7046159
--- /dev/null
+++ b/src/sat/kissat/internal.c
@@ -0,0 +1,528 @@
+#include "allocate.h"
+#include "backtrack.h"
+#include "error.h"
+#include "import.h"
+#include "inline.h"
+#include "inlineframes.h"
+#include "print.h"
+#include "propsearch.h"
+#include "require.h"
+#include "resize.h"
+#include "resources.h"
+#include "search.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_reset_last_learned (kissat *solver) {
+  for (really_all_last_learned (p))
+    *p = INVALID_REF;
+}
+
+kissat *kissat_init (void) {
+  kissat *solver = (kissat*)kissat_calloc (0, 1, sizeof *solver);
+#ifndef KISSAT_NOPTIONS
+  kissat_init_options (&solver->options);
+#else
+  kissat_init_options ();
+#endif
+#ifndef KISSAT_QUIET
+  kissat_init_profiles (&solver->profiles);
+#endif
+  START (total);
+  kissat_init_queue (solver);
+  KISSAT_assert (INTERNAL_MAX_LIT < UINT_MAX);
+  kissat_push_frame (solver, UINT_MAX);
+  solver->watching = true;
+  solver->conflict.size = 2;
+  solver->scinc = 1.0;
+  solver->first_reducible = INVALID_REF;
+  solver->last_irredundant = INVALID_REF;
+  kissat_reset_last_learned (solver);
+#ifndef KISSAT_NDEBUG
+  kissat_init_checker (solver);
+#endif
+  solver->prefix = kissat_strdup (solver, "c ");
+  return solver;
+}
+
+void kissat_set_prefix (kissat *solver, const char *prefix) {
+  kissat_freestr (solver, solver->prefix);
+  solver->prefix = kissat_strdup (solver, prefix);
+}
+
+#define DEALLOC_GENERIC(NAME, ELEMENTS_PER_BLOCK) \
+  do { \
+    const size_t block_size = ELEMENTS_PER_BLOCK * sizeof *solver->NAME; \
+    kissat_dealloc (solver, solver->NAME, solver->size, block_size); \
+    solver->NAME = 0; \
+  } while (0)
+
+#define DEALLOC_VARIABLE_INDEXED(NAME) DEALLOC_GENERIC (NAME, 1)
+
+#define DEALLOC_LITERAL_INDEXED(NAME) DEALLOC_GENERIC (NAME, 2)
+
+#define RELEASE_LITERAL_INDEXED_STACKS(NAME, ACCESS) \
+  do { \
+    for (all_stack (unsigned, IDX_RILIS, solver->active)) { \
+      const unsigned LIT_RILIS = LIT (IDX_RILIS); \
+      const unsigned NOT_LIT_RILIS = NOT (LIT_RILIS); \
+      RELEASE_STACK (ACCESS (LIT_RILIS)); \
+      RELEASE_STACK (ACCESS (NOT_LIT_RILIS)); \
+    } \
+    DEALLOC_LITERAL_INDEXED (NAME); \
+  } while (0)
+
+void kissat_release (kissat *solver) {
+  kissat_require_initialized (solver);
+  kissat_release_heap (solver, SCORES);
+  kissat_release_heap (solver, &solver->schedule);
+  kissat_release_vectors (solver);
+  kissat_release_phases (solver);
+
+  RELEASE_STACK (solver->export_);
+  RELEASE_STACK (solver->import);
+
+  DEALLOC_VARIABLE_INDEXED (assigned);
+  DEALLOC_VARIABLE_INDEXED (flags);
+  DEALLOC_VARIABLE_INDEXED (links);
+
+  DEALLOC_LITERAL_INDEXED (marks);
+  DEALLOC_LITERAL_INDEXED (values);
+  DEALLOC_LITERAL_INDEXED (watches);
+
+  RELEASE_STACK (solver->import);
+  RELEASE_STACK (solver->eliminated);
+  RELEASE_STACK (solver->extend);
+  RELEASE_STACK (solver->witness);
+  RELEASE_STACK (solver->etrail);
+
+  RELEASE_STACK (solver->delayed);
+
+  RELEASE_STACK (solver->clause);
+  RELEASE_STACK (solver->shadow);
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  RELEASE_STACK (solver->resolvent);
+#endif
+
+  RELEASE_STACK (solver->arena);
+
+  RELEASE_STACK (solver->units);
+  RELEASE_STACK (solver->frames);
+  RELEASE_STACK (solver->sorter);
+
+  RELEASE_ARRAY (solver->trail, solver->size);
+
+  RELEASE_STACK (solver->analyzed);
+  RELEASE_STACK (solver->levels);
+  RELEASE_STACK (solver->minimize);
+  RELEASE_STACK (solver->poisoned);
+  RELEASE_STACK (solver->promote);
+  RELEASE_STACK (solver->removable);
+  RELEASE_STACK (solver->shrinkable);
+  RELEASE_STACK (solver->xorted[0]);
+  RELEASE_STACK (solver->xorted[1]);
+
+  RELEASE_STACK (solver->sweep_schedule);
+
+  RELEASE_STACK (solver->ranks);
+
+  RELEASE_STACK (solver->antecedents[0]);
+  RELEASE_STACK (solver->antecedents[1]);
+  RELEASE_STACK (solver->gates[0]);
+  RELEASE_STACK (solver->gates[1]);
+  RELEASE_STACK (solver->resolvents);
+
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS)
+  RELEASE_STACK (solver->added);
+  RELEASE_STACK (solver->removed);
+#endif
+
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS) || defined(LOGGING)
+  RELEASE_STACK (solver->original);
+#endif
+
+#ifndef KISSAT_QUIET
+  RELEASE_STACK (solver->profiles.stack);
+#endif
+
+  kissat_freestr (solver, solver->prefix);
+
+#ifndef KISSAT_NDEBUG
+  kissat_release_checker (solver);
+#endif
+#if !defined(KISSAT_NDEBUG) && defined(METRICS)
+  uint64_t leaked = solver->statistics_.allocated_current;
+  if (leaked)
+    if (!getenv ("LEAK"))
+      kissat_fatal ("internally leaking %" PRIu64 " bytes", leaked);
+#endif
+
+  kissat_free (0, solver, sizeof *solver);
+}
+
+void kissat_reserve (kissat *solver, int max_var) {
+  kissat_require_initialized (solver);
+  kissat_require (0 <= max_var, "negative maximum variable argument '%d'",
+                  max_var);
+  kissat_require (max_var <= EXTERNAL_MAX_VAR,
+                  "invalid maximum variable argument '%d'", max_var);
+  kissat_increase_size (solver, (unsigned) max_var);
+  if (!GET_OPTION (tumble)) {
+    for (int idx = 1; idx <= max_var; idx++)
+      (void) kissat_import_literal (solver, idx);
+    for (unsigned idx = 0; idx != (unsigned) max_var; idx++)
+      kissat_activate_literal (solver, LIT (idx));
+  }
+}
+
+int kissat_get_option (kissat *solver, const char *name) {
+  kissat_require_initialized (solver);
+  kissat_require (name, "name zero pointer");
+#ifndef KISSAT_NOPTIONS
+  return kissat_options_get (&solver->options, name);
+#else
+  (void) solver;
+  return kissat_options_get (name);
+#endif
+}
+
+int kissat_set_option (kissat *solver, const char *name, int new_value) {
+#ifndef KISSAT_NOPTIONS
+  kissat_require_initialized (solver);
+  kissat_require (name, "name zero pointer");
+#ifndef KISSAT_NOPTIONS
+  return kissat_options_set (&solver->options, name, new_value);
+#else
+  return kissat_options_set (name, new_value);
+#endif
+#else
+  (void) solver, (void) new_value;
+  return kissat_options_get (name);
+#endif
+}
+
+void kissat_set_decision_limit (kissat *solver, unsigned limit) {
+  kissat_require_initialized (solver);
+  limits *limits = &solver->limits;
+  limited *limited = &solver->limited;
+  statistics *statistics = &solver->statistics_;
+  limited->decisions = true;
+  KISSAT_assert (UINT64_MAX - limit >= statistics->decisions);
+  limits->decisions = statistics->decisions + limit;
+  LOG ("set decision limit to %" PRIu64 " after %u decisions",
+       limits->decisions, limit);
+}
+
+void kissat_set_conflict_limit (kissat *solver, unsigned limit) {
+  kissat_require_initialized (solver);
+  limits *limits = &solver->limits;
+  limited *limited = &solver->limited;
+  statistics *statistics = &solver->statistics_;
+  limited->conflicts = true;
+  KISSAT_assert (UINT64_MAX - limit >= statistics->conflicts);
+  limits->conflicts = statistics->conflicts + limit;
+  LOG ("set conflict limit to %" PRIu64 " after %u conflicts",
+       limits->conflicts, limit);
+}
+
+void kissat_print_statistics (kissat *solver) {
+#ifndef KISSAT_QUIET
+  kissat_require_initialized (solver);
+  const int verbosity = kissat_verbosity (solver);
+  if (verbosity < 0)
+    return;
+  if (GET_OPTION (profile)) {
+    kissat_section (solver, "profiling");
+    kissat_profiles_print (solver);
+  }
+  const bool complete = GET_OPTION (statistics);
+  kissat_section (solver, "statistics");
+  const bool verbose = (complete || verbosity > 0);
+  kissat_statistics_print (solver, verbose);
+#ifndef KISSAT_NPROOFS
+  if (solver->proof) {
+    kissat_section (solver, "proof");
+    kissat_print_proof_statistics (solver, verbose);
+  }
+#endif
+#ifndef KISSAT_NDEBUG
+  if (GET_OPTION (check) > 1) {
+    kissat_section (solver, "checker");
+    kissat_print_checker_statistics (solver, verbose);
+  }
+#endif
+  kissat_section (solver, "glue usage");
+  kissat_print_glue_usage (solver);
+  kissat_section (solver, "resources");
+  kissat_print_resources (solver);
+#endif
+  (void) solver;
+}
+
+void kissat_add (kissat *solver, int elit) {
+  kissat_require_initialized (solver);
+  kissat_require (!GET (searches), "incremental solving not supported");
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS) || defined(LOGGING)
+  const int checking = kissat_checking (solver);
+  const bool logging = kissat_logging (solver);
+  const bool proving = kissat_proving (solver);
+#endif
+  if (elit) {
+    kissat_require_valid_external_internal (elit);
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS) || defined(LOGGING)
+    if (checking || logging || proving)
+      PUSH_STACK (solver->original, elit);
+#endif
+    unsigned ilit = kissat_import_literal (solver, elit);
+
+    const mark mark = MARK (ilit);
+    if (!mark) {
+      const value value = kissat_fixed (solver, ilit);
+      if (value > 0) {
+        if (!solver->clause_satisfied) {
+          LOG ("adding root level satisfied literal %u(%d)@0=1", ilit,
+               elit);
+          solver->clause_satisfied = true;
+        }
+      } else if (value < 0) {
+        LOG ("adding root level falsified literal %u(%d)@0=-1", ilit, elit);
+        if (!solver->clause_shrink) {
+          solver->clause_shrink = true;
+          LOG ("thus original clause needs shrinking");
+        }
+      } else {
+        MARK (ilit) = 1;
+        MARK (NOT (ilit)) = -1;
+        KISSAT_assert (SIZE_STACK (solver->clause) < UINT_MAX);
+        PUSH_STACK (solver->clause, ilit);
+      }
+    } else if (mark < 0) {
+      KISSAT_assert (mark < 0);
+      if (!solver->clause_trivial) {
+        LOG ("adding dual literal %u(%d) and %u(%d)", NOT (ilit), -elit,
+             ilit, elit);
+        solver->clause_trivial = true;
+      }
+    } else {
+      KISSAT_assert (mark > 0);
+      LOG ("adding duplicated literal %u(%d)", ilit, elit);
+      if (!solver->clause_shrink) {
+        solver->clause_shrink = true;
+        LOG ("thus original clause needs shrinking");
+      }
+    }
+  } else {
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS) || defined(LOGGING)
+    const size_t offset = solver->offset_of_last_original_clause;
+    size_t esize = SIZE_STACK (solver->original) - offset;
+    int *elits = BEGIN_STACK (solver->original) + offset;
+    KISSAT_assert (esize <= UINT_MAX);
+#endif
+    ADD_UNCHECKED_EXTERNAL (esize, elits);
+    const size_t isize = SIZE_STACK (solver->clause);
+    unsigned *ilits = BEGIN_STACK (solver->clause);
+    KISSAT_assert (isize < (unsigned) INT_MAX);
+
+    if (solver->inconsistent)
+      LOG ("inconsistent thus skipping original clause");
+    else if (solver->clause_satisfied)
+      LOG ("skipping satisfied original clause");
+    else if (solver->clause_trivial)
+      LOG ("skipping trivial original clause");
+    else {
+      kissat_activate_literals (solver, isize, ilits);
+
+      if (!isize) {
+        if (solver->clause_shrink)
+          LOG ("all original clause literals root level falsified");
+        else
+          LOG ("found empty original clause");
+
+        if (!solver->inconsistent) {
+          LOG ("thus solver becomes inconsistent");
+          solver->inconsistent = true;
+          CHECK_AND_ADD_EMPTY ();
+          ADD_EMPTY_TO_PROOF ();
+        }
+      } else if (isize == 1) {
+        unsigned unit = TOP_STACK (solver->clause);
+
+        if (solver->clause_shrink)
+          LOGUNARY (unit, "original clause shrinks to");
+        else
+          LOGUNARY (unit, "found original");
+
+        kissat_original_unit (solver, unit);
+
+        COVER (solver->level);
+        if (!solver->level)
+          (void) kissat_search_propagate (solver);
+      } else {
+        reference res = kissat_new_original_clause (solver);
+
+        const unsigned a = ilits[0];
+        const unsigned b = ilits[1];
+
+        const value u = VALUE (a);
+        const value v = VALUE (b);
+
+        const unsigned k = u ? LEVEL (a) : UINT_MAX;
+        const unsigned l = v ? LEVEL (b) : UINT_MAX;
+
+        bool assign = false;
+
+        if (!u && v < 0) {
+          LOG ("original clause immediately forcing");
+          assign = true;
+        } else if (u < 0 && k == l) {
+          LOG ("both watches falsified at level @%u", k);
+          KISSAT_assert (v < 0);
+          KISSAT_assert (k > 0);
+          kissat_backtrack_without_updating_phases (solver, k - 1);
+        } else if (u < 0) {
+          LOG ("watches falsified at levels @%u and @%u", k, l);
+          KISSAT_assert (v < 0);
+          KISSAT_assert (k > l);
+          KISSAT_assert (l > 0);
+          assign = true;
+        } else if (u > 0 && v < 0) {
+          LOG ("first watch satisfied at level @%u "
+               "second falsified at level @%u",
+               k, l);
+          KISSAT_assert (k <= l);
+        } else if (!u && v > 0) {
+          LOG ("first watch unassigned "
+               "second falsified at level @%u",
+               l);
+          assign = true;
+        } else {
+          KISSAT_assert (!u);
+          KISSAT_assert (!v);
+        }
+
+        if (assign) {
+          KISSAT_assert (solver->level > 0);
+
+          if (isize == 2) {
+            KISSAT_assert (res == INVALID_REF);
+            kissat_assign_binary (solver, a, b);
+          } else {
+            KISSAT_assert (res != INVALID_REF);
+            clause *c = kissat_dereference_clause (solver, res);
+            kissat_assign_reference (solver, a, res, c);
+          }
+        }
+      }
+    }
+
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS)
+    if (solver->clause_satisfied || solver->clause_trivial) {
+#ifndef KISSAT_NDEBUG
+      if (checking > 1)
+        kissat_remove_checker_external (solver, esize, elits);
+#endif
+#ifndef KISSAT_NPROOFS
+      if (proving) {
+        if (esize == 1)
+          LOG ("skipping deleting unit from proof");
+        else
+          kissat_delete_external_from_proof (solver, esize, elits);
+      }
+#endif
+    } else if (!solver->inconsistent && solver->clause_shrink) {
+#ifndef KISSAT_NDEBUG
+      if (checking > 1) {
+        kissat_check_and_add_internal (solver, isize, ilits);
+        kissat_remove_checker_external (solver, esize, elits);
+      }
+#endif
+#ifndef KISSAT_NPROOFS
+      if (proving) {
+        kissat_add_lits_to_proof (solver, isize, ilits);
+        kissat_delete_external_from_proof (solver, esize, elits);
+      }
+#endif
+    }
+#endif
+
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS) || defined(LOGGING)
+    if (checking) {
+      LOGINTS (esize, elits, "saved original");
+      PUSH_STACK (solver->original, 0);
+      solver->offset_of_last_original_clause =
+          SIZE_STACK (solver->original);
+    } else if (logging || proving) {
+      LOGINTS (esize, elits, "reset original");
+      CLEAR_STACK (solver->original);
+      solver->offset_of_last_original_clause = 0;
+    }
+#endif
+    for (all_stack (unsigned, lit, solver->clause))
+      MARK (lit) = MARK (NOT (lit)) = 0;
+
+    CLEAR_STACK (solver->clause);
+
+    solver->clause_satisfied = false;
+    solver->clause_trivial = false;
+    solver->clause_shrink = false;
+  }
+}
+
+int kissat_solve (kissat *solver) {
+  kissat_require_initialized (solver);
+  kissat_require (EMPTY_STACK (solver->clause),
+                  "incomplete clause (terminating zero not added)");
+  kissat_require (!GET (searches), "incremental solving not supported");
+  return kissat_search (solver);
+}
+
+void kissat_terminate (kissat *solver) {
+  kissat_require_initialized (solver);
+  solver->termination.flagged = ~(unsigned) 0;
+  KISSAT_assert (solver->termination.flagged);
+}
+
+void kissat_set_terminate (kissat *solver, void *state,
+                           int (*terminate) (void *)) {
+  solver->termination.terminate = 0;
+  solver->termination.state = state;
+  solver->termination.terminate = terminate;
+}
+
+int kissat_value (kissat *solver, int elit) {
+  kissat_require_initialized (solver);
+  kissat_require_valid_external_internal (elit);
+  const unsigned eidx = ABS (elit);
+  if (eidx >= SIZE_STACK (solver->import))
+    return 0;
+  const import *const import = &PEEK_STACK (solver->import, eidx);
+  if (!import->imported)
+    return 0;
+  value tmp;
+  if (import->eliminated) {
+    if (!solver->extended && !EMPTY_STACK (solver->extend))
+      kissat_extend (solver);
+    const unsigned eliminated = import->lit;
+    tmp = PEEK_STACK (solver->eliminated, eliminated);
+  } else {
+    const unsigned ilit = import->lit;
+    tmp = VALUE (ilit);
+  }
+  if (!tmp)
+    return 0;
+  if (elit < 0)
+    tmp = -tmp;
+  return tmp < 0 ? -elit : elit;
+}
+
+int kissat_is_inconsistent(kissat *solver) {
+  return solver->inconsistent;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/internal.h b/src/sat/kissat/internal.h
new file mode 100644
index 000000000..a3777a961
--- /dev/null
+++ b/src/sat/kissat/internal.h
@@ -0,0 +1,300 @@
+#ifndef _internal_h_INCLUDED
+#define _internal_h_INCLUDED
+
+#include "arena.h"
+#include "array.h"
+#include "assign.h"
+#include "averages.h"
+#include "check.h"
+#include "classify.h"
+#include "clause.h"
+#include "cover.h"
+#include "extend.h"
+#include "flags.h"
+#include "format.h"
+#include "frames.h"
+#include "heap.h"
+#include "kimits.h"
+#include "kissat.h"
+#include "literal.h"
+#include "mode.h"
+#include "options.h"
+#include "phases.h"
+#include "profile.h"
+#include "proof.h"
+#include "queue.h"
+#include "random.h"
+#include "reluctant.h"
+#include "rephase.h"
+#include "smooth.h"
+#include "stack.h"
+#include "statistics.h"
+#include "value.h"
+#include "vector.h"
+#include "watch.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct datarank datarank;
+
+struct datarank {
+  unsigned data;
+  unsigned rank;
+};
+
+typedef struct import import;
+
+struct import {
+  unsigned lit;
+  bool extension;
+  bool imported;
+  bool eliminated;
+};
+
+typedef struct termination termination;
+
+struct termination {
+#ifdef COVERAGE
+  volatile uint64_t flagged;
+#else
+  volatile bool flagged;
+#endif
+  volatile void *state;
+  int (*volatile terminate) (void *);
+};
+
+// clang-format off
+
+typedef STACK (value) eliminated;
+typedef STACK (import) imports;
+typedef STACK (datarank) dataranks;
+typedef STACK (watch) statches;
+typedef STACK (watch *) patches;
+
+// clang-format on
+
+struct kitten;
+
+struct kissat {
+#if !defined(KISSAT_NDEBUG) || defined(METRICS)
+  bool backbone_computing;
+#endif
+#ifdef LOGGING
+  bool compacting;
+#endif
+  bool extended;
+  bool inconsistent;
+  bool iterating;
+  bool preprocessing;
+  bool probing;
+#ifndef KISSAT_QUIET
+  bool sectioned;
+#endif
+  bool stable;
+#if !defined(KISSAT_NDEBUG) || defined(METRICS)
+  bool transitive_reducing;
+  bool vivifying;
+#endif
+  bool warming;
+  bool watching;
+
+  bool large_clauses_watched_after_binary_clauses;
+
+  termination termination;
+
+  unsigned vars;
+  unsigned size;
+  unsigned active;
+  unsigned randec;
+
+  ints export_;
+  ints units;
+  imports import;
+  extensions extend;
+  unsigneds witness;
+
+  assigned *assigned;
+  flags *flags;
+
+  mark *marks;
+
+  value *values;
+  phases phases;
+
+  eliminated eliminated;
+  unsigneds etrail;
+
+  links *links;
+  queue queue;
+
+  heap scores;
+  double scinc;
+
+  heap schedule;
+  double scoreshift;
+
+  unsigned level;
+  frames frames;
+
+  unsigned_array trail;
+  unsigned *propagate;
+
+  unsigned best_assigned;
+  unsigned target_assigned;
+  unsigned unflushed;
+  unsigned unassigned;
+
+  unsigneds delayed;
+
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  unsigneds resolvent;
+#endif
+  unsigned resolvent_size;
+  unsigned antecedent_size;
+
+  dataranks ranks;
+
+  unsigneds analyzed;
+  unsigneds levels;
+  unsigneds minimize;
+  unsigneds poisoned;
+  unsigneds promote;
+  unsigneds removable;
+  unsigneds shrinkable;
+
+  clause conflict;
+
+  bool clause_satisfied;
+  bool clause_shrink;
+  bool clause_trivial;
+
+  unsigneds clause;
+  unsigneds shadow;
+
+  arena arena;
+  vectors vectors;
+  reference first_reducible;
+  reference last_irredundant;
+  watches *watches;
+
+  reference last_learned[4];
+
+  sizes sorter;
+
+  generator random;
+  averages averages[2];
+  unsigned tier1[2], tier2[2];
+  reluctant reluctant;
+
+  bounds bounds;
+  classification classification;
+  delays delays;
+  enabled enabled;
+  limited limited;
+  limits limits;
+  remember last;
+  unsigned walked;
+
+  mode mode;
+
+  uint64_t ticks;
+
+  kormat format;
+  char *prefix;
+
+  statches antecedents[2];
+  statches gates[2];
+  patches xorted[2];
+  unsigneds resolvents;
+  bool resolve_gate;
+
+  struct kitten *kitten;
+#ifdef METRICS
+  uint64_t *gate_eliminated;
+#else
+  bool gate_eliminated;
+#endif
+  bool sweep_incomplete;
+  unsigneds sweep_schedule;
+
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS)
+  unsigneds added;
+  unsigneds removed;
+#endif
+
+#if !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS) || defined(LOGGING)
+  ints original;
+  size_t offset_of_last_original_clause;
+#endif
+
+#ifndef KISSAT_QUIET
+  profiles profiles;
+#endif
+
+#ifndef KISSAT_NOPTIONS
+  options options;
+#endif
+
+#ifndef KISSAT_NDEBUG
+  checker *checker;
+#endif
+
+#ifndef KISSAT_NPROOFS
+  proof *proof;
+#endif
+
+  statistics statistics_;
+};
+
+#define VARS (solver->vars)
+#define LITS (2 * solver->vars)
+
+#if 0
+#define TIEDX (GET_OPTION (focusedtiers) ? 0 : solver->stable)
+#define TIER1 (solver->tier1[TIEDX])
+#define TIER2 (solver->tier2[TIEDX])
+#else
+#define TIER1 (solver->tier1[0])
+#define TIER2 (solver->tier2[1])
+#endif
+
+#define SCORES (&solver->scores)
+
+static inline unsigned kissat_assigned (kissat *solver) {
+  KISSAT_assert (VARS >= solver->unassigned);
+  return VARS - solver->unassigned;
+}
+
+#define all_variables(IDX) \
+  unsigned IDX = 0, IDX##_END = solver->vars; \
+  IDX != IDX##_END; \
+  ++IDX
+
+#define all_literals(LIT) \
+  unsigned LIT = 0, LIT##_END = LITS; \
+  LIT != LIT##_END; \
+  ++LIT
+
+#define all_clauses(C) \
+  clause *C = (clause *) BEGIN_STACK (solver->arena), \
+         *const C##_END = (clause *) END_STACK (solver->arena), *C##_NEXT; \
+  C != C##_END && (C##_NEXT = kissat_next_clause (C), true); \
+  C = C##_NEXT
+
+#define capacity_last_learned \
+  (sizeof solver->last_learned / sizeof *solver->last_learned)
+
+#define real_end_last_learned (solver->last_learned + capacity_last_learned)
+
+#define really_all_last_learned(REF_PTR) \
+  reference *REF_PTR = solver->last_learned, \
+            *REF_PTR##_END = real_end_last_learned; \
+  REF_PTR != REF_PTR##_END; \
+  REF_PTR++
+
+void kissat_reset_last_learned (kissat *solver);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/keatures.h b/src/sat/kissat/keatures.h
new file mode 100644
index 000000000..e3d4cb912
--- /dev/null
+++ b/src/sat/kissat/keatures.h
@@ -0,0 +1,23 @@
+#ifndef _keatures_h_INCLUDED
+#define _keatures_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define KISSAT_IS_BIG_ENDIAN
+#endif
+
+#if defined(_POSIX_C_SOURCE) || defined(__APPLE__)
+#define KISSAT_HAS_COMPRESSION
+#define KISSAT_HAS_COLORS
+#define KISSAT_HAS_FILENO
+#endif
+
+#if defined(_POSIX_C_SOURCE)
+#define KISSAT_HAS_UNLOCKEDIO
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/kimits.c b/src/sat/kissat/kimits.c
new file mode 100644
index 000000000..f83a4865a
--- /dev/null
+++ b/src/sat/kissat/kimits.c
@@ -0,0 +1,198 @@
+#include "internal.h"
+#include "logging.h"
+#include "mode.h"
+#include "print.h"
+#include "reduce.h"
+#include "rephase.h"
+#include "resources.h"
+#include "restart.h"
+
+#include <inttypes.h>
+#include <math.h>
+
+ABC_NAMESPACE_IMPL_START
+
+double kissat_logn (uint64_t count) {
+  KISSAT_assert (count > 0);
+  const double res = log10 (count + 9);
+  KISSAT_assert (res >= 1);
+  return res;
+}
+
+double kissat_sqrt (uint64_t count) {
+  KISSAT_assert (count > 0);
+  const double res = sqrt (count);
+  KISSAT_assert (res >= 1);
+  return res;
+}
+
+double kissat_nlogpown (uint64_t count, unsigned exponent) {
+  KISSAT_assert (count > 0);
+  const double tmp = log10 (count + 9);
+  double factor = 1;
+  while (exponent--)
+    factor *= tmp;
+  KISSAT_assert (factor >= 1);
+  const double res = count * factor;
+  KISSAT_assert (res >= 1);
+  return res;
+}
+
+uint64_t kissat_scale_delta (kissat *solver, const char *pretty,
+                             uint64_t delta) {
+  const uint64_t C = BINIRR_CLAUSES;
+  double f = kissat_logn (C + 1) - 5;
+  const double ff = f * f;
+  KISSAT_assert (ff >= 0);
+  const double fff = 4.5 * ff + 25;
+  uint64_t scaled = fff * delta;
+  KISSAT_assert (delta <= scaled);
+  // clang-format off
+  kissat_very_verbose (solver,
+    "scaled %s delta %" PRIu64
+    " = %g * %" PRIu64
+    " = (4.5 (log10(%" PRIu64 ") - 5)^2 + 25) * %" PRIu64,
+    pretty, scaled, fff, delta, C, delta);
+  // clang-format on
+  (void) pretty;
+  return scaled;
+}
+
+static void init_enabled (kissat *solver) {
+  bool probe;
+  if (!GET_OPTION (simplify))
+    probe = false;
+  else if (!GET_OPTION (probe))
+    probe = false;
+  else if (GET_OPTION (substitute))
+    probe = true;
+  else if (GET_OPTION (sweep))
+    probe = true;
+  else if (GET_OPTION (vivify))
+    probe = true;
+  else
+    probe = false;
+  kissat_very_verbose (solver, "probing %sabled", probe ? "en" : "dis");
+  solver->enabled.probe = probe;
+
+  bool eliminate;
+  if (!GET_OPTION (simplify))
+    eliminate = false;
+  else if (!GET_OPTION (eliminate))
+    eliminate = false;
+  else
+    eliminate = true;
+  kissat_very_verbose (solver, "eliminate %sabled",
+                       eliminate ? "en" : "dis");
+  solver->enabled.eliminate = eliminate;
+}
+
+#define INIT_CONFLICT_LIMIT(NAME, SCALE) \
+  do { \
+    const uint64_t DELTA = GET_OPTION (NAME##init); \
+    const uint64_t SCALED = \
+        !(SCALE) ? DELTA : kissat_scale_delta (solver, #NAME, DELTA); \
+    limits->NAME.conflicts = CONFLICTS + SCALED; \
+    kissat_very_verbose (solver, \
+                         "initial " #NAME " limit of %s conflicts", \
+                         FORMAT_COUNT (limits->NAME.conflicts)); \
+  } while (0)
+
+void kissat_init_limits (kissat *solver) {
+  KISSAT_assert (solver->statistics_.searches == 1);
+
+  init_enabled (solver);
+
+  limits *limits = &solver->limits;
+
+  if (GET_OPTION (randec))
+    INIT_CONFLICT_LIMIT (randec, false);
+
+  if (GET_OPTION (reduce))
+    INIT_CONFLICT_LIMIT (reduce, false);
+
+  if (GET_OPTION (reorder))
+    INIT_CONFLICT_LIMIT (reorder, false);
+
+  if (GET_OPTION (rephase))
+    INIT_CONFLICT_LIMIT (rephase, false);
+
+  if (!solver->stable)
+    kissat_update_focused_restart_limit (solver);
+
+  kissat_init_mode_limit (solver);
+
+  if (solver->enabled.eliminate) {
+    INIT_CONFLICT_LIMIT (eliminate, true);
+    solver->bounds.eliminate.max_bound_completed = 0;
+    solver->bounds.eliminate.additional_clauses = 0;
+    kissat_very_verbose (solver, "reset elimination bound to zero");
+  }
+
+  if (solver->enabled.probe)
+    INIT_CONFLICT_LIMIT (probe, true);
+}
+
+#ifndef KISSAT_QUIET
+
+static const char *delay_description (kissat *solver, delay *delay) {
+  delays *delays = &solver->delays;
+  if (delay == &delays->bumpreasons)
+    return "bumping reason side literals";
+  else if (delay == &delays->congruence)
+    return "congruence closure";
+  else if (delay == &delays->sweep)
+    return "sweeping";
+  else {
+    KISSAT_assert (delay == &delays->vivifyirr);
+    return "vivifying irredundant clauses";
+  }
+}
+
+#endif
+
+#define VERY_VERBOSE_IF_NOT_BUMPREASONS(...) \
+  VERY_VERBOSE_OR_LOG (delay == &solver->delays.bumpreasons, __VA_ARGS__)
+
+void kissat_reduce_delay (kissat *solver, delay *delay) {
+  if (!delay->current)
+    return;
+  delay->current /= 2;
+  VERY_VERBOSE_IF_NOT_BUMPREASONS (
+      solver, "%s delay interval decreased to %u",
+      delay_description (solver, delay), delay->current);
+  delay->count = delay->current;
+#ifdef KISSAT_QUIET
+  (void) solver;
+#endif
+}
+
+void kissat_bump_delay (kissat *solver, delay *delay) {
+  delay->current += delay->current < UINT_MAX;
+  VERY_VERBOSE_IF_NOT_BUMPREASONS (
+      solver, "%s delay interval increased to %u",
+      delay_description (solver, delay), delay->current);
+  delay->count = delay->current;
+#ifdef KISSAT_QUIET
+  (void) solver;
+#endif
+}
+
+bool kissat_delaying (kissat *solver, delay *delay) {
+  if (delay->count) {
+    delay->count--;
+    VERY_VERBOSE_IF_NOT_BUMPREASONS (
+        solver, "%s still delayed (%u more times)",
+        delay_description (solver, delay), delay->current);
+    return true;
+  } else {
+    VERY_VERBOSE_IF_NOT_BUMPREASONS (solver, "%s not delayed",
+                                     delay_description (solver, delay));
+    return false;
+  }
+#ifdef KISSAT_QUIET
+  (void) solver;
+#endif
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/kimits.h b/src/sat/kissat/kimits.h
new file mode 100644
index 000000000..1696f05ed
--- /dev/null
+++ b/src/sat/kissat/kimits.h
@@ -0,0 +1,190 @@
+#ifndef _limits_h_INCLUDED
+#define _limits_h_INCLUDED
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct bounds bounds;
+typedef struct changes changes;
+typedef struct delays delays;
+typedef struct delay delay;
+typedef struct remember remember;
+typedef struct enabled enabled;
+typedef struct limited limited;
+typedef struct limits limits;
+
+struct bounds {
+  struct {
+    uint64_t max_bound_completed;
+    unsigned additional_clauses;
+  } eliminate;
+};
+
+struct limits {
+  uint64_t conflicts;
+  uint64_t decisions;
+  uint64_t reports;
+
+  struct {
+    uint64_t count;
+    uint64_t ticks;
+    uint64_t conflicts;
+  } mode;
+
+  struct {
+    struct {
+      uint64_t eliminate;
+      uint64_t subsume;
+    } variables;
+    uint64_t conflicts;
+  } eliminate;
+
+  struct {
+    uint64_t marked;
+  } factor;
+
+  struct {
+    uint64_t conflicts;
+  } probe, randec, reduce, reorder, rephase, restart;
+
+  struct {
+    uint64_t conflicts;
+    uint64_t interval;
+  } glue;
+};
+
+struct limited {
+  bool conflicts;
+  bool decisions;
+};
+
+struct enabled {
+  bool eliminate;
+  bool focus;
+  bool mode;
+  bool probe;
+};
+
+struct delay {
+  unsigned count;
+  unsigned current;
+};
+
+struct delays {
+  delay bumpreasons;
+  delay congruence;
+  delay sweep;
+  delay vivifyirr;
+};
+
+struct remember {
+  struct {
+    uint64_t eliminate;
+    uint64_t probe;
+  } ticks;
+  struct {
+    uint64_t reduce;
+  } conflicts;
+};
+
+struct kissat;
+
+changes kissat_changes (struct kissat *);
+
+bool kissat_changed (changes before, changes after);
+
+void kissat_init_limits (struct kissat *);
+
+uint64_t kissat_scale_delta (struct kissat *, const char *, uint64_t);
+
+double kissat_nlogpown (uint64_t, unsigned);
+double kissat_sqrt (uint64_t);
+double kissat_logn (uint64_t);
+
+#define LOGN(COUNT) kissat_logn (COUNT)
+#define LINEAR(COUNT) (COUNT)
+#define NLOGN(COUNT) kissat_nlogpown (COUNT, 1)
+#define NLOG2N(COUNT) kissat_nlogpown (COUNT, 2)
+#define NLOG3N(COUNT) kissat_nlogpown (COUNT, 3)
+
+#define SQRT(COUNT) kissat_sqrt (COUNT)
+
+#define UPDATE_CONFLICT_LIMIT(NAME, COUNT, SCALE_COUNT_FUNCTION, \
+                              SCALE_DELTA) \
+  do { \
+    if (solver->inconsistent) \
+      break; \
+    const struct statistics *statistics = &solver->statistics_; \
+    KISSAT_assert (statistics->COUNT > 0); \
+    struct limits *limits = &solver->limits; \
+    uint64_t DELTA = GET_OPTION (NAME##int); \
+    const double SCALING = SCALE_COUNT_FUNCTION (statistics->COUNT); \
+    KISSAT_assert (SCALING >= 1); \
+    DELTA *= SCALING; \
+    const uint64_t SCALED = \
+        !(SCALE_DELTA) ? DELTA \
+                       : kissat_scale_delta (solver, #NAME, DELTA); \
+    limits->NAME.conflicts = CONFLICTS + SCALED; \
+    kissat_phase ( \
+        solver, #NAME, GET (COUNT), "new limit of %s after %s conflicts", \
+        FORMAT_COUNT (limits->NAME.conflicts), FORMAT_COUNT (SCALED)); \
+  } while (0)
+
+#include <inttypes.h>
+
+#define SET_EFFORT_LIMIT(LIMIT, NAME, START) \
+  uint64_t LIMIT; \
+  do { \
+    const uint64_t OLD_LIMIT = solver->statistics_.START; \
+    const uint64_t TICKS = solver->statistics_.search_ticks; \
+    const uint64_t LAST = solver->probing ? solver->last.ticks.probe \
+                                          : solver->last.ticks.eliminate; \
+    uint64_t REFERENCE = TICKS - LAST; \
+    const uint64_t MINEFFORT = 1e6 * GET_OPTION (mineffort); \
+    if (REFERENCE < MINEFFORT) { \
+      REFERENCE = MINEFFORT; \
+      kissat_extremely_verbose ( \
+          solver, #NAME " effort reference %s set to 'mineffort'", \
+          FORMAT_COUNT (REFERENCE)); \
+    } else { \
+      kissat_extremely_verbose ( \
+          solver, #NAME " effort reference %s = %s - %s 'search_ticks'", \
+          FORMAT_COUNT (REFERENCE), FORMAT_COUNT (TICKS), \
+          FORMAT_COUNT (LAST)); \
+    } \
+    const double EFFORT = (double) GET_OPTION (NAME##effort) * 1e-3; \
+    const uint64_t DELTA = EFFORT * REFERENCE; \
+\
+    kissat_extremely_verbose ( \
+        solver, #NAME " effort delta %s = %g * %s '" #START "'", \
+        FORMAT_COUNT (DELTA), EFFORT, FORMAT_COUNT (REFERENCE)); \
+\
+    const uint64_t NEW_LIMIT = OLD_LIMIT + DELTA; \
+    kissat_very_verbose (solver, \
+                         #NAME " effort limit %s = %s + %s '" #START "'", \
+                         FORMAT_COUNT (NEW_LIMIT), \
+                         FORMAT_COUNT (OLD_LIMIT), FORMAT_COUNT (DELTA)); \
+\
+    LIMIT = NEW_LIMIT; \
+\
+  } while (0)
+
+struct kissat;
+
+bool kissat_delaying (struct kissat *, delay *);
+void kissat_bump_delay (struct kissat *, delay *);
+void kissat_reduce_delay (struct kissat *, delay *);
+
+#define DELAYING(NAME) kissat_delaying (solver, &solver->delays.NAME)
+
+#define BUMP_DELAY(NAME) kissat_bump_delay (solver, &solver->delays.NAME)
+
+#define REDUCE_DELAY(NAME) \
+  kissat_reduce_delay (solver, &solver->delays.NAME)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/kissat.h b/src/sat/kissat/kissat.h
new file mode 100644
index 000000000..10fade7ea
--- /dev/null
+++ b/src/sat/kissat/kissat.h
@@ -0,0 +1,52 @@
+#ifndef _kissat_h_INCLUDED
+#define _kissat_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct kissat kissat;
+
+// Default (partial) IPASIR interface.
+
+const char *kissat_signature (void);
+kissat *kissat_init (void);
+void kissat_add (kissat *solver, int lit);
+int kissat_solve (kissat *solver);
+int kissat_value (kissat *solver, int lit);
+void kissat_release (kissat *solver);
+
+void kissat_set_terminate (kissat *solver, void *state,
+                           int (*terminate) (void *state));
+
+// Additional API functions.
+
+void kissat_terminate (kissat *solver);
+void kissat_reserve (kissat *solver, int max_var);
+
+const char *kissat_id (void);
+const char *kissat_version (void);
+const char *kissat_compiler (void);
+
+const char **kissat_copyright (void);
+void kissat_build (const char *line_prefix);
+void kissat_banner (const char *line_prefix, const char *name_of_app);
+
+int kissat_get_option (kissat *solver, const char *name);
+int kissat_set_option (kissat *solver, const char *name, int new_value);
+
+void kissat_set_prefix (kissat *solver, const char *prefix);
+
+int kissat_has_configuration (const char *name);
+int kissat_set_configuration (kissat *solver, const char *name);
+
+void kissat_set_conflict_limit (kissat *solver, unsigned);
+void kissat_set_decision_limit (kissat *solver, unsigned);
+
+void kissat_print_statistics (kissat *solver);
+
+// Extra API functions.
+int kissat_is_inconsistent(kissat *solver);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/kissatSolver.c b/src/sat/kissat/kissatSolver.c
new file mode 100644
index 000000000..d0a6f7da5
--- /dev/null
+++ b/src/sat/kissat/kissatSolver.c
@@ -0,0 +1,245 @@
+/**CFile****************************************************************
+
+  FileName    [kissatSolver.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver Kissat by Armin Biere, University of Freiburg]
+
+  Synopsis    [https://github.com/arminbiere/kissat]
+
+  Author      [Integrated into ABC by Yukio Miyasaka]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: kissatSolver.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "kissat.h"
+#include "kissatSolver.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [allocate solver]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+kissat_solver* kissat_solver_new(void) {
+  kissat_solver* s = (kissat_solver*)malloc(sizeof(kissat_solver));
+  s->p = (void*)kissat_init();
+  s->nVars = 0;
+  return s;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [delete solver]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void kissat_solver_delete(kissat_solver* s) {
+  kissat_release((kissat*)s->p);
+  free(s);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [add clause]
+
+  Description [kissat takes x and -x as a literal for a variable x > 0,
+               where 0 is an indicator of the end of a clause.
+               since variables start from 0 in abc, a variable v is
+               translated into v + 1 in kissat.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int kissat_solver_addclause(kissat_solver* s, int* begin, int* end) {
+  for(;begin != end; begin++) {
+    if(*begin & 1) {
+      kissat_add((kissat*)s->p, -(1 + ((*begin) >> 1)));
+    } else {
+      kissat_add((kissat*)s->p,   1 + ((*begin) >> 1) );
+    }
+  }
+  kissat_add((kissat*)s->p, 0);
+  return !kissat_is_inconsistent((kissat*)s->p);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [solve with resource limits]
+
+  Description [assumptions and inspection limits are not supported.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int kissat_solver_solve(kissat_solver* s, int* begin, int* end, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal) {
+  // assumptions are not supported
+  assert(begin == end);
+  // inspection limits are not supported
+  assert(nInsLimit == 0);
+  assert(nInsLimitGlobal == 0);
+  // set conflict limits
+  if(nConfLimit)
+    kissat_set_conflict_limit((kissat*)s->p, nConfLimit);
+  if(nConfLimitGlobal && (nConfLimit == 0 || nConfLimit > nConfLimitGlobal))
+    kissat_set_conflict_limit((kissat*)s->p, nConfLimitGlobal);
+  // solve
+  int res = kissat_solve((kissat*)s->p);
+  // translate this kissat return value into a corresponding ABC status value
+  switch(res) {
+  case  0: // UNDETERMINED
+    return 0;
+  case 10: // SATISFIABLE
+    return 1;
+  case 20: // UNSATISFIABLE
+    return -1;
+  default:
+    assert(0);
+  }
+  return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [get number of variables]
+
+  Description [emulated using "nVars".]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int kissat_solver_nvars(kissat_solver* s) {
+  return s->nVars;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [add new variable]
+
+  Description [emulated using "nVars".]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int kissat_solver_addvar(kissat_solver* s) {
+  return s->nVars++;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [set number of variables]
+
+  Description [not only emulate with "nVars" but also reserve memory.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void kissat_solver_setnvars(kissat_solver* s,int n) {
+  s->nVars = n;
+  kissat_reserve((kissat*)s->p, n);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [get value of variable]
+
+  Description [kissat returns x (true) or -x (false) for a variable x.
+               note a variable v was translated into v + 1 in kissat.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int kissat_solver_get_var_value(kissat_solver* s, int v) {
+  return kissat_value((kissat*)s->p, v + 1) > 0;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Solves the given CNF using kissat.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * kissat_solve_cnf( Cnf_Dat_t * pCnf, char * pArgs, int nConfs, int nTimeLimit, int fSat, int fUnsat, int fPrintCex, int fVerbose )
+{
+    abctime clk = Abc_Clock();
+    Vec_Int_t * vRes = NULL;
+    int i, * pBeg, * pEnd, RetValue;    
+    if ( fVerbose )
+        printf( "CNF stats: Vars = %6d. Clauses = %7d. Literals = %8d. ", pCnf->nVars, pCnf->nClauses, pCnf->nLiterals );
+    kissat_solver *pSat = kissat_solver_new();
+    kissat_solver_setnvars(pSat, pCnf->nVars);
+    assert(kissat_solver_nvars(pSat) == pCnf->nVars);
+    Cnf_CnfForClause( pCnf, pBeg, pEnd, i ) {
+        if ( !kissat_solver_addclause(pSat, pBeg, pEnd) )
+        {
+            assert( 0 ); // if it happens, can return 1 (unsatisfiable)
+            return NULL;
+        }    
+    }
+    RetValue = kissat_solver_solve(pSat, NULL, NULL, 0, 0, 0, 0);
+    if ( RetValue == 1 )
+      printf( "Result: Satisfiable.  " );
+    else if ( RetValue == -1 )
+      printf( "Result: Unsatisfiable.  " );
+    else
+      printf( "Result: Undecided.  " );
+    if ( RetValue == 1 ) {
+        vRes = Vec_IntAlloc( pCnf->nVars );
+        for ( i = 0; i < pCnf->nVars; i++ )
+          Vec_IntPush( vRes, kissat_solver_get_var_value(pSat, i) );
+    }
+    kissat_solver_delete(pSat);
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+    return vRes;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/kissatSolver.h b/src/sat/kissat/kissatSolver.h
new file mode 100644
index 000000000..63aeab0a7
--- /dev/null
+++ b/src/sat/kissat/kissatSolver.h
@@ -0,0 +1,73 @@
+/**CFile****************************************************************
+
+  FileName    [kissatSolver.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver Kissat by Armin Biere, University of Freiburg]
+
+  Synopsis    [https://github.com/arminbiere/kissat]
+
+  Author      [Integrated into ABC by Yukio Miyasaka]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: kissatSolver.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef ABC_SAT_KISSAT_SOLVER_H_
+#define ABC_SAT_KISSAT_SOLVER_H_
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "aig/gia/gia.h"
+#include "sat/cnf/cnf.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct kissat_solver_ kissat_solver;
+struct kissat_solver_
+{
+  void* p;
+  int nVars;
+};
+
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+extern kissat_solver*  kissat_solver_new(void);
+extern void            kissat_solver_delete(kissat_solver* s);
+extern int             kissat_solver_addclause(kissat_solver* s, int* begin, int* end);
+extern int             kissat_solver_solve(kissat_solver* s, int* begin, int* end, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal);
+extern int             kissat_solver_nvars(kissat_solver* s);
+extern int             kissat_solver_addvar(kissat_solver* s);
+extern void            kissat_solver_setnvars(kissat_solver* s,int n);
+extern int             kissat_solver_get_var_value(kissat_solver* s, int v);
+extern Vec_Int_t *     kissat_solve_cnf( Cnf_Dat_t * pCnf, char * pArgs, int nConfs, int nTimeLimit, int fSat, int fUnsat, int fPrintCex, int fVerbose );
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
diff --git a/src/sat/kissat/kissatTest.c b/src/sat/kissat/kissatTest.c
new file mode 100644
index 000000000..879db8799
--- /dev/null
+++ b/src/sat/kissat/kissatTest.c
@@ -0,0 +1,133 @@
+/**CFile****************************************************************
+
+  FileName    [kissatTest.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName []
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: kissatTest.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "kissatSolver.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+void kissat_solver_test() {
+  int RetValue;
+  int Lits[3];
+  // test 1
+  {
+    kissat_solver *pSat = kissat_solver_new();
+    int a = kissat_solver_addvar(pSat);
+    int b = kissat_solver_addvar(pSat);
+    int c = kissat_solver_addvar(pSat);
+    assert(kissat_solver_nvars(pSat) == 3);
+    Lits[0] = Abc_Var2Lit(a, 0);
+    Lits[1] = Abc_Var2Lit(b, 0);
+    Lits[2] = Abc_Var2Lit(c, 0);
+    printf("adding (a, b, c)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 3);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(a, 0);
+    Lits[1] = Abc_Var2Lit(b, 1);
+    printf("adding (a, !b)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 2);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(a, 1);
+    printf("adding (!a)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 1);
+    assert(RetValue);
+    RetValue = kissat_solver_solve(pSat, NULL, NULL, 0, 0, 0, 0);
+    printf("solved: %d\n", RetValue);
+    assert(RetValue == 1);
+    int a_val = kissat_solver_get_var_value(pSat, a);
+    int b_val = kissat_solver_get_var_value(pSat, b);
+    int c_val = kissat_solver_get_var_value(pSat, c);
+    printf("a = %d, b = %d, c = %d\n", a_val, b_val, c_val);
+    assert(a_val == 0);
+    assert(b_val == 0);
+    assert(c_val == 1);
+    kissat_solver_delete(pSat);
+    printf("test 1 passed\n");
+  }
+  // test 2
+  {
+    kissat_solver *pSat = kissat_solver_new();
+    kissat_solver_setnvars(pSat, 2);
+    assert(kissat_solver_nvars(pSat) == 2);
+    Lits[0] = Abc_Var2Lit(0, 0);
+    Lits[1] = Abc_Var2Lit(1, 0);
+    printf("adding (x0, x1)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 2);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 0);
+    Lits[1] = Abc_Var2Lit(1, 1);
+    printf("adding (x0, !x1)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 2);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 1);
+    Lits[1] = Abc_Var2Lit(1, 1);
+    printf("adding (!x0, !x1)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 2);
+    assert(RetValue);
+    RetValue = kissat_solver_solve(pSat, NULL, NULL, 0, 0, 0, 0);
+    printf("solved: %d\n", RetValue);
+    assert(RetValue == 1);
+    printf("x0 = %d, x1 = %d\n", kissat_solver_get_var_value(pSat, 0), kissat_solver_get_var_value(pSat, 1));
+    assert(kissat_solver_get_var_value(pSat, 0) == 1);
+    assert(kissat_solver_get_var_value(pSat, 1) == 0);
+    kissat_solver_delete(pSat);
+    printf("test 2 passed\n");
+  }
+  // test 3
+  {
+    kissat_solver *pSat = kissat_solver_new();
+    kissat_solver_setnvars(pSat, 3);
+    assert(kissat_solver_nvars(pSat) == 3);
+    Lits[0] = Abc_Var2Lit(0, 1);
+    Lits[1] = Abc_Var2Lit(1, 0);
+    Lits[2] = Abc_Var2Lit(2, 1);
+    printf("adding (!x0, x1, !x2)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 3);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(0, 0);
+    printf("adding (x0)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 1);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(1, 1);
+    printf("adding (!x1)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 1);
+    assert(RetValue);
+    Lits[0] = Abc_Var2Lit(2, 0);
+    printf("adding (x2)\n");
+    RetValue = kissat_solver_addclause(pSat, Lits, Lits + 1);
+    RetValue = kissat_solver_solve(pSat, NULL, NULL, 0, 0, 0, 0);
+    printf("solved: %d\n", RetValue);
+    assert(RetValue == -1);
+    kissat_solver_delete(pSat);
+    printf("test 3 passed\n");
+  }
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/kitten.c b/src/sat/kissat/kitten.c
new file mode 100644
index 000000000..ea2e7f360
--- /dev/null
+++ b/src/sat/kissat/kitten.c
@@ -0,0 +1,2814 @@
+#include "kitten.h"
+#include "random.h"
+#include "stack.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*------------------------------------------------------------------------*/
+#ifdef STAND_ALONE_KITTEN
+/*------------------------------------------------------------------------*/
+
+#include <unistd.h>
+
+// clang-format off
+
+static const char * usage =
+"usage: kitten [-h]"
+#ifdef LOGGING
+" [-l]"
+#endif
+" [-n] [-O[<n>]] [-p] [ <dimacs> [ <output> ] ]\n"
+"\n"
+"where\n"
+"\n"
+#ifdef LOGGING
+"  -l            enable low-level logging\n"
+#endif
+"  -n            do not print witness\n"
+"  -O[<effort>]  core shrinking effort\n"
+"  -p            produce DRAT proof\n"
+"  -a <lit>      assume a literal\n"
+"  -t <sec>      set time limit\n"
+"\n"
+"and\n"
+"\n"
+"  <dimacs>      input in DIMACS format (default '<stdin>')\n"
+"  <output>      DRAT proof or clausal core file\n"
+;
+
+// clang-format on
+
+// Replacement for 'kissat' allocators in the stand alone variant.
+
+typedef signed char value;
+
+static void die (const char *fmt, ...) {
+  fputs ("kitten: error: ", stderr);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  exit (1);
+}
+
+static inline void *kitten_calloc (size_t n, size_t size) {
+  void *res = calloc (n, size);
+  if (n && size && !res)
+    die ("out of memory allocating '%zu * %zu' bytes", n, size);
+  return res;
+}
+
+#define CALLOC(T, P, N)                          \
+  do { \
+    (P) = (T*) kitten_calloc (N, sizeof *(P));    \
+  } while (0)
+#define DEALLOC(P, N) free (P)
+
+#undef ENLARGE_STACK
+
+#define ENLARGE_STACK(S) \
+  do { \
+    KISSAT_assert (FULL_STACK (S)); \
+    const size_t SIZE = SIZE_STACK (S); \
+    const size_t OLD_CAPACITY = CAPACITY_STACK (S); \
+    const size_t NEW_CAPACITY = OLD_CAPACITY ? 2 * OLD_CAPACITY : 1; \
+    const size_t BYTES = NEW_CAPACITY * sizeof *(S).begin; \
+    (S).begin = realloc ((S).begin, BYTES); \
+    if (!(S).begin) \
+      die ("out of memory reallocating '%zu' bytes", BYTES); \
+    (S).allocated = (S).begin + NEW_CAPACITY; \
+    (S).end = (S).begin + SIZE; \
+  } while (0)
+
+// Beside allocators above also use stand alone statistics counters.
+
+#define INC(NAME) \
+  do { \
+    statistics *statistics = &kitten->statistics; \
+    KISSAT_assert (statistics->NAME < UINT64_MAX); \
+    statistics->NAME++; \
+  } while (0)
+
+#define ADD(NAME, DELTA) \
+  do { \
+    statistics *statistics = &kitten->statistics; \
+    KISSAT_assert (statistics->NAME <= UINT64_MAX - (DELTA)); \
+    statistics->NAME += (DELTA); \
+  } while (0)
+
+#define KITTEN_TICKS (kitten->statistics.kitten_ticks)
+
+/*------------------------------------------------------------------------*/
+#else // '#ifdef STAND_ALONE_KITTEN'
+/*------------------------------------------------------------------------*/
+
+#include "allocate.h"  // Use 'kissat' allocator if embedded.
+#include "error.h"     // Use 'kissat_fatal' if embedded.
+#include "internal.h"  // Also use 'kissat' statistics if embedded.
+#include "terminate.h" // For macros defining termination macro.
+
+#define KITTEN_TICKS (solver->statistics_.kitten_ticks)
+
+/*------------------------------------------------------------------------*/
+#endif // STAND_ALONE_KITTEN
+/*------------------------------------------------------------------------*/
+
+ABC_NAMESPACE_IMPL_START
+
+#define INVALID UINT_MAX
+#define MAX_VARS ((1u << 31) - 1)
+
+#define CORE_FLAG (1u)
+#define LEARNED_FLAG (2u)
+
+// clang-format off
+
+typedef struct kar kar;
+typedef struct kink kink;
+typedef struct klause klause;
+typedef struct katch katch;
+typedef STACK (unsigned) klauses;
+typedef STACK (katch) katches;
+
+// clang-format on
+
+struct kar {
+  unsigned level;
+  unsigned reason;
+};
+
+struct kink {
+  unsigned next;
+  unsigned prev;
+  uint64_t stamp;
+};
+
+#define KITTEN_BLIT
+
+#ifdef KITTEN_BLIT
+
+struct katch {
+  unsigned blit;
+  unsigned ref : 31;
+  bool binary : 1;
+};
+
+#else
+
+struct katch {
+  unsigned ref;
+};
+
+#endif
+
+struct klause {
+  unsigned aux;
+  unsigned size;
+  unsigned flags;
+  unsigned lits[1];
+};
+
+#ifdef STAND_ALONE_KITTEN
+
+typedef struct statistics statistics;
+
+struct statistics {
+  uint64_t learned;
+  uint64_t original;
+  uint64_t kitten_flip;
+  uint64_t kitten_flipped;
+  uint64_t kitten_sat;
+  uint64_t kitten_solve;
+  uint64_t kitten_solved;
+  uint64_t kitten_conflicts;
+  uint64_t kitten_decisions;
+  uint64_t kitten_propagations;
+  uint64_t kitten_ticks;
+  uint64_t kitten_unknown;
+  uint64_t kitten_unsat;
+};
+
+#endif
+
+typedef struct kimits kimits;
+
+struct kimits {
+  uint64_t ticks;
+};
+
+struct kitten {
+#ifndef STAND_ALONE_KITTEN
+  struct kissat *kissat;
+#define solver (kitten->kissat)
+#endif
+
+  // First zero initialized field in 'clear_kitten' is 'status'.
+  //
+  int status;
+
+#if defined(STAND_ALONE_KITTEN) && defined(LOGGING)
+  bool logging;
+#endif
+  bool antecedents;
+  bool learned;
+
+  unsigned level;
+  unsigned propagated;
+  unsigned unassigned;
+  unsigned inconsistent;
+  unsigned failing;
+
+  uint64_t generator;
+
+  size_t lits;
+  size_t evars;
+
+  size_t end_original_ref;
+
+  struct {
+    unsigned first, last;
+    uint64_t stamp;
+    unsigned search;
+  } queue;
+
+  // The 'size' field below is the first not zero reinitialized field
+  // by 'memset' in 'clear_kitten' (after 'kissat').
+
+  size_t size;
+  size_t esize;
+
+  kar *vars;
+  kink *links;
+  value *marks;
+  value *values;
+  bool *failed;
+  unsigned char *phases;
+  unsigned *import;
+  katches *watches;
+
+  unsigneds analyzed;
+  unsigneds assumptions;
+  unsigneds core;
+  unsigneds eclause;
+  unsigneds export_;
+  unsigneds klause;
+  unsigneds klauses;
+  unsigneds resolved;
+  unsigneds trail;
+  unsigneds units;
+
+  kimits limits;
+  uint64_t initialized;
+
+#ifdef STAND_ALONE_KITTEN
+  statistics statistics;
+#endif
+};
+
+/*------------------------------------------------------------------------*/
+
+static inline bool is_core_klause (klause *c) {
+  return c->flags & CORE_FLAG;
+}
+
+static inline bool is_learned_klause (klause *c) {
+  return c->flags & LEARNED_FLAG;
+}
+
+static inline void set_core_klause (klause *c) { c->flags |= CORE_FLAG; }
+
+static inline void unset_core_klause (klause *c) { c->flags &= ~CORE_FLAG; }
+
+static inline klause *dereference_klause (kitten *kitten, unsigned ref) {
+  unsigned *res = BEGIN_STACK (kitten->klauses) + ref;
+  KISSAT_assert (res < END_STACK (kitten->klauses));
+  return (klause *) res;
+}
+
+#ifdef LOGGING
+
+static inline unsigned reference_klause (kitten *kitten, const klause *c) {
+  const unsigned *const begin = BEGIN_STACK (kitten->klauses);
+  const unsigned *p = (const unsigned *) c;
+  KISSAT_assert (begin <= p);
+  KISSAT_assert (p < END_STACK (kitten->klauses));
+  const unsigned res = p - begin;
+  return res;
+}
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#define KATCHES(KIT) (kitten->watches[KISSAT_assert ((KIT) < kitten->lits), (KIT)])
+
+#define all_klauses(C) \
+  klause *C = begin_klauses (kitten), *end_##C = end_klauses (kitten); \
+  (C) != end_##C; \
+  (C) = next_klause (kitten, C)
+
+#define all_original_klauses(C) \
+  klause *C = begin_klauses (kitten), \
+         *end_##C = end_original_klauses (kitten); \
+  (C) != end_##C; \
+  (C) = next_klause (kitten, C)
+
+#define all_learned_klauses(C) \
+  klause *C = begin_learned_klauses (kitten), \
+         *end_##C = end_klauses (kitten); \
+  (C) != end_##C; \
+  (C) = next_klause (kitten, C)
+
+#define all_kits(KIT) \
+  size_t KIT = 0, KIT_##END = kitten->lits; \
+  KIT != KIT_##END; \
+  KIT++
+
+#define BEGIN_KLAUSE(C) (C)->lits
+
+#define END_KLAUSE(C) (BEGIN_KLAUSE (C) + (C)->size)
+
+#define all_literals_in_klause(KIT, C) \
+  unsigned KIT, *KIT##_PTR = BEGIN_KLAUSE (C), \
+                *KIT##_END = END_KLAUSE (C); \
+  KIT##_PTR != KIT##_END && ((KIT = *KIT##_PTR), true); \
+  ++KIT##_PTR
+
+#define all_antecedents(REF, C) \
+  unsigned REF, *REF##_PTR = antecedents_func (C), \
+                *REF##_END = REF##_PTR + (C)->aux; \
+  REF##_PTR != REF##_END && ((REF = *REF##_PTR), true); \
+  ++REF##_PTR
+
+#ifdef LOGGING
+
+#ifdef STAND_ALONE_KITTEN
+#define logging (kitten->logging)
+#else
+#define logging GET_OPTION (log)
+#endif
+
+static void log_basic (kitten *, const char *, ...)
+    __attribute__ ((format (printf, 2, 3)));
+
+static void log_basic (kitten *kitten, const char *fmt, ...) {
+  KISSAT_assert (logging);
+  printf ("c KITTEN %u ", kitten->level);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+static void log_reference (kitten *, unsigned, const char *, ...)
+    __attribute__ ((format (printf, 3, 4)));
+
+static void log_reference (kitten *kitten, unsigned ref, const char *fmt,
+                           ...) {
+  klause *c = dereference_klause (kitten, ref);
+  KISSAT_assert (logging);
+  printf ("c KITTEN %u ", kitten->level);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (is_learned_klause (c)) {
+    fputs (" learned", stdout);
+    if (c->aux)
+      printf ("[%u]", c->aux);
+  } else {
+    fputs (" original", stdout);
+    if (c->aux != INVALID)
+      printf ("[%u]", c->aux);
+  }
+  printf (" size %u clause[%u]", c->size, ref);
+  value *values = kitten->values;
+  kar *vars = kitten->vars;
+  for (all_literals_in_klause (lit, c)) {
+    printf (" %u", lit);
+    const value value = values[lit];
+    if (value)
+      printf ("@%u=%d", vars[lit / 2].level, (int) value);
+  }
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#define LOG(...) \
+  do { \
+    if (logging) \
+      log_basic (kitten, __VA_ARGS__); \
+  } while (0)
+
+#define ROG(...) \
+  do { \
+    if (logging) \
+      log_reference (kitten, __VA_ARGS__); \
+  } while (0)
+
+#else
+
+#define LOG(...) \
+  do { \
+  } while (0)
+#define ROG(...) \
+  do { \
+  } while (0)
+
+#endif
+
+static void check_queue (kitten *kitten) {
+#ifdef CHECK_KITTEN
+  const unsigned vars = kitten->lits / 2;
+  unsigned found = 0, prev = INVALID;
+  kink *links = kitten->links;
+  uint64_t stamp = 0;
+  for (unsigned idx = kitten->queue.first, next; idx != INVALID;
+       idx = next) {
+    kink *link = links + idx;
+    KISSAT_assert (link->prev == prev);
+    KISSAT_assert (!found || stamp < link->stamp);
+    KISSAT_assert (link->stamp < kitten->queue.stamp);
+    stamp = link->stamp;
+    next = link->next;
+    prev = idx;
+    found++;
+  }
+  KISSAT_assert (found == vars);
+  unsigned next = INVALID;
+  found = 0;
+  for (unsigned idx = kitten->queue.last, prev; idx != INVALID;
+       idx = prev) {
+    kink *link = links + idx;
+    KISSAT_assert (link->next == next);
+    prev = link->prev;
+    next = idx;
+    found++;
+  }
+  KISSAT_assert (found == vars);
+  value *values = kitten->values;
+  bool first = true;
+  for (unsigned idx = kitten->queue.search, next; idx != INVALID;
+       idx = next) {
+    kink *link = links + idx;
+    next = link->next;
+    const unsigned lit = 2 * idx;
+    KISSAT_assert (first || values[lit]);
+    first = false;
+  }
+#else
+  (void) kitten;
+#endif
+}
+
+static void update_search (kitten *kitten, unsigned idx) {
+  if (kitten->queue.search == idx)
+    return;
+  kitten->queue.search = idx;
+  LOG ("search updated to %u stamped %" PRIu64, idx,
+       kitten->links[idx].stamp);
+}
+
+static void enqueue (kitten *kitten, unsigned idx) {
+  LOG ("enqueue %u", idx);
+  kink *links = kitten->links;
+  kink *l = links + idx;
+  const unsigned last = kitten->queue.last;
+  if (last == INVALID)
+    kitten->queue.first = idx;
+  else
+    links[last].next = idx;
+  l->prev = last;
+  l->next = INVALID;
+  kitten->queue.last = idx;
+  l->stamp = kitten->queue.stamp++;
+  LOG ("stamp %" PRIu64, l->stamp);
+}
+
+static void dequeue (kitten *kitten, unsigned idx) {
+  LOG ("dequeue %u", idx);
+  kink *links = kitten->links;
+  kink *l = links + idx;
+  const unsigned prev = l->prev;
+  const unsigned next = l->next;
+  if (prev == INVALID)
+    kitten->queue.first = next;
+  else
+    links[prev].next = next;
+  if (next == INVALID)
+    kitten->queue.last = prev;
+  else
+    links[next].prev = prev;
+}
+
+static void init_queue (kitten *kitten, size_t old_vars, size_t new_vars) {
+  for (size_t idx = old_vars; idx < new_vars; idx++) {
+    KISSAT_assert (!kitten->values[2 * idx]);
+    KISSAT_assert (kitten->unassigned < UINT_MAX);
+    kitten->unassigned++;
+    enqueue (kitten, idx);
+  }
+  LOG ("initialized decision queue from %zu to %zu", old_vars, new_vars);
+  update_search (kitten, kitten->queue.last);
+  check_queue (kitten);
+}
+
+static void initialize_kitten (kitten *kitten) {
+  kitten->queue.first = INVALID;
+  kitten->queue.last = INVALID;
+  kitten->inconsistent = INVALID;
+  kitten->failing = INVALID;
+  kitten->queue.search = INVALID;
+  kitten->limits.ticks = UINT64_MAX;
+  kitten->generator = kitten->initialized++;
+}
+
+static void clear_kitten (kitten *kitten) {
+  size_t bytes = (char *) &kitten->size - (char *) &kitten->status;
+  memset (&kitten->status, 0, bytes);
+#ifdef STAND_ALONE_KITTEN
+  memset (&kitten->statistics, 0, sizeof (statistics));
+#endif
+  initialize_kitten (kitten);
+}
+
+#define RESIZE1(T, P)                            \
+  do { \
+    void *OLD_PTR = (P); \
+    CALLOC (T, (P), new_size / 2);                \
+    const size_t BYTES = old_vars * sizeof *(P); \
+    if (BYTES) \
+      memcpy ((P), OLD_PTR, BYTES); \
+    void *NEW_PTR = (P); \
+    (P) = (T*) OLD_PTR;             \
+    DEALLOC ((P), old_size / 2); \
+    (P) = (T*) NEW_PTR;           \
+  } while (0)
+
+#define RESIZE2(T, P)                            \
+  do { \
+    void *OLD_PTR = (P); \
+    CALLOC (T, (P), new_size);                    \
+    const size_t BYTES = old_lits * sizeof *(P); \
+    if (BYTES) \
+      memcpy ((P), OLD_PTR, BYTES); \
+    void *NEW_PTR = (P); \
+    (P) = (T*) OLD_PTR;         \
+    DEALLOC ((P), old_size); \
+    (P) = (T*) NEW_PTR;       \
+  } while (0)
+
+static void enlarge_internal (kitten *kitten, size_t new_lits) {
+  const size_t old_lits = kitten->lits;
+  KISSAT_assert (old_lits < new_lits);
+  const size_t old_size = kitten->size;
+  const unsigned new_vars = new_lits / 2;
+  const unsigned old_vars = old_lits / 2;
+  if (old_size < new_lits) {
+    size_t new_size = old_size ? 2 * old_size : 2;
+    while (new_size <= new_lits)
+      new_size *= 2;
+    LOG ("internal literals resized to %zu from %zu (requested %zu)",
+         new_size, old_size, new_lits);
+
+    RESIZE1 (value, kitten->marks);
+    RESIZE1 (unsigned char, kitten->phases);
+    RESIZE2 (value, kitten->values);
+    RESIZE2 (bool, kitten->failed);
+    RESIZE1 (kar, kitten->vars);
+    RESIZE1 (kink, kitten->links);
+    RESIZE2 (katches, kitten->watches);
+
+    kitten->size = new_size;
+  }
+  kitten->lits = new_lits;
+  init_queue (kitten, old_vars, new_vars);
+  LOG ("internal literals activated until %zu literals", new_lits);
+  return;
+}
+
+static const char *status_to_string (int status) {
+  switch (status) {
+  case 10:
+    return "formula satisfied";
+  case 20:
+    return "formula inconsistent";
+  case 21:
+    return "formula inconsistent and core computed";
+  default:
+    KISSAT_assert (!status);
+    return "formula unsolved";
+  }
+}
+
+static void invalid_api_usage (const char *fun, const char *fmt, ...) {
+  fprintf (stderr, "kitten: fatal error: invalid API usage in '%s': ", fun);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  abort ();
+}
+
+#define INVALID_API_USAGE(...) invalid_api_usage (__func__, __VA_ARGS__)
+
+#define REQUIRE_INITIALIZED() \
+  do { \
+    if (!kitten) \
+      INVALID_API_USAGE ("solver argument zero"); \
+  } while (0)
+
+#define REQUIRE_STATUS(EXPECTED) \
+  do { \
+    REQUIRE_INITIALIZED (); \
+    if (kitten->status != (EXPECTED)) \
+      INVALID_API_USAGE ("invalid status '%s' (expected '%s')", \
+                         status_to_string (kitten->status), \
+                         status_to_string (EXPECTED)); \
+  } while (0)
+
+#define UPDATE_STATUS(STATUS) \
+  do { \
+    if (kitten->status != (STATUS)) \
+      LOG ("updating status from '%s' to '%s'", \
+           status_to_string (kitten->status), status_to_string (STATUS)); \
+    else \
+      LOG ("keeping status at '%s'", status_to_string (STATUS)); \
+    kitten->status = (STATUS); \
+  } while (0)
+
+#ifdef STAND_ALONE_KITTEN
+
+kitten *kitten_init (void) {
+  kitten *kitten;
+  CALLOC (struct kitten, kitten, 1);
+  initialize_kitten (kitten);
+  return kitten;
+}
+
+#else
+
+kitten *kitten_embedded (struct kissat *kissat) {
+  if (!kissat)
+    INVALID_API_USAGE ("'kissat' argument zero");
+
+  kitten *kitten;
+  struct kitten dummy;
+  dummy.kissat = kissat;
+  kitten = &dummy;
+  CALLOC (struct kitten, kitten, 1);
+  kitten->kissat = kissat;
+  initialize_kitten (kitten);
+  return kitten;
+}
+
+#endif
+
+void kitten_track_antecedents (kitten *kitten) {
+  REQUIRE_STATUS (0);
+
+  if (kitten->learned)
+    INVALID_API_USAGE ("can not start tracking antecedents after learning");
+
+  LOG ("enabling antecedents tracking");
+  kitten->antecedents = true;
+}
+
+void kitten_randomize_phases (kitten *kitten) {
+  REQUIRE_INITIALIZED ();
+
+  LOG ("randomizing phases");
+
+  unsigned char *phases = kitten->phases;
+  const unsigned vars = kitten->size / 2;
+
+  uint64_t random = kissat_next_random64 (&kitten->generator);
+
+  unsigned i = 0;
+  const unsigned rest = vars & ~63u;
+
+  while (i != rest) {
+    uint64_t *p = (uint64_t *) (phases + i);
+    p[0] = (random >> 0) & 0x0101010101010101;
+    p[1] = (random >> 1) & 0x0101010101010101;
+    p[2] = (random >> 2) & 0x0101010101010101;
+    p[3] = (random >> 3) & 0x0101010101010101;
+    p[4] = (random >> 4) & 0x0101010101010101;
+    p[5] = (random >> 5) & 0x0101010101010101;
+    p[6] = (random >> 6) & 0x0101010101010101;
+    p[7] = (random >> 7) & 0x0101010101010101;
+    random = kissat_next_random64 (&kitten->generator);
+    i += 64;
+  }
+
+  unsigned shift = 0;
+  while (i != vars)
+    phases[i++] = (random >> shift++) & 1;
+}
+
+void kitten_flip_phases (kitten *kitten) {
+  REQUIRE_INITIALIZED ();
+
+  LOG ("flipping phases");
+
+  unsigned char *phases = kitten->phases;
+  const unsigned vars = kitten->size / 2;
+
+  unsigned i = 0;
+  const unsigned rest = vars & ~7u;
+
+  while (i != rest) {
+    uint64_t *p = (uint64_t *) (phases + i);
+    *p ^= 0x0101010101010101;
+    i += 8;
+  }
+
+  while (i != vars)
+    phases[i++] ^= 1;
+}
+
+void kitten_no_ticks_limit (kitten *kitten) {
+  REQUIRE_INITIALIZED ();
+  LOG ("forcing no ticks limit");
+  kitten->limits.ticks = UINT64_MAX;
+}
+
+void kitten_set_ticks_limit (kitten *kitten, uint64_t delta) {
+  REQUIRE_INITIALIZED ();
+  const uint64_t current = KITTEN_TICKS;
+  uint64_t limit;
+  if (UINT64_MAX - delta <= current) {
+    LOG ("forcing unlimited ticks limit");
+    limit = UINT64_MAX;
+  } else {
+    limit = current + delta;
+    LOG ("new limit of %" PRIu64 " ticks after %" PRIu64, limit, delta);
+  }
+
+  kitten->limits.ticks = limit;
+}
+
+static void shuffle_unsigned_array (kitten *kitten, size_t size,
+                                    unsigned *a) {
+  for (size_t i = 0; i != size; i++) {
+    const size_t j = kissat_pick_random (&kitten->generator, 0, i);
+    if (j == i)
+      continue;
+    const unsigned first = a[i];
+    const unsigned second = a[j];
+    a[i] = second;
+    a[j] = first;
+  }
+}
+
+static void shuffle_unsigned_stack (kitten *kitten, unsigneds *stack) {
+  const size_t size = SIZE_STACK (*stack);
+  unsigned *a = BEGIN_STACK (*stack);
+  shuffle_unsigned_array (kitten, size, a);
+}
+
+static void shuffle_katches_array (kitten *kitten, size_t size, katch *a) {
+  for (size_t i = 0; i != size; i++) {
+    const size_t j = kissat_pick_random (&kitten->generator, 0, i);
+    if (j == i)
+      continue;
+    const katch first = a[i];
+    const katch second = a[j];
+    a[i] = second;
+    a[j] = first;
+  }
+}
+
+static void shuffle_katches_stack (kitten *kitten, katches *stack) {
+  const size_t size = SIZE_STACK (*stack);
+  katch *a = BEGIN_STACK (*stack);
+  shuffle_katches_array (kitten, size, a);
+}
+
+static void shuffle_katches (kitten *kitten) {
+  LOG ("shuffling watch lists");
+  const size_t lits = kitten->lits;
+  for (size_t lit = 0; lit != lits; lit++)
+    shuffle_katches_stack (kitten, &KATCHES (lit));
+}
+
+static void shuffle_queue (kitten *kitten) {
+  LOG ("shuffling variable decision order");
+
+  const unsigned vars = kitten->lits / 2;
+  for (unsigned i = 0; i != vars; i++) {
+    const unsigned idx = kissat_pick_random (&kitten->generator, 0, vars);
+    dequeue (kitten, idx);
+    enqueue (kitten, idx);
+  }
+  update_search (kitten, kitten->queue.last);
+}
+
+static void shuffle_units (kitten *kitten) {
+  LOG ("shuffling units");
+  shuffle_unsigned_stack (kitten, &kitten->units);
+}
+
+void kitten_shuffle_clauses (kitten *kitten) {
+  REQUIRE_STATUS (0);
+  shuffle_queue (kitten);
+  shuffle_katches (kitten);
+  shuffle_units (kitten);
+}
+
+static inline unsigned *antecedents_func (klause *c) {
+  KISSAT_assert (is_learned_klause (c));
+  return c->lits + c->size;
+}
+
+static inline void watch_klause (kitten *kitten, unsigned lit, klause *c,
+                                 unsigned ref) {
+  ROG (ref, "watching %u in", lit);
+  katches *watches = &KATCHES (lit);
+  katch katch;
+  katch.ref = ref;
+#ifdef KITTEN_BLIT
+  const unsigned size = c->size;
+  KISSAT_assert (lit == c->lits[0] || lit == c->lits[1]);
+  const unsigned blit = c->lits[0] ^ c->lits[1] ^ lit;
+  const bool binary = size == 2;
+  KISSAT_assert (size > 1);
+  KISSAT_assert (ref < (1u << 31));
+  katch.blit = blit;
+  katch.binary = binary;
+#else
+  (void) c;
+#endif
+  PUSH_STACK (*watches, katch);
+}
+
+static inline void connect_new_klause (kitten *kitten, unsigned ref) {
+  ROG (ref, "new");
+
+  klause *c = dereference_klause (kitten, ref);
+
+  if (!c->size) {
+    if (kitten->inconsistent == INVALID) {
+      ROG (ref, "registering inconsistent empty");
+      kitten->inconsistent = ref;
+    } else
+      ROG (ref, "ignoring inconsistent empty");
+  } else if (c->size == 1) {
+    ROG (ref, "watching unit");
+    PUSH_STACK (kitten->units, ref);
+  } else {
+    watch_klause (kitten, c->lits[0], c, ref);
+    watch_klause (kitten, c->lits[1], c, ref);
+  }
+}
+
+static unsigned new_reference (kitten *kitten) {
+  size_t ref = SIZE_STACK (kitten->klauses);
+  if (ref >= INVALID) {
+#ifdef STAND_ALONE_KITTEN
+    die ("maximum number of literals exhausted");
+#else
+    kissat_fatal ("kitten: maximum number of literals exhausted");
+#endif
+  }
+  const unsigned res = (unsigned) ref;
+  KISSAT_assert (res != INVALID);
+  INC (kitten_ticks);
+  return res;
+}
+
+static void new_original_klause (kitten *kitten, unsigned id) {
+  unsigned res = new_reference (kitten);
+  unsigned size = SIZE_STACK (kitten->klause);
+  unsigneds *klauses = &kitten->klauses;
+  PUSH_STACK (*klauses, id);
+  PUSH_STACK (*klauses, size);
+  PUSH_STACK (*klauses, 0);
+  for (all_stack (unsigned, lit, kitten->klause))
+    PUSH_STACK (*klauses, lit);
+  connect_new_klause (kitten, res);
+  kitten->end_original_ref = SIZE_STACK (*klauses);
+#ifdef STAND_ALONE_KITTEN
+  kitten->statistics.original++;
+#endif
+}
+
+static void enlarge_external (kitten *kitten, size_t eidx) {
+  const size_t old_size = kitten->esize;
+  const unsigned old_evars = kitten->evars;
+  KISSAT_assert (old_evars <= eidx);
+  const unsigned new_evars = eidx + 1;
+  if (old_size <= eidx) {
+    size_t new_size = old_size ? 2 * old_size : 1;
+    while (new_size <= eidx)
+      new_size *= 2;
+    LOG ("external resizing to %zu variables from %zu (requested %u)",
+         new_size, old_size, new_evars);
+    unsigned *old_import = kitten->import;
+    CALLOC (unsigned, kitten->import, new_size);
+    const size_t bytes = old_evars * sizeof *kitten->import;
+    if (bytes)
+      memcpy (kitten->import, old_import, bytes);
+    DEALLOC (old_import, old_size);
+    kitten->esize = new_size;
+  }
+  kitten->evars = new_evars;
+  LOG ("external variables enlarged to %u", new_evars);
+}
+
+static unsigned import_literal (kitten *kitten, unsigned elit) {
+  const unsigned eidx = elit / 2;
+  if (eidx >= kitten->evars)
+    enlarge_external (kitten, eidx);
+
+  unsigned iidx = kitten->import[eidx];
+  if (!iidx) {
+    iidx = SIZE_STACK (kitten->export_);
+    PUSH_STACK (kitten->export_, eidx);
+    kitten->import[eidx] = iidx + 1;
+  } else
+    iidx--;
+  unsigned ilit = 2 * iidx + (elit & 1);
+  LOG ("imported external literal %u as internal literal %u", elit, ilit);
+  const size_t new_lits = (ilit | 1) + (size_t) 1;
+  KISSAT_assert (ilit < new_lits);
+  KISSAT_assert (ilit / 2 < new_lits / 2);
+  if (new_lits > kitten->lits)
+    enlarge_internal (kitten, new_lits);
+  return ilit;
+}
+
+static unsigned export_literal (kitten *kitten, unsigned ilit) {
+  const unsigned iidx = ilit / 2;
+  KISSAT_assert (iidx < SIZE_STACK (kitten->export_));
+  const unsigned eidx = PEEK_STACK (kitten->export_, iidx);
+  const unsigned elit = 2 * eidx + (ilit & 1);
+  return elit;
+}
+
+unsigned new_learned_klause (kitten *kitten) {
+  unsigned res = new_reference (kitten);
+  unsigneds *klauses = &kitten->klauses;
+  const size_t size = SIZE_STACK (kitten->klause);
+  KISSAT_assert (size <= UINT_MAX);
+  const size_t aux =
+      kitten->antecedents ? SIZE_STACK (kitten->resolved) : 0;
+  KISSAT_assert (aux <= UINT_MAX);
+  PUSH_STACK (*klauses, (unsigned) aux);
+  PUSH_STACK (*klauses, (unsigned) size);
+  PUSH_STACK (*klauses, LEARNED_FLAG);
+  for (all_stack (unsigned, lit, kitten->klause))
+    PUSH_STACK (*klauses, lit);
+  if (aux)
+    for (all_stack (unsigned, ref, kitten->resolved))
+      PUSH_STACK (*klauses, ref);
+  connect_new_klause (kitten, res);
+  kitten->learned = true;
+#ifdef STAND_ALONE_KITTEN
+  kitten->statistics.learned++;
+#endif
+  return res;
+}
+
+void kitten_clear (kitten *kitten) {
+  LOG ("clear kitten of size %zu", kitten->size);
+
+  KISSAT_assert (EMPTY_STACK (kitten->analyzed));
+  KISSAT_assert (EMPTY_STACK (kitten->klause));
+  KISSAT_assert (EMPTY_STACK (kitten->eclause));
+  KISSAT_assert (EMPTY_STACK (kitten->resolved));
+
+  CLEAR_STACK (kitten->assumptions);
+  CLEAR_STACK (kitten->core);
+  CLEAR_STACK (kitten->klause);
+  CLEAR_STACK (kitten->klauses);
+  CLEAR_STACK (kitten->trail);
+  CLEAR_STACK (kitten->units);
+
+  for (all_kits (kit))
+    CLEAR_STACK (KATCHES (kit));
+
+  while (!EMPTY_STACK (kitten->export_))
+    kitten->import[POP_STACK (kitten->export_)] = 0;
+
+  const size_t lits = kitten->size;
+  const unsigned vars = lits / 2;
+
+#ifndef KISSAT_NDEBUG
+  for (unsigned i = 0; i < vars; i++)
+    KISSAT_assert (!kitten->marks[i]);
+#endif
+
+  if (vars) {
+    memset (kitten->phases, 0, vars);
+    memset (kitten->vars, 0, vars);
+  }
+
+  if (lits) {
+    memset (kitten->values, 0, lits);
+    memset (kitten->failed, 0, lits);
+  }
+
+  clear_kitten (kitten);
+}
+
+void kitten_release (kitten *kitten) {
+  RELEASE_STACK (kitten->analyzed);
+  RELEASE_STACK (kitten->assumptions);
+  RELEASE_STACK (kitten->core);
+  RELEASE_STACK (kitten->eclause);
+  RELEASE_STACK (kitten->export_);
+  RELEASE_STACK (kitten->klause);
+  RELEASE_STACK (kitten->klauses);
+  RELEASE_STACK (kitten->resolved);
+  RELEASE_STACK (kitten->trail);
+  RELEASE_STACK (kitten->units);
+
+  for (size_t lit = 0; lit < kitten->size; lit++)
+    RELEASE_STACK (kitten->watches[lit]);
+
+#ifndef STAND_ALONE_KITTEN
+  const size_t lits = kitten->size;
+  const unsigned vars = lits / 2;
+#endif
+  DEALLOC (kitten->marks, vars);
+  DEALLOC (kitten->phases, vars);
+  DEALLOC (kitten->values, lits);
+  DEALLOC (kitten->failed, lits);
+  DEALLOC (kitten->vars, vars);
+  DEALLOC (kitten->links, vars);
+  DEALLOC (kitten->watches, lits);
+  DEALLOC (kitten->import, kitten->esize);
+#ifdef STAND_ALONE_KITTEN
+  free (kitten);
+#else
+  kissat_free (kitten->kissat, kitten, sizeof *kitten);
+#endif
+}
+
+static inline void move_to_front (kitten *kitten, unsigned idx) {
+  if (idx == kitten->queue.last)
+    return;
+  LOG ("move to front variable %u", idx);
+  dequeue (kitten, idx);
+  enqueue (kitten, idx);
+  KISSAT_assert (kitten->values[2 * idx]);
+}
+
+static inline void assign (kitten *kitten, unsigned lit, unsigned reason) {
+#ifdef LOGGING
+  if (reason == INVALID)
+    LOG ("assign %u as decision", lit);
+  else
+    ROG (reason, "assign %u reason", lit);
+#endif
+  value *values = kitten->values;
+  const unsigned not_lit = lit ^ 1;
+  KISSAT_assert (!values[lit]);
+  KISSAT_assert (!values[not_lit]);
+  values[lit] = 1;
+  values[not_lit] = -1;
+  const unsigned idx = lit / 2;
+  const unsigned sign = lit & 1;
+  kitten->phases[idx] = sign;
+  PUSH_STACK (kitten->trail, lit);
+  kar *v = kitten->vars + idx;
+  v->level = kitten->level;
+  if (!v->level) {
+    KISSAT_assert (reason != INVALID);
+    klause *c = dereference_klause (kitten, reason);
+    if (c->size > 1) {
+      if (kitten->antecedents) {
+        PUSH_STACK (kitten->resolved, reason);
+        for (all_literals_in_klause (other, c))
+          if (other != lit) {
+            const unsigned other_idx = other / 2;
+            const unsigned other_ref = kitten->vars[other_idx].reason;
+            KISSAT_assert (other_ref != INVALID);
+            PUSH_STACK (kitten->resolved, other_ref);
+          }
+      }
+      PUSH_STACK (kitten->klause, lit);
+      reason = new_learned_klause (kitten);
+      CLEAR_STACK (kitten->resolved);
+      CLEAR_STACK (kitten->klause);
+    }
+  }
+  v->reason = reason;
+  KISSAT_assert (kitten->unassigned);
+  kitten->unassigned--;
+}
+
+static inline unsigned propagate_literal (kitten *kitten, unsigned lit) {
+  LOG ("propagating %u", lit);
+  value *values = kitten->values;
+  KISSAT_assert (values[lit] > 0);
+  const unsigned not_lit = lit ^ 1;
+  katches *watches = kitten->watches + not_lit;
+  unsigned conflict = INVALID;
+  katch *q = BEGIN_STACK (*watches);
+  const katch *const end_watches = END_STACK (*watches);
+  katch const *p = q;
+  uint64_t ticks = (((char *) end_watches - (char *) q) >> 7) + 1;
+  while (p != end_watches) {
+    katch katch = *q++ = *p++;
+    const unsigned ref = katch.ref;
+#ifdef KITTEN_BLIT
+    const unsigned blit = katch.blit;
+    KISSAT_assert (blit != not_lit);
+    const value blit_value = values[blit];
+    if (blit_value > 0)
+      continue;
+    if (katch.binary) {
+      if (blit_value < 0) {
+        ROG (ref, "conflict");
+        INC (kitten_conflicts);
+        conflict = ref;
+        break;
+      } else {
+        KISSAT_assert (!blit_value);
+        assign (kitten, blit, ref);
+        continue;
+      }
+    }
+#endif
+    klause *c = dereference_klause (kitten, ref);
+    KISSAT_assert (c->size > 1);
+    unsigned *lits = c->lits;
+    const unsigned other = lits[0] ^ lits[1] ^ not_lit;
+    const value other_value = values[other];
+    ticks++;
+    if (other_value > 0) {
+#ifdef KITTEN_BLIT
+      q[-1].blit = other;
+#endif
+      continue;
+    }
+    value replacement_value = -1;
+    unsigned replacement = INVALID;
+    const unsigned *const end_lits = lits + c->size;
+    unsigned *r;
+    for (r = lits + 2; r != end_lits; r++) {
+      replacement = *r;
+      replacement_value = values[replacement];
+      if (replacement_value >= 0)
+        break;
+    }
+    if (replacement_value >= 0) {
+      KISSAT_assert (replacement != INVALID);
+      ROG (ref, "unwatching %u in", not_lit);
+      lits[0] = other;
+      lits[1] = replacement;
+      *r = not_lit;
+      watch_klause (kitten, replacement, c, ref);
+      q--;
+    } else if (other_value < 0) {
+      ROG (ref, "conflict");
+      INC (kitten_conflicts);
+      conflict = ref;
+      break;
+    } else {
+      KISSAT_assert (!other_value);
+      assign (kitten, other, ref);
+    }
+  }
+  while (p != end_watches)
+    *q++ = *p++;
+  SET_END_OF_STACK (*watches, q);
+  ADD (kitten_ticks, ticks);
+  return conflict;
+}
+
+static inline unsigned propagate (kitten *kitten) {
+  KISSAT_assert (kitten->inconsistent == INVALID);
+  unsigned propagated = 0;
+  unsigned conflict = INVALID;
+  while (conflict == INVALID &&
+         kitten->propagated < SIZE_STACK (kitten->trail)) {
+    const unsigned lit = PEEK_STACK (kitten->trail, kitten->propagated);
+    conflict = propagate_literal (kitten, lit);
+    kitten->propagated++;
+    propagated++;
+  }
+  ADD (kitten_propagations, propagated);
+  return conflict;
+}
+
+static void bump (kitten *kitten) {
+  value *marks = kitten->marks;
+  for (all_stack (unsigned, idx, kitten->analyzed)) {
+    marks[idx] = 0;
+    move_to_front (kitten, idx);
+  }
+  check_queue (kitten);
+}
+
+static inline void unassign (kitten *kitten, value *values, unsigned lit) {
+  const unsigned not_lit = lit ^ 1;
+  KISSAT_assert (values[lit]);
+  KISSAT_assert (values[not_lit]);
+  const unsigned idx = lit / 2;
+#ifdef LOGGING
+  kar *var = kitten->vars + idx;
+  kitten->level = var->level;
+  LOG ("unassign %u", lit);
+#endif
+  values[lit] = values[not_lit] = 0;
+  KISSAT_assert (kitten->unassigned < kitten->lits / 2);
+  kitten->unassigned++;
+  kink *links = kitten->links;
+  kink *link = links + idx;
+  if (link->stamp > links[kitten->queue.search].stamp)
+    update_search (kitten, idx);
+}
+
+static void backtrack (kitten *kitten, unsigned jump) {
+  check_queue (kitten);
+  KISSAT_assert (jump < kitten->level);
+  LOG ("back%s to level %u",
+       (kitten->level == jump + 1 ? "tracking" : "jumping"), jump);
+  kar *vars = kitten->vars;
+  value *values = kitten->values;
+  unsigneds *trail = &kitten->trail;
+  while (!EMPTY_STACK (*trail)) {
+    const unsigned lit = TOP_STACK (*trail);
+    const unsigned idx = lit / 2;
+    const unsigned level = vars[idx].level;
+    if (level == jump)
+      break;
+    (void) POP_STACK (*trail);
+    unassign (kitten, values, lit);
+  }
+  kitten->propagated = SIZE_STACK (*trail);
+  kitten->level = jump;
+  check_queue (kitten);
+}
+
+void completely_backtrack_to_root_level (kitten *kitten) {
+  check_queue (kitten);
+  LOG ("completely backtracking to level 0");
+  value *values = kitten->values;
+  unsigneds *trail = &kitten->trail;
+#ifndef KISSAT_NDEBUG
+  kar *vars = kitten->vars;
+#endif
+  for (all_stack (unsigned, lit, *trail)) {
+    KISSAT_assert (vars[lit / 2].level);
+    unassign (kitten, values, lit);
+  }
+  CLEAR_STACK (*trail);
+  kitten->propagated = 0;
+  kitten->level = 0;
+  check_queue (kitten);
+}
+
+static void analyze (kitten *kitten, unsigned conflict) {
+  KISSAT_assert (kitten->level);
+  KISSAT_assert (kitten->inconsistent == INVALID);
+  KISSAT_assert (EMPTY_STACK (kitten->analyzed));
+  KISSAT_assert (EMPTY_STACK (kitten->resolved));
+  KISSAT_assert (EMPTY_STACK (kitten->klause));
+  PUSH_STACK (kitten->klause, INVALID);
+  unsigned reason = conflict;
+  value *marks = kitten->marks;
+  const kar *const vars = kitten->vars;
+  const unsigned level = kitten->level;
+  unsigned const *p = END_STACK (kitten->trail);
+  unsigned open = 0, jump = 0, size = 1, uip;
+  for (;;) {
+    KISSAT_assert (reason != INVALID);
+    klause *c = dereference_klause (kitten, reason);
+    KISSAT_assert (c);
+    ROG (reason, "analyzing");
+    PUSH_STACK (kitten->resolved, reason);
+    for (all_literals_in_klause (lit, c)) {
+      const unsigned idx = lit / 2;
+      if (marks[idx])
+        continue;
+      KISSAT_assert (kitten->values[lit] < 0);
+      LOG ("analyzed %u", lit);
+      marks[idx] = true;
+      PUSH_STACK (kitten->analyzed, idx);
+      const kar *const v = vars + idx;
+      const unsigned tmp = v->level;
+      if (tmp < level) {
+        if (tmp > jump) {
+          jump = tmp;
+          if (size > 1) {
+            const unsigned other = PEEK_STACK (kitten->klause, 1);
+            POKE_STACK (kitten->klause, 1, lit);
+            lit = other;
+          }
+        }
+        PUSH_STACK (kitten->klause, lit);
+        size++;
+      } else
+        open++;
+    }
+    unsigned idx;
+    do {
+      KISSAT_assert (BEGIN_STACK (kitten->trail) < p);
+      uip = *--p;
+    } while (!marks[idx = uip / 2]);
+    KISSAT_assert (open);
+    if (!--open)
+      break;
+    reason = vars[idx].reason;
+  }
+  const unsigned not_uip = uip ^ 1;
+  LOG ("first UIP %u jump level %u size %u", not_uip, jump, size);
+  POKE_STACK (kitten->klause, 0, not_uip);
+  bump (kitten);
+  CLEAR_STACK (kitten->analyzed);
+  const unsigned learned_ref = new_learned_klause (kitten);
+  CLEAR_STACK (kitten->resolved);
+  CLEAR_STACK (kitten->klause);
+  backtrack (kitten, jump);
+  assign (kitten, not_uip, learned_ref);
+}
+
+static void failing (kitten *kitten) {
+  KISSAT_assert (kitten->inconsistent == INVALID);
+  KISSAT_assert (!EMPTY_STACK (kitten->assumptions));
+  KISSAT_assert (EMPTY_STACK (kitten->analyzed));
+  KISSAT_assert (EMPTY_STACK (kitten->resolved));
+  KISSAT_assert (EMPTY_STACK (kitten->klause));
+  LOG ("analyzing failing assumptions");
+  const value *const values = kitten->values;
+  const kar *const vars = kitten->vars;
+  unsigned failed_clashing = INVALID;
+  unsigned first_failed = INVALID;
+  unsigned failed_unit = INVALID;
+  for (all_stack (unsigned, lit, kitten->assumptions)) {
+    if (values[lit] >= 0)
+      continue;
+    if (first_failed == INVALID)
+      first_failed = lit;
+    const unsigned failed_idx = lit / 2;
+    const kar *const failed_var = vars + failed_idx;
+    if (!failed_var->level) {
+      failed_unit = lit;
+      break;
+    }
+    if (failed_clashing == INVALID && failed_var->reason == INVALID)
+      failed_clashing = lit;
+  }
+  unsigned failed;
+  if (failed_unit != INVALID)
+    failed = failed_unit;
+  else if (failed_clashing != INVALID)
+    failed = failed_clashing;
+  else
+    failed = first_failed;
+  KISSAT_assert (failed != INVALID);
+  const unsigned failed_idx = failed / 2;
+  const kar *const failed_var = vars + failed_idx;
+  const unsigned failed_reason = failed_var->reason;
+  LOG ("first failed assumption %u", failed);
+  kitten->failed[failed] = true;
+
+  if (failed_unit != INVALID) {
+    KISSAT_assert (dereference_klause (kitten, failed_reason)->size == 1);
+    LOG ("root-level falsified assumption %u", failed);
+    kitten->failing = failed_reason;
+    ROG (kitten->failing, "failing reason");
+    return;
+  }
+
+  const unsigned not_failed = failed ^ 1;
+  if (failed_clashing != INVALID) {
+    LOG ("clashing with negated assumption %u", not_failed);
+    kitten->failed[not_failed] = true;
+    KISSAT_assert (kitten->failing == INVALID);
+    return;
+  }
+
+  value *marks = kitten->marks;
+  KISSAT_assert (!marks[failed_idx]);
+  marks[failed_idx] = true;
+  PUSH_STACK (kitten->analyzed, failed_idx);
+  PUSH_STACK (kitten->klause, not_failed);
+
+  for (size_t next = 0; next < SIZE_STACK (kitten->analyzed); next++) {
+    const unsigned idx = PEEK_STACK (kitten->analyzed, next);
+    KISSAT_assert (marks[idx]);
+    const kar *var = vars + idx;
+    const unsigned reason = var->reason;
+    if (reason == INVALID) {
+      unsigned lit = 2 * idx;
+      if (values[lit] < 0)
+        lit ^= 1;
+      LOG ("failed assumption %u", lit);
+      KISSAT_assert (!kitten->failed[lit]);
+      kitten->failed[lit] = true;
+      const unsigned not_lit = lit ^ 1;
+      PUSH_STACK (kitten->klause, not_lit);
+    } else {
+      ROG (reason, "analyzing");
+      PUSH_STACK (kitten->resolved, reason);
+      klause *c = dereference_klause (kitten, reason);
+      for (all_literals_in_klause (other, c)) {
+        const unsigned other_idx = other / 2;
+        if (other_idx == idx)
+          continue;
+        if (marks[other_idx])
+          continue;
+        marks[other_idx] = true;
+        PUSH_STACK (kitten->analyzed, other_idx);
+        LOG ("analyzing final literal %u", other ^ 1);
+      }
+    }
+  }
+
+  for (all_stack (unsigned, idx, kitten->analyzed))
+    KISSAT_assert (marks[idx]), marks[idx] = 0;
+  CLEAR_STACK (kitten->analyzed);
+
+  const size_t resolved = SIZE_STACK (kitten->resolved);
+  KISSAT_assert (resolved);
+
+  if (resolved == 1) {
+    kitten->failing = PEEK_STACK (kitten->resolved, 0);
+    ROG (kitten->failing, "reusing as core");
+  } else {
+    kitten->failing = new_learned_klause (kitten);
+    ROG (kitten->failing, "new core");
+  }
+
+  CLEAR_STACK (kitten->resolved);
+  CLEAR_STACK (kitten->klause);
+}
+
+static void flush_trail (kitten *kitten) {
+  unsigneds *trail = &kitten->trail;
+  LOG ("flushing %zu root-level literals from trail", SIZE_STACK (*trail));
+  KISSAT_assert (!kitten->level);
+  kitten->propagated = 0;
+  CLEAR_STACK (*trail);
+}
+
+static int decide (kitten *kitten) {
+  if (!kitten->level && !EMPTY_STACK (kitten->trail))
+    flush_trail (kitten);
+
+  const value *const values = kitten->values;
+  unsigned decision = INVALID;
+  const size_t assumptions = SIZE_STACK (kitten->assumptions);
+  while (kitten->level < assumptions) {
+    unsigned assumption = PEEK_STACK (kitten->assumptions, kitten->level);
+    value value = values[assumption];
+    if (value < 0) {
+      LOG ("found failing assumption %u", assumption);
+      failing (kitten);
+      return 20;
+    } else if (value > 0) {
+
+      kitten->level++;
+      LOG ("pseudo decision level %u for already satisfied assumption %u",
+           kitten->level, assumption);
+    } else {
+      decision = assumption;
+      LOG ("using assumption %u as decision", decision);
+      break;
+    }
+  }
+
+  if (!kitten->unassigned)
+    return 10;
+
+  if (KITTEN_TICKS >= kitten->limits.ticks) {
+    LOG ("ticks limit %" PRIu64 " hit after %" PRIu64 " ticks",
+         kitten->limits.ticks, KITTEN_TICKS);
+    return -1;
+  }
+
+#ifndef STAND_ALONE_KITTEN
+  if (TERMINATED (kitten_terminated_1))
+    return -1;
+#endif
+
+  if (decision == INVALID) {
+    unsigned idx = kitten->queue.search;
+    const kink *const links = kitten->links;
+    for (;;) {
+      KISSAT_assert (idx != INVALID);
+      if (!values[2 * idx])
+        break;
+      idx = links[idx].prev;
+    }
+    update_search (kitten, idx);
+    const unsigned phase = kitten->phases[idx];
+    decision = 2 * idx + phase;
+    LOG ("decision %u variable %u phase %u", decision, idx, phase);
+  }
+  INC (kitten_decisions);
+  kitten->level++;
+  assign (kitten, decision, INVALID);
+  return 0;
+}
+
+static void inconsistent (kitten *kitten, unsigned ref) {
+  KISSAT_assert (ref != INVALID);
+  KISSAT_assert (kitten->inconsistent == INVALID);
+
+  if (!kitten->antecedents) {
+    kitten->inconsistent = ref;
+    ROG (ref, "registering inconsistent virtually empty");
+    return;
+  }
+
+  unsigneds *analyzed = &kitten->analyzed;
+  unsigneds *resolved = &kitten->resolved;
+
+  KISSAT_assert (EMPTY_STACK (*analyzed));
+  KISSAT_assert (EMPTY_STACK (*resolved));
+
+  value *marks = kitten->marks;
+  const kar *const vars = kitten->vars;
+  unsigned next = 0;
+
+  for (;;) {
+    KISSAT_assert (ref != INVALID);
+    klause *c = dereference_klause (kitten, ref);
+    KISSAT_assert (c);
+    ROG (ref, "analyzing inconsistent");
+    PUSH_STACK (*resolved, ref);
+    for (all_literals_in_klause (lit, c)) {
+      const unsigned idx = lit / 2;
+      KISSAT_assert (!vars[idx].level);
+      if (marks[idx])
+        continue;
+      KISSAT_assert (kitten->values[lit] < 0);
+      LOG ("analyzed %u", lit);
+      marks[idx] = true;
+      PUSH_STACK (kitten->analyzed, idx);
+    }
+    if (next == SIZE_STACK (kitten->analyzed))
+      break;
+    const unsigned idx = PEEK_STACK (kitten->analyzed, next);
+    next++;
+    const kar *const v = vars + idx;
+    KISSAT_assert (!v->level);
+    ref = v->reason;
+  }
+  KISSAT_assert (EMPTY_STACK (kitten->klause));
+  ref = new_learned_klause (kitten);
+  ROG (ref, "registering final inconsistent empty");
+  kitten->inconsistent = ref;
+
+  for (all_stack (unsigned, idx, *analyzed))
+    marks[idx] = 0;
+
+  CLEAR_STACK (*analyzed);
+  CLEAR_STACK (*resolved);
+}
+
+static int propagate_units (kitten *kitten) {
+  if (kitten->inconsistent != INVALID)
+    return 20;
+
+  if (EMPTY_STACK (kitten->units)) {
+    LOG ("no root level unit clauses");
+    return 0;
+  }
+
+  LOG ("propagating %zu root level unit clauses",
+       SIZE_STACK (kitten->units));
+
+  const value *const values = kitten->values;
+
+  for (size_t next = 0; next < SIZE_STACK (kitten->units); next++) {
+    const unsigned ref = PEEK_STACK (kitten->units, next);
+    KISSAT_assert (ref != INVALID);
+    klause *c = dereference_klause (kitten, ref);
+    KISSAT_assert (c->size == 1);
+    ROG (ref, "propagating unit");
+    const unsigned unit = c->lits[0];
+    const value value = values[unit];
+    if (value > 0)
+      continue;
+    if (value < 0) {
+      inconsistent (kitten, ref);
+      return 20;
+    }
+    assign (kitten, unit, ref);
+    const unsigned conflict = propagate (kitten);
+    if (conflict == INVALID)
+      continue;
+    inconsistent (kitten, conflict);
+    return 20;
+  }
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+static klause *begin_klauses (kitten *kitten) {
+  return (klause *) BEGIN_STACK (kitten->klauses);
+}
+
+static klause *end_original_klauses (kitten *kitten) {
+  return (klause *) (BEGIN_STACK (kitten->klauses) +
+                     kitten->end_original_ref);
+}
+
+static klause *end_klauses (kitten *kitten) {
+  return (klause *) END_STACK (kitten->klauses);
+}
+
+static klause *next_klause (kitten *kitten, klause *c) {
+  KISSAT_assert (begin_klauses (kitten) <= c);
+  KISSAT_assert (c < end_klauses (kitten));
+  unsigned *res = c->lits + c->size;
+  if (kitten->antecedents && is_learned_klause (c))
+    res += c->aux;
+  return (klause *) res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void reset_core (kitten *kitten) {
+  LOG ("resetting core clauses");
+  size_t reset = 0;
+  for (all_klauses (c))
+    if (is_core_klause (c))
+      unset_core_klause (c), reset++;
+  LOG ("reset %zu core clauses", reset);
+  CLEAR_STACK (kitten->core);
+}
+
+static void reset_assumptions (kitten *kitten) {
+  LOG ("reset %zu assumptions", SIZE_STACK (kitten->assumptions));
+  while (!EMPTY_STACK (kitten->assumptions)) {
+    const unsigned assumption = POP_STACK (kitten->assumptions);
+    kitten->failed[assumption] = false;
+  }
+#ifndef KISSAT_NDEBUG
+  for (size_t i = 0; i < kitten->size; i++)
+    KISSAT_assert (!kitten->failed[i]);
+#endif
+  CLEAR_STACK (kitten->assumptions);
+  if (kitten->failing != INVALID) {
+    ROG (kitten->failing, "reset failed assumption reason");
+    kitten->failing = INVALID;
+  }
+}
+
+static void reset_incremental (kitten *kitten) {
+  if (kitten->level)
+    completely_backtrack_to_root_level (kitten);
+  if (!EMPTY_STACK (kitten->assumptions))
+    reset_assumptions (kitten);
+  else
+    KISSAT_assert (kitten->failing == INVALID);
+  if (kitten->status == 21)
+    reset_core (kitten);
+  UPDATE_STATUS (0);
+}
+
+/*------------------------------------------------------------------------*/
+
+static bool flip_literal (kitten *kitten, unsigned lit) {
+  INC (kitten_flip);
+  signed char *values = kitten->values;
+  KISSAT_assert (values[lit]);
+  if (!kitten->vars[lit / 2].level) {
+    LOG ("can not flip root-level assigned literal %u", lit);
+    return false;
+  }
+  if (values[lit] < 0)
+    lit ^= 1;
+  LOG ("trying to flip value of satisfied literal %u", lit);
+  KISSAT_assert (values[lit] > 0);
+  katches *watches = kitten->watches + lit;
+  katch *q = BEGIN_STACK (*watches);
+  const katch *const end_watches = END_STACK (*watches);
+  katch const *p = q;
+  uint64_t ticks = (((char *) end_watches - (char *) q) >> 7) + 1;
+  bool res = true;
+  while (p != end_watches) {
+    const katch katch = *q++ = *p++;
+#ifdef KITTEN_BLIT
+    const unsigned blit = katch.blit;
+    KISSAT_assert (blit != lit);
+    const value blit_value = values[blit];
+    if (blit_value > 0)
+      continue;
+#endif
+    const unsigned ref = katch.ref;
+    klause *c = dereference_klause (kitten, ref);
+    unsigned *lits = c->lits;
+    const unsigned other = lits[0] ^ lits[1] ^ lit;
+    const value other_value = values[other];
+    ticks++;
+    if (other_value > 0)
+      continue;
+    value replacement_value = -1;
+    unsigned replacement = INVALID;
+    const unsigned *const end_lits = lits + c->size;
+    unsigned *r;
+    for (r = lits + 2; r != end_lits; r++) {
+      replacement = *r;
+      KISSAT_assert (replacement != lit);
+      replacement_value = values[replacement];
+      KISSAT_assert (replacement_value);
+      if (replacement_value > 0)
+        break;
+    }
+    if (replacement_value > 0) {
+      KISSAT_assert (replacement != INVALID);
+      ROG (ref, "unwatching %u in", lit);
+      lits[0] = other;
+      lits[1] = replacement;
+      *r = lit;
+      watch_klause (kitten, replacement, c, ref);
+      q--;
+    } else {
+      KISSAT_assert (replacement_value < 0);
+      ROG (ref, "single satisfied");
+      res = false;
+      break;
+    }
+  }
+  while (p != end_watches)
+    *q++ = *p++;
+  SET_END_OF_STACK (*watches, q);
+  ADD (kitten_ticks, ticks);
+  if (res) {
+    LOG ("flipping value of %u", lit);
+    values[lit] = -1;
+    const unsigned not_lit = lit ^ 1;
+    values[not_lit] = 1;
+    INC (kitten_flipped);
+  } else
+    LOG ("failed to flip value of %u", lit);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+void kitten_assume (kitten *kitten, unsigned elit) {
+  REQUIRE_INITIALIZED ();
+  if (kitten->status)
+    reset_incremental (kitten);
+  const unsigned ilit = import_literal (kitten, elit);
+  LOG ("registering assumption %u", ilit);
+  PUSH_STACK (kitten->assumptions, ilit);
+}
+
+void kitten_clause_with_id_and_exception (kitten *kitten, unsigned id,
+                                          size_t size,
+                                          const unsigned *elits,
+                                          unsigned except) {
+  REQUIRE_INITIALIZED ();
+  if (kitten->status)
+    reset_incremental (kitten);
+  KISSAT_assert (EMPTY_STACK (kitten->klause));
+  const unsigned *const end = elits + size;
+  for (const unsigned *p = elits; p != end; p++) {
+    const unsigned elit = *p;
+    if (elit == except)
+      continue;
+    const unsigned ilit = import_literal (kitten, elit);
+    KISSAT_assert (ilit < kitten->lits);
+    const unsigned iidx = ilit / 2;
+    if (kitten->marks[iidx])
+      INVALID_API_USAGE ("variable '%u' of literal '%u' occurs twice",
+                         elit / 2, elit);
+    kitten->marks[iidx] = true;
+    PUSH_STACK (kitten->klause, ilit);
+  }
+  for (unsigned *p = kitten->klause.begin; p != kitten->klause.end; p++)
+    kitten->marks[*p / 2] = false;
+  new_original_klause (kitten, id);
+  CLEAR_STACK (kitten->klause);
+}
+
+void kitten_clause (kitten *kitten, size_t size, unsigned *elits) {
+  kitten_clause_with_id_and_exception (kitten, INVALID, size, elits,
+                                       INVALID);
+}
+
+void kitten_unit (kitten *kitten, unsigned lit) {
+  kitten_clause (kitten, 1, &lit);
+}
+
+void kitten_binary (kitten *kitten, unsigned a, unsigned b) {
+  unsigned clause[2] = {a, b};
+  kitten_clause (kitten, 2, clause);
+}
+
+#ifdef STAND_ALONE_KITTEN
+static volatile bool time_limit_hit;
+#endif
+
+int kitten_solve (kitten *kitten) {
+  REQUIRE_INITIALIZED ();
+  if (kitten->status)
+    reset_incremental (kitten);
+  else if (kitten->level)
+    completely_backtrack_to_root_level (kitten);
+
+  LOG ("starting solving under %zu assumptions",
+       SIZE_STACK (kitten->assumptions));
+
+  INC (kitten_solved);
+
+  int res = propagate_units (kitten);
+  while (!res) {
+    const unsigned conflict = propagate (kitten);
+    if (conflict != INVALID) {
+      if (kitten->level)
+        analyze (kitten, conflict);
+      else {
+        inconsistent (kitten, conflict);
+        res = 20;
+      }
+    } else
+#ifdef STAND_ALONE_KITTEN
+        if (time_limit_hit) {
+      time_limit_hit = false;
+      break;
+    } else
+#endif
+      res = decide (kitten);
+  }
+
+  if (res < 0)
+    res = 0;
+
+  if (!res && !EMPTY_STACK (kitten->assumptions))
+    reset_assumptions (kitten);
+
+  UPDATE_STATUS (res);
+
+  if (res == 10)
+    INC (kitten_sat);
+  else if (res == 20)
+    INC (kitten_unsat);
+  else
+    INC (kitten_unknown);
+
+  LOG ("finished solving with result %d", res);
+
+  return res;
+}
+
+int kitten_status (kitten *kitten) { return kitten->status; }
+
+unsigned kitten_compute_clausal_core (kitten *kitten,
+                                      uint64_t *learned_ptr) {
+  REQUIRE_STATUS (20);
+
+  if (!kitten->antecedents)
+    INVALID_API_USAGE ("antecedents not tracked");
+
+  LOG ("computing clausal core");
+
+  unsigneds *resolved = &kitten->resolved;
+  KISSAT_assert (EMPTY_STACK (*resolved));
+
+  unsigned original = 0;
+  uint64_t learned = 0;
+
+  unsigned reason_ref = kitten->inconsistent;
+
+  if (reason_ref == INVALID) {
+    KISSAT_assert (!EMPTY_STACK (kitten->assumptions));
+    reason_ref = kitten->failing;
+    if (reason_ref == INVALID) {
+      LOG ("assumptions mutually inconsistent");
+
+      
+      //      goto DONE;
+  if (learned_ptr)
+    *learned_ptr = learned;
+
+  LOG ("clausal core of %u original clauses", original);
+  LOG ("clausal core of %" PRIu64 " learned clauses", learned);
+#ifdef STAND_ALONE_KITTEN
+  kitten->statistics.original = original;
+  kitten->statistics.learned = 0;
+#endif
+  UPDATE_STATUS (21);
+
+  return original;
+
+  
+    }
+  }
+
+  PUSH_STACK (*resolved, reason_ref);
+  unsigneds *core = &kitten->core;
+  KISSAT_assert (EMPTY_STACK (*core));
+
+  while (!EMPTY_STACK (*resolved)) {
+    const unsigned c_ref = POP_STACK (*resolved);
+    if (c_ref == INVALID) {
+      const unsigned d_ref = POP_STACK (*resolved);
+      ROG (d_ref, "core[%zu]", SIZE_STACK (*core));
+      PUSH_STACK (*core, d_ref);
+      klause *d = dereference_klause (kitten, d_ref);
+      KISSAT_assert (!is_core_klause (d));
+      set_core_klause (d);
+      if (is_learned_klause (d))
+        learned++;
+      else
+        original++;
+    } else {
+      klause *c = dereference_klause (kitten, c_ref);
+      if (is_core_klause (c))
+        continue;
+      PUSH_STACK (*resolved, c_ref);
+      PUSH_STACK (*resolved, INVALID);
+      ROG (c_ref, "analyzing antecedent core");
+      if (!is_learned_klause (c))
+        continue;
+      for (all_antecedents (d_ref, c)) {
+        klause *d = dereference_klause (kitten, d_ref);
+        if (!is_core_klause (d))
+          PUSH_STACK (*resolved, d_ref);
+      }
+    }
+  }
+
+  //DONE:
+
+  if (learned_ptr)
+    *learned_ptr = learned;
+
+  LOG ("clausal core of %u original clauses", original);
+  LOG ("clausal core of %" PRIu64 " learned clauses", learned);
+#ifdef STAND_ALONE_KITTEN
+  kitten->statistics.original = original;
+  kitten->statistics.learned = 0;
+#endif
+  UPDATE_STATUS (21);
+
+  return original;
+}
+
+void kitten_traverse_core_ids (kitten *kitten, void *state,
+                               void (*traverse) (void *, unsigned)) {
+  REQUIRE_STATUS (21);
+
+  LOG ("traversing core of original clauses");
+
+  unsigned traversed = 0;
+
+  for (all_original_klauses (c)) {
+    KISSAT_assert (!is_learned_klause (c));
+    if (is_learned_klause (c))
+      continue;
+    if (!is_core_klause (c))
+      continue;
+    ROG (reference_klause (kitten, c), "traversing");
+    traverse (state, c->aux);
+    traversed++;
+  }
+
+  LOG ("traversed %u original core clauses", traversed);
+  (void) traversed;
+
+  KISSAT_assert (kitten->status == 21);
+}
+
+void kitten_traverse_core_clauses (kitten *kitten, void *state,
+                                   void (*traverse) (void *, bool, size_t,
+                                                     const unsigned *)) {
+  REQUIRE_STATUS (21);
+
+  LOG ("traversing clausal core");
+
+  unsigned traversed = 0;
+
+  for (all_stack (unsigned, c_ref, kitten->core)) {
+    klause *c = dereference_klause (kitten, c_ref);
+    KISSAT_assert (is_core_klause (c));
+    const bool learned = is_learned_klause (c);
+    unsigneds *eclause = &kitten->eclause;
+    KISSAT_assert (EMPTY_STACK (*eclause));
+    for (all_literals_in_klause (ilit, c)) {
+      const unsigned elit = export_literal (kitten, ilit);
+      PUSH_STACK (*eclause, elit);
+    }
+    const size_t size = SIZE_STACK (*eclause);
+    const unsigned *elits = eclause->begin;
+    ROG (reference_klause (kitten, c), "traversing");
+    traverse (state, learned, size, elits);
+    CLEAR_STACK (*eclause);
+    traversed++;
+  }
+
+  LOG ("traversed %u core clauses", traversed);
+  (void) traversed;
+
+  KISSAT_assert (kitten->status == 21);
+}
+
+void kitten_shrink_to_clausal_core (kitten *kitten) {
+  REQUIRE_STATUS (21);
+
+  LOG ("shrinking formula to core of original clauses");
+
+  CLEAR_STACK (kitten->trail);
+
+  kitten->unassigned = kitten->lits / 2;
+  kitten->propagated = 0;
+  kitten->level = 0;
+
+  update_search (kitten, kitten->queue.last);
+
+  memset (kitten->values, 0, kitten->lits);
+
+  for (all_kits (lit))
+    CLEAR_STACK (KATCHES (lit));
+
+  KISSAT_assert (kitten->inconsistent != INVALID);
+  klause *inconsistent = dereference_klause (kitten, kitten->inconsistent);
+  if (is_learned_klause (inconsistent) || inconsistent->size) {
+    ROG (kitten->inconsistent, "resetting inconsistent");
+    kitten->inconsistent = INVALID;
+  } else
+    ROG (kitten->inconsistent, "keeping inconsistent");
+
+  CLEAR_STACK (kitten->units);
+
+  klause *begin = begin_klauses (kitten), *q = begin;
+  klause const *const end = end_original_klauses (kitten);
+#ifdef LOGGING
+  unsigned original = 0;
+#endif
+  for (klause *c = begin, *next; c != end; c = next) {
+    next = next_klause (kitten, c);
+    KISSAT_assert (!is_learned_klause (c));
+    if (is_learned_klause (c))
+      continue;
+    if (!is_core_klause (c))
+      continue;
+    unset_core_klause (c);
+    const unsigned dst = (unsigned *) q - (unsigned *) begin;
+    const unsigned size = c->size;
+    if (!size) {
+      if (!kitten->inconsistent)
+        kitten->inconsistent = dst;
+    } else if (size == 1)
+      PUSH_STACK (kitten->units, dst);
+    else {
+      watch_klause (kitten, c->lits[0], c, dst);
+      watch_klause (kitten, c->lits[1], c, dst);
+    }
+    if (c == q)
+      q = next;
+    else {
+      const size_t bytes = (char *) next - (char *) c;
+      memmove (q, c, bytes);
+      q = (klause *) ((char *) q + bytes);
+    }
+#ifdef LOGGING
+    original++;
+#endif
+  }
+  SET_END_OF_STACK (kitten->klauses, (unsigned *) q);
+  kitten->end_original_ref = SIZE_STACK (kitten->klauses);
+  LOG ("end of original clauses at %zu", kitten->end_original_ref);
+  LOG ("%u original clauses left", original);
+
+  CLEAR_STACK (kitten->core);
+
+  UPDATE_STATUS (0);
+}
+
+signed char kitten_value (kitten *kitten, unsigned elit) {
+  REQUIRE_STATUS (10);
+  const unsigned eidx = elit / 2;
+  if (eidx >= kitten->evars)
+    return 0;
+  unsigned iidx = kitten->import[eidx];
+  if (!iidx)
+    return 0;
+  const unsigned ilit = 2 * (iidx - 1) + (elit & 1);
+  return kitten->values[ilit];
+}
+
+signed char kitten_fixed (kitten *kitten, unsigned elit) {
+  const unsigned eidx = elit / 2;
+  if (eidx >= kitten->evars)
+    return 0;
+  unsigned iidx = kitten->import[eidx];
+  if (!iidx)
+    return 0;
+  iidx--;
+  const unsigned ilit = 2 * iidx + (elit & 1);
+  signed char res = kitten->values[ilit];
+  if (!res)
+    return 0;
+  kar *v = kitten->vars + iidx;
+  if (v->level)
+    return 0;
+  return res;
+}
+
+bool kitten_flip_literal (kitten *kitten, unsigned elit) {
+  REQUIRE_STATUS (10);
+  const unsigned eidx = elit / 2;
+  if (eidx >= kitten->evars)
+    return false;
+  unsigned iidx = kitten->import[eidx];
+  if (!iidx)
+    return false;
+  const unsigned ilit = 2 * (iidx - 1) + (elit & 1);
+  return flip_literal (kitten, ilit);
+}
+
+bool kitten_failed (kitten *kitten, unsigned elit) {
+  REQUIRE_STATUS (20);
+  const unsigned eidx = elit / 2;
+  if (eidx >= kitten->evars)
+    return false;
+  unsigned iidx = kitten->import[eidx];
+  if (!iidx)
+    return false;
+  const unsigned ilit = 2 * (iidx - 1) + (elit & 1);
+  return kitten->failed[ilit];
+}
+
+/*------------------------------------------------------------------------*/
+
+#ifdef STAND_ALONE_KITTEN
+
+#include <ctype.h>
+#include <signal.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+
+static double process_time (void) {
+  struct rusage u;
+  double res;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  res = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;
+  res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
+  return res;
+}
+
+static double maximum_resident_set_size (void) {
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  const uint64_t bytes = ((uint64_t) u.ru_maxrss) << 10;
+  return bytes / (double) (1 << 20);
+}
+
+#include "attribute.h"
+
+static void msg (const char *, ...) __attribute__ ((format (printf, 1, 2)));
+
+static void msg (const char *fmt, ...) {
+  fputs ("c ", stdout);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#undef logging
+
+typedef struct parser parser;
+
+struct parser {
+  const char *path;
+  uint64_t lineno;
+  FILE *file;
+#ifdef LOGGING
+  bool logging;
+#endif
+};
+
+static void parse_error (parser *parser, const char *msg) {
+  fprintf (stderr, "kitten: error: %s:%" PRIu64 ": parse error: %s\n",
+           parser->path, parser->lineno, msg);
+  exit (1);
+}
+
+#define ERROR(...) parse_error (parser, __VA_ARGS__)
+
+static inline int next_char (parser *parser) {
+  int res = getc (parser->file);
+  if (res == '\r') {
+    res = getc (parser->file);
+    if (res != '\n')
+      ERROR ("expected new line after carriage return");
+  }
+  if (res == '\n')
+    parser->lineno++;
+  return res;
+}
+
+#define NEXT() next_char (parser)
+
+#define FAILED INT_MIN
+
+static int parse_number (parser *parser, int *res_ptr) {
+  int ch = NEXT ();
+  if (!isdigit (ch))
+    return FAILED;
+  int res = ch - '0';
+  while (isdigit (ch = NEXT ())) {
+    if (!res)
+      return FAILED;
+    if (INT_MAX / 10 < res)
+      return FAILED;
+    res *= 10;
+    const int digit = ch - '0';
+    if (INT_MAX - digit < res)
+      return FAILED;
+    res += digit;
+  }
+  *res_ptr = res;
+  return ch;
+}
+
+static kitten *parse (parser *parser, ints *originals, int *max_var) {
+  signed char *marks = 0;
+  size_t size_marks = 0;
+  int last = '\n', ch;
+  for (;;) {
+    ch = NEXT ();
+    if (ch == 'c') {
+      while ((ch = NEXT ()) != '\n')
+        if (ch == EOF)
+          ERROR ("unexpected end-of-file in comment");
+    } else if (ch != ' ' && ch != '\t' && ch != '\n')
+      break;
+    last = ch;
+  }
+  if (ch != 'p' || last != '\n')
+    ERROR ("expected 'c' or 'p' at start of line");
+  bool valid = (NEXT () == ' ' && NEXT () == 'c' && NEXT () == 'n' &&
+                NEXT () == 'f' && NEXT () == ' ');
+  int vars = 0;
+  int clauses = 0;
+  if (valid && (parse_number (parser, &vars) != ' ' ||
+                parse_number (parser, &clauses) != '\n'))
+    valid = false;
+  if (!valid)
+    ERROR ("invalid header");
+  msg ("found header 'p cnf %d %d'", vars, clauses);
+  *max_var = vars;
+  kitten *kitten = kitten_init ();
+#ifdef LOGGING
+  kitten->logging = parser->logging;
+#define logging (kitten->logging)
+#endif
+  unsigneds clause;
+  INIT_STACK (clause);
+  int iidx = 0;
+  int parsed = 0;
+  bool tautological = false;
+  uint64_t offset = 0;
+  for (;;) {
+    ch = NEXT ();
+    if (ch == EOF) {
+      if (parsed < clauses)
+        ERROR ("clause missing");
+      if (iidx)
+        ERROR ("zero missing");
+      break;
+    }
+    if (ch == ' ' || ch == '\t' || ch == '\n')
+      continue;
+    if (ch == 'c') {
+      while ((ch = NEXT ()) != '\n')
+        if (ch == EOF)
+          ERROR ("unexpected end-of-file in comment");
+      continue;
+    }
+    int sign = 1;
+    if (ch == '-')
+      sign = -1;
+    else
+      ungetc (ch, parser->file);
+    ch = parse_number (parser, &iidx);
+    if (ch == FAILED)
+      ERROR ("invalid literal");
+    if (ch == EOF)
+      ERROR ("unexpected end-of-file after literal");
+    if (ch == 'c') {
+      while ((ch = NEXT ()) != '\n')
+        if (ch == EOF)
+          ERROR ("unexpected end-of-file in comment");
+    } else if (ch != ' ' && ch != '\t' && ch != '\n')
+      ERROR ("expected comment or white space after literal");
+    if (iidx > vars)
+      ERROR ("maximum variable exceeded");
+    if (parsed == clauses)
+      ERROR ("too many clauses");
+    const int ilit = sign * iidx;
+    if (originals)
+      PUSH_STACK (*originals, ilit);
+    if (!iidx) {
+      for (all_stack (unsigned, ulit, clause))
+        marks[ulit / 2] = 0;
+      if (tautological) {
+        LOG ("skipping tautological clause");
+        tautological = false;
+      } else if (offset > UINT_MAX)
+        ERROR ("too many original literals");
+      else {
+        KISSAT_assert (SIZE_STACK (clause) <= UINT_MAX);
+        const unsigned size = SIZE_STACK (clause);
+        const unsigned *const lits = BEGIN_STACK (clause);
+        kitten_clause_with_id_and_exception (kitten, offset, size, lits,
+                                             INVALID);
+      }
+      CLEAR_STACK (clause);
+      parsed++;
+
+      if (originals)
+        offset = SIZE_STACK (*originals);
+      else
+        offset = parsed;
+    } else if (!tautological) {
+      const unsigned uidx = iidx - 1;
+      const unsigned ulit = 2 * uidx + (sign < 0);
+      if (uidx >= size_marks) {
+        size_t new_size_marks = size_marks ? 2 * size_marks : 1;
+        while (uidx >= new_size_marks)
+          new_size_marks *= 2;
+        signed char *new_marks;
+        CALLOC (signed char, new_marks, new_size_marks);
+        if (size_marks)
+          memcpy (new_marks, marks, size_marks);
+        DEALLOC (marks, size_marks);
+        size_marks = new_size_marks;
+        marks = new_marks;
+      }
+      value mark = marks[uidx];
+      if (sign < 0)
+        mark = -mark;
+      if (mark > 0)
+        LOG ("dropping repeated %d in parsed clause", ilit);
+      else if (mark < 0) {
+        LOG ("parsed clause contains both %d and %d", -ilit, ilit);
+        tautological = true;
+      } else {
+        LOG ("adding parsed integer literal %d as external literal %u",
+             ilit, ulit);
+        marks[uidx] = sign;
+        PUSH_STACK (clause, ulit);
+      }
+    }
+  }
+  RELEASE_STACK (clause);
+  free (marks);
+  return kitten;
+}
+
+typedef struct line line;
+
+struct line {
+  char buffer[80];
+  size_t size;
+};
+
+static void flush_line (line *line) {
+  if (!line->size)
+    return;
+  for (size_t i = 0; i < line->size; i++)
+    fputc (line->buffer[i], stdout);
+  fputc ('\n', stdout);
+  line->size = 0;
+}
+
+static inline void print_lit (line *line, int lit) {
+  char tmp[16];
+  sprintf (tmp, " %d", lit);
+  const size_t len = strlen (tmp);
+  if (line->size + len > 78)
+    flush_line (line);
+  if (!line->size) {
+    line->buffer[0] = 'v';
+    line->size = 1;
+  }
+  strcpy (line->buffer + line->size, tmp);
+  line->size += len;
+}
+
+static void print_witness (kitten *kitten, int max_var) {
+  KISSAT_assert (max_var >= 0);
+  line line = {.size = 0};
+  const size_t parsed_lits = 2 * (size_t) max_var;
+  for (size_t ulit = 0; ulit < parsed_lits; ulit += 2) {
+    const value sign = kitten_value (kitten, ulit);
+    const int iidx = ulit / 2 + 1;
+    const int ilit = (sign > 0 ? iidx : -iidx);
+    print_lit (&line, ilit);
+  }
+  print_lit (&line, 0);
+  flush_line (&line);
+}
+
+static double percent (double a, double b) { return b ? 100 * a / b : 0; }
+
+typedef struct core_writer core_writer;
+
+struct core_writer {
+  FILE *file;
+  ints *originals;
+#ifndef KISSAT_NDEBUG
+  unsigned written;
+#endif
+};
+
+static void write_offset (void *ptr, unsigned offset) {
+  core_writer *writer = ptr;
+#ifndef KISSAT_NDEBUG
+  writer->written++;
+#endif
+  int const *p = &PEEK_STACK (*writer->originals, offset);
+  FILE *file = writer->file;
+  while (*p)
+    fprintf (file, "%d ", *p++);
+  fputs ("0\n", file);
+}
+
+static void write_core (kitten *kitten, unsigned reduced, ints *originals,
+                        FILE *file) {
+  KISSAT_assert (originals);
+  fprintf (file, "p cnf %zu %u\n", kitten->evars, reduced);
+  core_writer writer;
+  writer.file = file;
+  writer.originals = originals;
+#ifndef KISSAT_NDEBUG
+  writer.written = 0;
+#endif
+  kitten_traverse_core_ids (kitten, &writer, write_offset);
+  KISSAT_assert (writer.written == reduced);
+}
+
+#ifndef KISSAT_NDEBUG
+
+typedef struct lemma_writer lemma_writer;
+
+struct lemma_writer {
+  FILE *file;
+  uint64_t written;
+};
+
+#endif
+
+static void write_lemma (void *ptr, bool learned, size_t size,
+                         const unsigned *lits) {
+  if (!learned)
+    return;
+  const unsigned *const end = lits + size;
+#ifdef KISSAT_NDEBUG
+  FILE *file = ptr;
+#else
+  lemma_writer *writer = ptr;
+  FILE *file = writer->file;
+  writer->written++;
+#endif
+  for (const unsigned *p = lits; p != end; p++) {
+    const unsigned ulit = *p;
+    const unsigned idx = ulit / 2;
+    const unsigned sign = ulit & 1;
+    KISSAT_assert (idx + 1 <= (unsigned) INT_MAX);
+    int ilit = idx + 1;
+    if (sign)
+      ilit = -ilit;
+    fprintf (file, "%d ", ilit);
+  }
+  fputs ("0\n", file);
+}
+
+static void write_lemmas (kitten *kitten, uint64_t reduced, FILE *file) {
+  void *state;
+#ifdef KISSAT_NDEBUG
+  state = file;
+  (void) reduced;
+#else
+  lemma_writer writer;
+  writer.file = file;
+  writer.written = 0;
+  state = &writer;
+#endif
+  kitten_traverse_core_clauses (kitten, state, write_lemma);
+  KISSAT_assert (writer.written == reduced);
+}
+
+static void print_statistics (statistics statistics) {
+  msg ("conflicts:                 %20" PRIu64,
+       statistics.kitten_conflicts);
+  msg ("decisions:                 %20" PRIu64,
+       statistics.kitten_decisions);
+  msg ("propagations:              %20" PRIu64,
+       statistics.kitten_propagations);
+  msg ("maximum-resident-set-size: %23.2f MB",
+       maximum_resident_set_size ());
+  msg ("process-time:              %23.2f seconds", process_time ());
+}
+
+static volatile int time_limit;
+static volatile kitten *static_kitten;
+
+#define SIGNALS \
+  SIGNAL (SIGABRT) \
+  SIGNAL (SIGBUS) \
+  SIGNAL (SIGINT) \
+  SIGNAL (SIGSEGV) \
+  SIGNAL (SIGTERM)
+
+// clang-format off
+
+#define SIGNAL(SIG) \
+static void (*SIG ## _handler)(int);
+SIGNALS
+#undef SIGNAL
+
+static void (*SIGALRM_handler)(int);
+
+// clang-format on
+
+static void reset_alarm (void) {
+  if (time_limit > 0) {
+    time_limit = 0;
+    time_limit_hit = false;
+  }
+}
+
+static void reset_signals (void) {
+#define SIGNAL(SIG) signal (SIG, SIG##_handler);
+  SIGNALS
+#undef SIGNAL
+  static_kitten = 0;
+}
+
+static const char *signal_name (int sig) {
+#define SIGNAL(SIG) \
+  if (sig == SIG) \
+    return #SIG;
+  SIGNALS
+#undef SIGNAL
+  return "SIGUNKNOWN";
+}
+
+static void catch_signal (int sig) {
+  if (!static_kitten)
+    return;
+  statistics statistics = static_kitten->statistics;
+  reset_signals ();
+  msg ("caught signal %d (%s)", sig, signal_name (sig));
+  print_statistics (statistics);
+  raise (sig);
+}
+
+static void catch_alarm (int sig) {
+  KISSAT_assert (sig == SIGALRM);
+  if (time_limit > 0)
+    time_limit_hit = true;
+  (void) sig;
+}
+
+static void init_signals (kitten *kitten) {
+  static_kitten = kitten;
+#define SIGNAL(SIG) SIG##_handler = signal (SIG, catch_signal);
+  SIGNALS
+#undef SIGNAL
+  if (time_limit > 0) {
+    SIGALRM_handler = signal (SIGALRM, catch_alarm);
+    alarm (time_limit);
+  }
+}
+
+static bool parse_arg (const char *arg, unsigned *res_ptr) {
+  unsigned res = 0;
+  int ch;
+  while ((ch = *arg++)) {
+    if (!isdigit (ch))
+      return false;
+    if (UINT_MAX / 10 < res)
+      return false;
+    res *= 10;
+    const unsigned digit = ch - '0';
+    if (UINT_MAX - digit < res)
+      return false;
+    res += digit;
+  }
+  *res_ptr = res;
+  return true;
+}
+
+static bool parse_lit (const char *arg, int *res_ptr) {
+  int res = 0, sign, ch;
+  if (*arg == '-') {
+    sign = -1;
+    if (*++arg == '0')
+      return false;
+  } else
+    sign = 1;
+  while ((ch = *arg++)) {
+    if (!isdigit (ch))
+      return false;
+    if (INT_MAX / 10 < res)
+      return false;
+    res *= 10;
+    const int digit = ch - '0';
+    if (INT_MAX - digit < res)
+      return false;
+    res += digit;
+  }
+  res *= sign;
+  *res_ptr = res;
+  return true;
+}
+
+#undef logging
+
+int main (int argc, char **argv) {
+  ints assumptions;
+  INIT_STACK (assumptions);
+  const char *dimacs_path = 0;
+  const char *output_path = 0;
+  unsigned shrink = 0;
+  bool witness = true;
+  bool proof = false;
+#ifdef LOGGING
+  bool logging = false;
+#endif
+  for (int i = 1; i < argc; i++) {
+    const char *arg = argv[i];
+    if (!strcmp (arg, "-h"))
+      fputs (usage, stdout), exit (0);
+#ifdef LOGGING
+    else if (!strcmp (arg, "-l"))
+      logging = true;
+#endif
+    else if (!strcmp (arg, "-n"))
+      witness = false;
+    else if (!strcmp (arg, "-p"))
+      proof = true;
+    else if (!strcmp (arg, "-a")) {
+      if (++i == argc)
+        die ("argument to '-a' missing");
+      int lit;
+      if (!parse_lit (argv[i], &lit) || !lit)
+        die ("invalid '-a %s'", argv[i]);
+      PUSH_STACK (assumptions, lit);
+    } else if (!strcmp (arg, "-t")) {
+      if (++i == argc)
+        die ("argument to '-t' missing");
+      if ((time_limit = atoi (argv[i])) <= 0)
+        die ("invalid argument in '-t %s'", argv[i]);
+    } else if (arg[0] == '-' && arg[1] == 'O' && !arg[2])
+      shrink = 1;
+    else if (arg[0] == '-' && arg[1] == 'O' && parse_arg (arg + 2, &shrink))
+      ;
+    else if (*arg == '-')
+      die ("invalid option '%s' (try '-h')", arg);
+    else if (output_path)
+      die ("too many arguments (try '-h')");
+    else if (dimacs_path)
+      output_path = arg;
+    else
+      dimacs_path = arg;
+  }
+  if (proof && !output_path)
+    die ("option '-p' without output file");
+  if (shrink && !EMPTY_STACK (assumptions))
+    die ("can not using shrinking with assumptions");
+  FILE *dimacs_file;
+  bool close_dimacs_file = true;
+  if (!dimacs_path)
+    close_dimacs_file = false, dimacs_file = stdin, dimacs_path = "<stdin>";
+  else if (!(dimacs_file = fopen (dimacs_path, "r")))
+    die ("can not open '%s' for reading", dimacs_path);
+  msg ("Kitten SAT Solver");
+  msg ("Copyright (c) 2021-2024 Armin Biere University of Freiburg");
+  msg ("Copyright (c) 2020-2021 Armin Biere Johannes Kepler University "
+       "Linz");
+  msg ("reading '%s'", dimacs_path);
+  ints originals;
+  INIT_STACK (originals);
+  kitten *kitten;
+  int max_var;
+  {
+    parser parser;
+    parser.path = dimacs_path;
+    parser.lineno = 1;
+    parser.file = dimacs_file;
+#ifdef LOGGING
+    parser.logging = logging;
+#endif
+    kitten = parse (&parser, ((output_path && !proof) ? &originals : 0),
+                    &max_var);
+  }
+  if (close_dimacs_file)
+    fclose (dimacs_file);
+  msg ("parsed DIMACS file in %.2f seconds", process_time ());
+  init_signals (kitten);
+  if (output_path) {
+    msg ("tracking antecedents");
+    kitten_track_antecedents (kitten);
+  }
+  if (!EMPTY_STACK (assumptions)) {
+    msg ("assuming %zu assumptions", SIZE_STACK (assumptions));
+    for (all_stack (int, ilit, assumptions)) {
+      unsigned ulit = 2u * (abs (ilit) - 1) + (ilit < 0);
+      kitten_assume (kitten, ulit);
+    }
+  }
+  int res = kitten_solve (kitten);
+  if (res == 10) {
+    printf ("s SATISFIABLE\n");
+    fflush (stdout);
+    if (witness)
+      print_witness (kitten, max_var);
+  } else if (res == 20) {
+    printf ("s UNSATISFIABLE\n");
+    fflush (stdout);
+    if (output_path) {
+      const unsigned original = kitten->statistics.original;
+      const uint64_t learned = kitten->statistics.learned;
+      unsigned reduced_original, round = 0;
+      uint64_t reduced_learned;
+
+      for (;;) {
+        msg ("computing clausal core of %" PRIu64 " clauses",
+             kitten->statistics.original + kitten->statistics.learned);
+
+        reduced_original =
+            kitten_compute_clausal_core (kitten, &reduced_learned);
+
+        msg ("found %" PRIu64 " core lemmas %.0f%% "
+             "out of %" PRIu64 " learned clauses",
+             reduced_learned, percent (reduced_learned, learned), learned);
+
+        if (!shrink--)
+          break;
+
+        msg ("shrinking round %u", ++round);
+
+        msg ("reduced to %u core clauses %.0f%% "
+             "out of %u original clauses",
+             reduced_original, percent (reduced_original, original),
+             original);
+
+        kitten_shrink_to_clausal_core (kitten);
+        kitten_shuffle_clauses (kitten);
+
+        reset_alarm ();
+        res = kitten_solve (kitten);
+        KISSAT_assert (res == 20);
+      }
+      FILE *output_file = fopen (output_path, "w");
+      if (!output_file)
+        die ("can not open '%s' for writing", output_path);
+      if (proof) {
+        msg ("writing proof to '%s'", output_path);
+        write_lemmas (kitten, reduced_learned, output_file);
+        msg ("written %" PRIu64 " core lemmas %.0f%% of %" PRIu64
+             " learned clauses",
+             reduced_learned, percent (reduced_learned, learned), learned);
+      } else {
+        msg ("writing original clausal core to '%s'", output_path);
+        write_core (kitten, reduced_original, &originals, output_file);
+        msg ("written %u core clauses %.0f%% of %u original clauses",
+             reduced_original, percent (reduced_original, original),
+             original);
+      }
+      fclose (output_file);
+    }
+  } else {
+    fputs ("s UNKNOWN\n", stdout);
+    fflush (stdout);
+  }
+  RELEASE_STACK (originals);
+  RELEASE_STACK (assumptions);
+  statistics statistics = kitten->statistics;
+  reset_signals ();
+  kitten_release (kitten);
+  print_statistics (statistics);
+  msg ("exit %d", res);
+  return res;
+}
+
+#endif
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/kitten.h b/src/sat/kissat/kitten.h
new file mode 100644
index 000000000..2ea9d6d36
--- /dev/null
+++ b/src/sat/kissat/kitten.h
@@ -0,0 +1,59 @@
+#ifndef _kitten_h_INCLUDED
+#define _kitten_h_INCLUDED
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct kitten kitten;
+
+kitten *kitten_init (void);
+void kitten_clear (kitten *);
+void kitten_release (kitten *);
+
+void kitten_track_antecedents (kitten *);
+
+void kitten_shuffle_clauses (kitten *);
+void kitten_flip_phases (kitten *);
+void kitten_randomize_phases (kitten *);
+
+void kitten_assume (kitten *, unsigned lit);
+
+void kitten_clause (kitten *, size_t size, unsigned *);
+void kitten_unit (kitten *, unsigned);
+void kitten_binary (kitten *, unsigned, unsigned);
+
+void kitten_clause_with_id_and_exception (kitten *, unsigned id,
+                                          size_t size, const unsigned *,
+                                          unsigned except);
+
+void kitten_no_ticks_limit (kitten *);
+void kitten_set_ticks_limit (kitten *, uint64_t);
+
+int kitten_solve (kitten *);
+int kitten_status (kitten *);
+
+signed char kitten_value (kitten *, unsigned);
+signed char kitten_fixed (kitten *, unsigned);
+bool kitten_failed (kitten *, unsigned);
+bool kitten_flip_literal (kitten *, unsigned);
+
+unsigned kitten_compute_clausal_core (kitten *, uint64_t *learned);
+void kitten_shrink_to_clausal_core (kitten *);
+
+void kitten_traverse_core_ids (kitten *, void *state,
+                               void (*traverse) (void *state, unsigned id));
+
+void kitten_traverse_core_clauses (kitten *, void *state,
+                                   void (*traverse) (void *state,
+                                                     bool learned, size_t,
+                                                     const unsigned *));
+struct kissat;
+kitten *kitten_embedded (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/kptions.c b/src/sat/kissat/kptions.c
new file mode 100644
index 000000000..8a07b693d
--- /dev/null
+++ b/src/sat/kissat/kptions.c
@@ -0,0 +1,404 @@
+#include "options.h"
+#include "error.h"
+#include "print.h"
+
+#include <ctype.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#ifdef KISSAT_NOPTIONS
+
+static const opt table[] = {
+#define OPTION(N, V, L, H, D) {#N, (int) (V), D},
+    OPTIONS
+#undef OPTION
+};
+
+#else
+
+static const opt table[] = {
+#define OPTION(N, V, L, H, D) {#N, (int) (V), (int) (L), (int) (H), D},
+    OPTIONS
+#undef OPTION
+};
+
+#endif
+
+#define size_table (sizeof table / sizeof *table)
+
+const opt *kissat_options_begin = table;
+const opt *kissat_options_end = table + size_table;
+
+static void check_table_sorted (void) {
+#ifndef KISSAT_NDEBUG
+  opt const *p = 0;
+  for (all_options (o))
+    if (p && strcmp (p->name, o->name) >= 0)
+      kissat_fatal ("option '%s' before option '%s'", p->name, o->name);
+    else
+      p = o;
+#endif
+}
+
+const opt *kissat_options_has (const char *name) {
+  size_t l = 0, m, r = size_table;
+  int tmp;
+  opt const *o;
+  KISSAT_assert (l < r);
+  while (l + 1 < r) {
+    m = l + (r - l) / 2;
+    tmp = strcmp (name, (o = table + m)->name);
+    if (tmp < 0)
+      r = m;
+    else if (tmp > 0)
+      l = m;
+    else
+      return o;
+  }
+  o = table + l;
+  tmp = strcmp (o->name, name);
+  return tmp ? 0 : o;
+}
+
+bool kissat_parse_option_value (const char *val_str, int *res_ptr) {
+  if (!strcmp (val_str, "true")) {
+    *res_ptr = 1;
+    return true;
+  }
+  if (!strcmp (val_str, "false")) {
+    *res_ptr = 0;
+    return true;
+  }
+  int sign = 1;
+  char const *p = val_str;
+  int ch = *p++;
+  if (ch == '-') {
+    sign = -1;
+    ch = *p++;
+  }
+  if (!isdigit (ch)) // at least one digit
+    return false;
+  const unsigned max = -(unsigned) INT_MIN;
+  unsigned res = ch - '0';
+  while (isdigit ((ch = *p++))) {
+    if (max / 10 < res)
+      return false;
+    res *= 10;
+    const unsigned digit = ch - '0';
+    if (max - digit < res)
+      return false;
+    res += digit;
+    if (!res)
+      return false; // invalid '00'
+  }
+  if (ch == 'e') // parse '13e5' etc.
+  {
+    if (!isdigit ((ch = *p++))) // at least one digit
+      return false;
+    if (res) {
+      if (*p) // exactly one digit
+        return false;
+      const unsigned digit = ch - '0';
+      for (unsigned i = 0; i < digit; i++) {
+        if (max / 10 < res)
+          return false;
+        res *= 10;
+      }
+    } else // parse '0^123123123' etc.
+    {
+      while (isdigit (ch = *p++)) // arbitrary many digits
+        ;
+      if (ch)
+        return false;
+    }
+  } else if (ch == '^') // parse '2^11' etc.
+  {
+    const unsigned base = res;
+    if (!isdigit ((ch = *p++))) // at least one digit
+      return false;
+    unsigned exp = ch - '0';
+    if (base < 2) // parse '0^123123123' etc.
+    {
+      while (isdigit (ch = *p++)) // arbitrary many digits
+        ;
+      if (ch)
+        return false;
+    } else if (isdigit (ch = *p++)) // parse '2^30' etc.
+    {
+      if (*p) // at most two digits
+        return false;
+      exp *= 10;
+      const unsigned digit = ch - '0';
+      exp += digit;
+      if (!exp) // '2^00' invalid
+        return false;
+    } else if (ch)
+      return false;
+    if (exp)
+      for (unsigned i = 1; i < exp; i++) {
+        if (max / base < res)
+          return false;
+        res *= base;
+      }
+    else if (base)
+      res = 1; // parse '3^0'
+    else
+      return false; // '0^0' invalid
+  } else if (ch)
+    return false;
+  KISSAT_assert (res <= max);
+  if (sign > 0 && res == max)
+    return false;
+  res *= sign;
+  *res_ptr = res;
+  return true;
+}
+
+const char *kissat_parse_option_name (const char *arg, const char *name) {
+  if (arg[0] != '-' || arg[1] != '-')
+    return 0;
+  char const *p = arg + 2, *q = name;
+  if (p[0] == 'n' && p[1] == 'o' && p[2] == '-')
+    return strcmp (p + 3, name) ? 0 : "0";
+  while (*p && *p == *q)
+    p++, q++;
+  if (*q)
+    return 0;
+  if (*p != '=')
+    return 0;
+  return p + 1;
+}
+
+#ifdef KISSAT_NOPTIONS
+
+void kissat_init_options (void) { check_table_sorted (); }
+
+int kissat_options_get (const char *name) {
+  const opt *const o = kissat_options_has (name);
+  return o ? o->value : 0;
+}
+
+#else
+
+ABC_NAMESPACE_IMPL_END
+
+#include "format.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void kissat_printf_usage (const char *option, const char *fmt, ...) {
+  va_list ap;
+  printf ("  %-26s ", option);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+}
+
+static void check_ranges (void) {
+#define OPTION(N, V, L, H, D) \
+  do { \
+    if ((int) (L) > (int) (H)) \
+      kissat_fatal ("minimum '%d' of option '%s' above maximum '%d'", \
+                    (int) (L), #N, (int) (H)); \
+    if ((int) (V) < (int) (L)) \
+      kissat_fatal ( \
+          "default value '%d' of option '%s' below minimum '%d'", \
+          (int) (V), #N, (int) (L)); \
+    if ((int) (V) > (int) (H)) \
+      kissat_fatal ( \
+          "default value '%d' of option '%s' above maximum '%d'", \
+          (int) (V), #N, (int) (H)); \
+  } while (0);
+  OPTIONS
+#undef OPTION
+}
+
+static void check_name_length (void) {
+#ifndef KISSAT_NDEBUG
+#define OPTION(N, V, L, H, D) \
+  if (strlen (#N) + 1 > kissat_options_max_name_buffer_size) \
+    kissat_fatal ("option '%s' name length %zu " \
+                  "exceeds maximum name buffer size %zu", \
+                  #N, strlen (#N), kissat_options_max_name_buffer_size);
+  OPTIONS
+#undef OPTION
+#endif
+}
+
+int kissat_options_get (const options *options, const char *name) {
+  const int *const p =
+      kissat_options_ref (options, kissat_options_has (name));
+  return p ? *p : 0;
+}
+
+int kissat_options_set_opt (options *options, const opt *o, int value) {
+  KISSAT_assert (kissat_options_begin <= o);
+  KISSAT_assert (o < kissat_options_end);
+  int *p = (int *) options + (o - table);
+  int res = *p;
+  if (value == res)
+    return res;
+  if (value < o->low)
+    value = o->low;
+  if (value > o->high)
+    value = o->high;
+  *p = value;
+  return res;
+}
+
+int kissat_options_set (options *options, const char *name, int value) {
+  const opt *const o = kissat_options_has (name);
+  if (!o)
+    return 0;
+  return kissat_options_set_opt (options, o, value);
+}
+
+void kissat_init_options (options *options) {
+  check_ranges ();
+  check_name_length ();
+  check_table_sorted ();
+#define OPTION(N, V, L, H, D) \
+  KISSAT_assert ((L) <= (V)); \
+  KISSAT_assert ((V) <= (H)); \
+  options->N = (V);
+  OPTIONS
+#undef OPTION
+}
+
+#define FORMAT_OPTION_LIMIT(V) \
+  (((V) == INT_MIN || (V) == INT_MAX) \
+       ? "." \
+       : kissat_format_value (&format, false, (V)))
+
+void kissat_options_usage (void) {
+  check_ranges ();
+  check_name_length ();
+  check_table_sorted ();
+  format format;
+  memset (&format, 0, sizeof format);
+#define OPTION(N, V, L, H, D) \
+  do { \
+    const bool b = ((L) == 0 && (H) == 1); \
+    char buffer[96]; \
+    if (b) \
+      sprintf (buffer, "--%s=<bool>", #N); \
+    else { \
+      const char *low_str = FORMAT_OPTION_LIMIT ((L)); \
+      const char *high_str = FORMAT_OPTION_LIMIT ((H)); \
+      sprintf (buffer, "--%s=%s..%s", #N, low_str, high_str); \
+    } \
+    const char *val_str = kissat_format_value (&format, b, (V)); \
+    kissat_printf_usage (buffer, "%s [%s]", D, val_str); \
+  } while (0);
+  OPTIONS
+#undef OPTION
+}
+
+bool kissat_options_parse_arg (const char *arg, char *buffer,
+                               int *val_ptr) {
+  if (arg[0] != '-' || arg[1] != '-')
+    return false;
+  char const *name = arg + 2, *p = name;
+  int ch;
+  while ((ch = *p) && ch != '=')
+    p++;
+  if (ch) {
+    KISSAT_assert (ch == '=');
+    const size_t len = p - name;
+    if (len >= kissat_options_max_name_buffer_size)
+      return false;
+    memcpy (buffer, name, len);
+    buffer[len] = 0;
+    const opt *const o = kissat_options_has (buffer);
+    if (!o)
+      return false;
+    int value;
+    if (!kissat_parse_option_value (p + 1, &value))
+      return false;
+    if (value < o->low || value > o->high)
+      return false;
+    *val_ptr = value;
+  } else {
+    int value = 0;
+    if (arg[2] == 'n' && arg[3] == 'o' && arg[4] == '-') {
+      name += 3;
+      const opt *const o = kissat_options_has (name);
+      if (!o || o->low > (value = 0))
+        return false;
+    } else {
+      const opt *const o = kissat_options_has (name);
+      if (!o || o->high < (value = 1))
+        return false;
+    }
+    KISSAT_assert (strlen (name) < kissat_options_max_name_buffer_size);
+    strcpy (buffer, name);
+    *val_ptr = value;
+  }
+  return true;
+}
+
+static bool ignore_embedded_option_for_fuzzing (const char *name) {
+#ifdef EMBEDDED
+  if (!strcmp (name, "embedded"))
+    return true;
+#endif
+#ifndef KISSAT_QUIET
+  if (!strcmp (name, "quiet"))
+    return true;
+#endif
+  (void) name;
+  return false;
+}
+
+void kissat_print_embedded_option_list () {
+#define OPTION(N, V, L, H, D) \
+  if (!ignore_embedded_option_for_fuzzing (#N)) \
+    printf ("c --%s=%d\n", #N, (int) (V));
+  OPTIONS
+#undef OPTION
+}
+
+static bool ignore_range_option_for_fuzzing (const char *name) {
+#ifdef LOGGING
+  if (!strcmp (name, "log"))
+    return true;
+#endif
+#ifdef EMBEDDED
+  if (!strcmp (name, "embedded"))
+    return true;
+#endif
+#ifndef KISSAT_QUIET
+  if (!strcmp (name, "quiet"))
+    return true;
+#endif
+  if (!strcmp (name, "reduce"))
+    return true;
+  if (!strcmp (name, "reluctant"))
+    return true;
+  if (!strcmp (name, "rephase"))
+    return true;
+  if (!strcmp (name, "restart"))
+    return true;
+  return false;
+}
+
+void kissat_print_option_range_list (void) {
+#define OPTION(N, V, L, H, D) \
+  if (!ignore_range_option_for_fuzzing (#N)) \
+    printf ("%s %d %d %d\n", #N, (int) (L), (int) (V), (int) (H));
+  OPTIONS
+#undef OPTION
+}
+
+#endif
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/krite.c b/src/sat/kissat/krite.c
new file mode 100644
index 000000000..04c9a810d
--- /dev/null
+++ b/src/sat/kissat/krite.c
@@ -0,0 +1,49 @@
+#include "krite.h"
+#include "inline.h"
+#include "internal.h"
+#include "watch.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_write_dimacs (kissat *solver, FILE *file) {
+  size_t imported = SIZE_STACK (solver->import);
+  if (imported)
+    imported--;
+  fprintf (file, "p cnf %zu %" PRIu64 "\n", imported, BINIRR_CLAUSES);
+  KISSAT_assert (solver->watching);
+  if (solver->watching) {
+    for (all_literals (ilit))
+      for (all_binary_blocking_watches (watch, WATCHES (ilit)))
+        if (watch.type.binary) {
+          const unsigned iother = watch.binary.lit;
+          if (iother < ilit)
+            continue;
+          const int elit = kissat_export_literal (solver, ilit);
+          const int eother = kissat_export_literal (solver, iother);
+          fprintf (file, "%d %d 0\n", elit, eother);
+        }
+  } else {
+    for (all_literals (ilit))
+      for (all_binary_large_watches (watch, WATCHES (ilit)))
+        if (watch.type.binary) {
+          const unsigned iother = watch.binary.lit;
+          if (iother < ilit)
+            continue;
+          const int elit = kissat_export_literal (solver, ilit);
+          const int eother = kissat_export_literal (solver, iother);
+          fprintf (file, "%d %d 0\n", elit, eother);
+        }
+  }
+  for (all_clauses (c))
+    if (!c->garbage && !c->redundant) {
+      for (all_literals_in_clause (ilit, c)) {
+        const int elit = kissat_export_literal (solver, ilit);
+        fprintf (file, "%d ", elit);
+      }
+      fputs ("0\n", file);
+    }
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/krite.h b/src/sat/kissat/krite.h
new file mode 100644
index 000000000..3b6fe6bb4
--- /dev/null
+++ b/src/sat/kissat/krite.h
@@ -0,0 +1,14 @@
+#ifndef _krite_h_INCLUDED
+#define _krite_h_INCLUDED
+
+#include <stdio.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+void kissat_write_dimacs (struct kissat *, FILE *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/kucky.c b/src/sat/kissat/kucky.c
new file mode 100644
index 000000000..3e3121b2d
--- /dev/null
+++ b/src/sat/kissat/kucky.c
@@ -0,0 +1,397 @@
+#include "lucky.h"
+#include "analyze.h"
+#include "backtrack.h"
+#include "decide.h"
+#include "inline.h"
+#include "internal.h"
+#include "print.h"
+#include "proprobe.h"
+#include "report.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static bool no_all_negative_clauses (struct kissat *solver) {
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+  for (all_clauses (c)) {
+    if (last_irredundant && last_irredundant < c)
+      break;
+    if (c->redundant)
+      continue;
+    if (c->garbage)
+      continue;
+    for (all_literals_in_clause (lit, c))
+      if (!NEGATED (lit) && VALUE (lit) >= 0)
+        goto CONTINUE_WITH_NEXT_CLAUSE;
+    kissat_verbose (solver, "found all negative large clause");
+    return false;
+  CONTINUE_WITH_NEXT_CLAUSE:;
+  }
+  KISSAT_assert (solver->watching);
+  for (all_variables (idx)) {
+    if (!ACTIVE (idx))
+      continue;
+    const unsigned lit = LIT (idx);
+    const unsigned not_lit = NOT (lit);
+    for (all_binary_blocking_watches (watch, WATCHES (not_lit))) {
+      if (!watch.type.binary)
+        continue;
+      const unsigned other = watch.binary.lit;
+      if (NEGATED (other) && ACTIVE (IDX (other))) {
+        kissat_verbose (solver, "found all negative binary clause");
+        return false;
+      }
+    }
+  }
+  kissat_message (solver, "lucky no all-negative clause");
+  return true;
+}
+
+static bool no_all_positive_clauses (struct kissat *solver) {
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+  for (all_clauses (c)) {
+    if (last_irredundant && last_irredundant < c)
+      break;
+    if (c->redundant)
+      continue;
+    if (c->garbage)
+      continue;
+    for (all_literals_in_clause (lit, c))
+      if (NEGATED (lit) && VALUE (lit) >= 0)
+        goto CONTINUE_WITH_NEXT_CLAUSE;
+    kissat_verbose (solver, "found all positive large clause");
+    return false;
+  CONTINUE_WITH_NEXT_CLAUSE:;
+  }
+  KISSAT_assert (solver->watching);
+  for (all_variables (idx)) {
+    if (!ACTIVE (idx))
+      continue;
+    const unsigned lit = LIT (idx);
+    for (all_binary_blocking_watches (watch, WATCHES (lit))) {
+      if (!watch.type.binary)
+        continue;
+      const unsigned other = watch.binary.lit;
+      if (!NEGATED (other) && ACTIVE (IDX (other))) {
+        kissat_verbose (solver, "found all positive binary clause");
+        return false;
+      }
+    }
+  }
+  kissat_message (solver, "lucky no all-positive clause");
+  return true;
+}
+
+static int forward_false_satisfiable (struct kissat *solver) {
+  KISSAT_assert (!solver->level);
+#ifndef KISSAT_QUIET
+  unsigned conflicts = 0;
+#endif
+  for (all_stack (import, import, solver->import)) {
+    if (!import.imported)
+      continue;
+    if (import.eliminated)
+      continue;
+    const unsigned lit = import.lit;
+    const unsigned idx = IDX (lit);
+    if (!ACTIVE (idx))
+      continue;
+    if (VALUE (lit))
+      continue;
+    const unsigned not_lit = NOT (lit);
+    kissat_internal_assume (solver, not_lit);
+    clause *c = kissat_probing_propagate (solver, 0, true);
+    if (!c)
+      continue;
+#ifndef KISSAT_QUIET
+    conflicts++;
+#endif
+    if (solver->level > 1) {
+      kissat_backtrack_without_updating_phases (solver, solver->level - 1);
+      kissat_internal_assume (solver, lit);
+      clause *d = kissat_probing_propagate (solver, 0, true);
+      if (!d)
+        continue;
+      kissat_verbose (solver,
+                      "inconsistency after %u conflicts "
+                      "forward assigning %u variables to false",
+                      conflicts, solver->level);
+      kissat_backtrack_without_updating_phases (solver, 0);
+      return 0;
+    } else {
+      LOG ("failed literal %s", LOGLIT (not_lit));
+      kissat_analyze (solver, c);
+      KISSAT_assert (!solver->level);
+      clause *d = kissat_probing_propagate (solver, 0, true);
+      if (d) {
+        kissat_analyze (solver, d);
+        KISSAT_assert (solver->inconsistent);
+        kissat_verbose (solver,
+                        "lucky inconsistency forward assigning to false");
+        return 20;
+      }
+    }
+  }
+
+  kissat_message (solver, "lucky in forward setting literals to false");
+  return 10;
+}
+
+static int forward_true_satisfiable (struct kissat *solver) {
+  KISSAT_assert (!solver->level);
+#ifndef KISSAT_QUIET
+  unsigned conflicts = 0;
+#endif
+  for (all_stack (import, import, solver->import)) {
+    if (!import.imported)
+      continue;
+    if (import.eliminated)
+      continue;
+    const unsigned lit = import.lit;
+    const unsigned idx = IDX (lit);
+    if (!ACTIVE (idx))
+      continue;
+    if (VALUE (lit))
+      continue;
+    kissat_internal_assume (solver, lit);
+    clause *c = kissat_probing_propagate (solver, 0, true);
+    if (!c)
+      continue;
+#ifndef KISSAT_QUIET
+    conflicts++;
+#endif
+    if (solver->level > 1) {
+      kissat_backtrack_without_updating_phases (solver, solver->level - 1);
+      const unsigned not_lit = NOT (lit);
+      kissat_internal_assume (solver, not_lit);
+      clause *d = kissat_probing_propagate (solver, 0, true);
+      if (!d)
+        continue;
+      kissat_verbose (solver,
+                      "inconsistency after %u conflicts "
+                      "forward assigning %u variables to true",
+                      conflicts, solver->level);
+      kissat_backtrack_without_updating_phases (solver, 0);
+      return 0;
+    } else {
+      LOG ("failed literal %s", LOGLIT (lit));
+      kissat_analyze (solver, c);
+      KISSAT_assert (!solver->level);
+      clause *d = kissat_probing_propagate (solver, 0, true);
+      if (d) {
+        kissat_analyze (solver, d);
+        KISSAT_assert (solver->inconsistent);
+        kissat_verbose (solver,
+                        "lucky inconsistency forward assigning to true");
+        return 20;
+      }
+    }
+  }
+  kissat_message (solver, "lucky in forward setting literals to true");
+  return 10;
+}
+
+static int backward_false_satisfiable (struct kissat *solver) {
+  KISSAT_assert (!solver->level);
+#ifndef KISSAT_QUIET
+  unsigned conflicts = 0;
+#endif
+  import *begin = BEGIN_STACK (solver->import);
+  import *end = END_STACK (solver->import);
+  import *p = end;
+  while (p != begin) {
+    const import import = *--p;
+    if (!import.imported)
+      continue;
+    if (import.eliminated)
+      continue;
+    const unsigned lit = import.lit;
+    const unsigned idx = IDX (lit);
+    if (!ACTIVE (idx))
+      continue;
+    if (VALUE (lit))
+      continue;
+    const unsigned not_lit = NOT (lit);
+    kissat_internal_assume (solver, not_lit);
+    clause *c = kissat_probing_propagate (solver, 0, true);
+    if (!c)
+      continue;
+#ifndef KISSAT_QUIET
+    conflicts++;
+#endif
+    if (solver->level > 1) {
+      kissat_backtrack_without_updating_phases (solver, solver->level - 1);
+      kissat_internal_assume (solver, lit);
+      clause *d = kissat_probing_propagate (solver, 0, true);
+      if (!d)
+        continue;
+      kissat_verbose (solver,
+                      "inconsistency after %u conflicts "
+                      "backward assigning %u variables to false",
+                      conflicts, solver->level);
+      kissat_backtrack_without_updating_phases (solver, 0);
+      return 0;
+    } else {
+      LOG ("failed literal %s", LOGLIT (not_lit));
+      kissat_analyze (solver, c);
+      KISSAT_assert (!solver->level);
+      clause *d = kissat_probing_propagate (solver, 0, true);
+      if (d) {
+        kissat_analyze (solver, d);
+        KISSAT_assert (solver->inconsistent);
+        kissat_verbose (solver,
+                        "lucky inconsistency backward assigning to false");
+        return 20;
+      }
+    }
+  }
+  kissat_message (solver, "lucky in backward setting literals to false");
+  return 10;
+}
+
+static int backward_true_satisfiable (struct kissat *solver) {
+  KISSAT_assert (!solver->level);
+#ifndef KISSAT_QUIET
+  unsigned conflicts = 0;
+#endif
+  import *begin = BEGIN_STACK (solver->import);
+  import *end = END_STACK (solver->import);
+  import *p = end;
+  while (p != begin) {
+    const import import = *--p;
+    if (!import.imported)
+      continue;
+    if (import.eliminated)
+      continue;
+    const unsigned lit = import.lit;
+    const unsigned idx = IDX (lit);
+    if (!ACTIVE (idx))
+      continue;
+    if (VALUE (lit))
+      continue;
+    kissat_internal_assume (solver, lit);
+    clause *c = kissat_probing_propagate (solver, 0, true);
+    if (!c)
+      continue;
+#ifndef KISSAT_QUIET
+    conflicts++;
+#endif
+    if (solver->level > 1) {
+      kissat_backtrack_without_updating_phases (solver, solver->level - 1);
+      const unsigned not_lit = NOT (lit);
+      kissat_internal_assume (solver, not_lit);
+      clause *d = kissat_probing_propagate (solver, 0, true);
+      if (!d)
+        continue;
+      kissat_verbose (solver,
+                      "inconsistency after %u conflicts "
+                      "backward assigning %u variables to true",
+                      conflicts, solver->level);
+      kissat_backtrack_without_updating_phases (solver, 0);
+      return 0;
+    } else {
+      LOG ("failed literal %s", LOGLIT (lit));
+      kissat_analyze (solver, c);
+      KISSAT_assert (!solver->level);
+      clause *d = kissat_probing_propagate (solver, 0, true);
+      if (d) {
+        kissat_analyze (solver, d);
+        KISSAT_assert (solver->inconsistent);
+        kissat_verbose (solver,
+                        "lucky inconsistency backward assigning to true");
+        return 20;
+      }
+    }
+  }
+  kissat_message (solver, "lucky in backward setting literals to true");
+  return 10;
+}
+
+int kissat_lucky (struct kissat *solver) {
+
+  if (solver->inconsistent)
+    return 0;
+
+  if (!GET_OPTION (lucky))
+    return 0;
+
+  START (lucky);
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->probing);
+  solver->probing = true;
+  KISSAT_assert (kissat_propagated (solver));
+
+  int res = 0;
+
+  if (no_all_negative_clauses (solver)) {
+    for (all_variables (idx)) {
+      if (!ACTIVE (idx))
+        continue;
+      const unsigned lit = LIT (idx);
+      if (VALUE (lit))
+        continue;
+      kissat_internal_assume (solver, lit);
+#ifndef KISSAT_NDEBUG
+      clause *c =
+#endif
+          kissat_probing_propagate (solver, 0, true);
+      KISSAT_assert (!c);
+    }
+    kissat_verbose (solver, "set all variables to true");
+    KISSAT_assert (kissat_propagated (solver));
+    KISSAT_assert (!solver->unassigned);
+    res = 10;
+  }
+
+  if (!res && no_all_positive_clauses (solver)) {
+    for (all_variables (idx)) {
+      if (!ACTIVE (idx))
+        continue;
+      const unsigned lit = LIT (idx);
+      if (VALUE (lit))
+        continue;
+      const unsigned not_lit = NOT (lit);
+      kissat_internal_assume (solver, not_lit);
+#ifndef KISSAT_NDEBUG
+      clause *c =
+#endif
+          kissat_probing_propagate (solver, 0, true);
+      KISSAT_assert (!c);
+    }
+    kissat_verbose (solver, "set all variables to false");
+    KISSAT_assert (kissat_propagated (solver));
+    KISSAT_assert (!solver->unassigned);
+    res = 10;
+  }
+
+  const unsigned active_before = solver->active;
+
+  if (!res)
+    res = forward_false_satisfiable (solver);
+
+  if (!res)
+    res = forward_true_satisfiable (solver);
+
+  if (!res)
+    res = backward_false_satisfiable (solver);
+
+  if (!res)
+    res = backward_true_satisfiable (solver);
+
+  const unsigned active_after = solver->active;
+  const unsigned units = active_before - active_after;
+
+  if (!res && units)
+    kissat_message (solver, "lucky %u units", units);
+
+#ifndef KISSAT_QUIET
+  bool success = res || units;
+#endif
+  KISSAT_assert (solver->probing);
+  solver->probing = false;
+  REPORT (!success, 'l');
+  STOP (lucky);
+
+  return res;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/learn.c b/src/sat/kissat/learn.c
new file mode 100644
index 000000000..401fc0b56
--- /dev/null
+++ b/src/sat/kissat/learn.c
@@ -0,0 +1,214 @@
+#include "learn.h"
+#include "backtrack.h"
+#include "inline.h"
+#include "reluctant.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static unsigned backjump_limit (struct kissat *solver) {
+#ifdef KISSAT_NOPTIONS
+  (void) solver;
+#endif
+  return GET_OPTION (chrono) ? (unsigned) GET_OPTION (chronolevels)
+                             : UINT_MAX;
+}
+
+unsigned kissat_determine_new_level (kissat *solver, unsigned jump) {
+  KISSAT_assert (solver->level);
+  const unsigned back = solver->level - 1;
+  KISSAT_assert (jump <= back);
+
+  const unsigned delta = back - jump;
+  const unsigned limit = backjump_limit (solver);
+
+  unsigned res;
+
+  if (!delta) {
+    res = jump;
+    LOG ("using identical backtrack and jump level %u", res);
+  } else if (delta > limit) {
+    res = back;
+    LOG ("backjumping over %u levels (%u - %u) considered inefficient",
+         delta, back, jump);
+    LOG ("backtracking chronologically to backtrack level %u", res);
+    INC (chronological);
+  } else {
+    res = jump;
+    LOG ("backjumping over %u levels (%u - %u) considered efficient", delta,
+         back, jump);
+    LOG ("backjumping non-chronologically to jump level %u", res);
+  }
+  return res;
+}
+
+static void learn_unit (kissat *solver, unsigned not_uip) {
+  KISSAT_assert (not_uip == PEEK_STACK (solver->clause, 0));
+  LOG ("learned unit clause %s triggers iteration", LOGLIT (not_uip));
+  const unsigned new_level = kissat_determine_new_level (solver, 0);
+  kissat_backtrack_after_conflict (solver, new_level);
+  kissat_learned_unit (solver, not_uip);
+  if (!solver->probing) {
+    solver->iterating = true;
+    INC (iterations);
+  }
+}
+
+static void learn_binary (kissat *solver, unsigned not_uip) {
+  const unsigned other = PEEK_STACK (solver->clause, 1);
+  const unsigned jump_level = LEVEL (other);
+  const unsigned new_level =
+      kissat_determine_new_level (solver, jump_level);
+  kissat_backtrack_after_conflict (solver, new_level);
+#ifndef KISSAT_NDEBUG
+  const reference ref =
+#endif
+      kissat_new_redundant_clause (solver, 1);
+  KISSAT_assert (ref == INVALID_REF);
+  kissat_assign_binary (solver, not_uip, other);
+}
+
+static void insert_last_learned (kissat *solver, reference ref) {
+  const reference *const end =
+      solver->last_learned + GET_OPTION (eagersubsume);
+  reference prev = ref;
+  for (reference *p = solver->last_learned; p != end; p++) {
+    reference tmp = *p;
+    *p = prev;
+    prev = tmp;
+  }
+}
+
+static reference learn_reference (kissat *solver, unsigned not_uip,
+                                  unsigned glue) {
+  KISSAT_assert (solver->level > 1);
+  KISSAT_assert (SIZE_STACK (solver->clause) > 2);
+  unsigned *lits = BEGIN_STACK (solver->clause);
+  KISSAT_assert (lits[0] == not_uip);
+  unsigned *q = lits + 1;
+  unsigned jump_lit = *q;
+  unsigned jump_level = LEVEL (jump_lit);
+  const unsigned *const end = END_STACK (solver->clause);
+  const unsigned backtrack_level = solver->level - 1;
+  assigned *all_assigned = solver->assigned;
+  for (unsigned *p = lits + 2; p != end; p++) {
+    const unsigned lit = *p;
+    const unsigned idx = IDX (lit);
+    const unsigned level = all_assigned[idx].level;
+    if (jump_level >= level)
+      continue;
+    jump_level = level;
+    jump_lit = lit;
+    q = p;
+    if (level == backtrack_level)
+      break;
+  }
+  *q = lits[1];
+  lits[1] = jump_lit;
+  const reference ref = kissat_new_redundant_clause (solver, glue);
+  KISSAT_assert (ref != INVALID_REF);
+  clause *c = kissat_dereference_clause (solver, ref);
+  c->used = MAX_USED;
+  const unsigned new_level =
+      kissat_determine_new_level (solver, jump_level);
+  kissat_backtrack_after_conflict (solver, new_level);
+  kissat_assign_reference (solver, not_uip, ref, c);
+  return ref;
+}
+
+void kissat_update_learned (kissat *solver, unsigned glue, unsigned size) {
+  KISSAT_assert (!solver->probing);
+  INC (clauses_learned);
+  LOG ("learned[%" PRIu64 "] clause glue %u size %u", GET (clauses_learned),
+       glue, size);
+  if (solver->stable)
+    kissat_tick_reluctant (&solver->reluctant);
+  ADD (literals_learned, size);
+#ifndef KISSAT_QUIET
+  UPDATE_AVERAGE (size, size);
+#endif
+  UPDATE_AVERAGE (fast_glue, glue);
+  UPDATE_AVERAGE (slow_glue, glue);
+}
+
+static void flush_last_learned (kissat *solver) {
+  reference *q = solver->last_learned;
+  const reference *const end = q + GET_OPTION (eagersubsume), *p = q;
+  while (p != end) {
+    reference ref = *p++;
+    if (ref != INVALID_REF)
+      *q++ = ref;
+  }
+  while (q != end)
+    *q++ = INVALID_REF;
+}
+
+static void eagerly_subsume_last_learned (kissat *solver) {
+  value *marks = solver->marks;
+  for (all_stack (unsigned, lit, solver->clause)) {
+    KISSAT_assert (!marks[lit]);
+    marks[lit] = 1;
+  }
+  unsigned clause_size = SIZE_STACK (solver->clause);
+  unsigned subsumed = 0;
+  reference *p = solver->last_learned;
+  const reference *const end = p + GET_OPTION (eagersubsume);
+  while (p != end) {
+    reference ref = *p++;
+    if (ref == INVALID_REF)
+      continue;
+    clause *c = kissat_dereference_clause (solver, ref);
+    if (c->garbage)
+      continue;
+    if (!c->redundant)
+      continue;
+    unsigned c_size = c->size;
+    if (c_size <= clause_size)
+      continue;
+    LOGCLS2 (c, "trying to eagerly subsume");
+    unsigned needed = clause_size;
+    unsigned remain = c_size;
+    for (all_literals_in_clause (lit, c)) {
+      if (marks[lit] && !--needed)
+        break;
+      else if (--remain < needed)
+        break;
+    }
+    if (needed)
+      continue;
+    LOGCLS (c, "eagerly subsumed");
+    kissat_mark_clause_as_garbage (solver, c);
+    p[-1] = INVALID_REF;
+    subsumed++;
+    INC (eagerly_subsumed);
+  }
+  for (all_stack (unsigned, lit, solver->clause))
+    marks[lit] = 0;
+  if (subsumed)
+    flush_last_learned (solver);
+}
+
+void kissat_learn_clause (kissat *solver) {
+  const unsigned not_uip = PEEK_STACK (solver->clause, 0);
+  const unsigned size = SIZE_STACK (solver->clause);
+  const size_t glue = SIZE_STACK (solver->levels);
+  KISSAT_assert (glue <= UINT_MAX);
+  if (!solver->probing)
+    kissat_update_learned (solver, glue, size);
+  KISSAT_assert (size > 0);
+  reference ref = INVALID_REF;
+  if (size == 1)
+    learn_unit (solver, not_uip);
+  else if (size == 2)
+    learn_binary (solver, not_uip);
+  else
+    ref = learn_reference (solver, not_uip, glue);
+  if (GET_OPTION (eagersubsume)) {
+    eagerly_subsume_last_learned (solver);
+    if (ref != INVALID_REF)
+      insert_last_learned (solver, ref);
+  }
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/learn.h b/src/sat/kissat/learn.h
new file mode 100644
index 000000000..42c3bad5e
--- /dev/null
+++ b/src/sat/kissat/learn.h
@@ -0,0 +1,15 @@
+#ifndef _learn_h_INCLUDED
+#define _learn_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_learn_clause (struct kissat *);
+void kissat_update_learned (struct kissat *, unsigned glue, unsigned size);
+unsigned kissat_determine_new_level (struct kissat *, unsigned jump);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/literal.h b/src/sat/kissat/literal.h
new file mode 100644
index 000000000..9014e5dd4
--- /dev/null
+++ b/src/sat/kissat/literal.h
@@ -0,0 +1,41 @@
+#ifndef _literal_h_INCLUDED
+#define _literal_h_INCLUDED
+
+#include <limits.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define LD_MAX_VAR 30u
+#define LD_MAX_LIT (1 + LD_MAX_VAR)
+
+#define EXTERNAL_MAX_VAR ((1 << LD_MAX_VAR) - 1)
+#define INTERNAL_MAX_VAR ((1u << LD_MAX_VAR) - 2)
+#define INTERNAL_MAX_LIT (2 * INTERNAL_MAX_VAR + 1)
+
+#define ILLEGAL_LIT ((1u << LD_MAX_LIT) - 1)
+
+#define INVALID_IDX UINT_MAX
+#define INVALID_LIT UINT_MAX
+
+#define VALID_INTERNAL_INDEX(IDX) ((IDX) < VARS)
+
+#define VALID_INTERNAL_LITERAL(LIT) ((LIT) < LITS)
+
+#define VALID_EXTERNAL_LITERAL(LIT) \
+  ((LIT) && ((LIT) != INT_MIN) && ABS (LIT) <= EXTERNAL_MAX_VAR)
+
+#define IDX(LIT) \
+  (KISSAT_assert (VALID_INTERNAL_LITERAL (LIT)), (((unsigned) (LIT)) >> 1))
+
+#define LIT(IDX) (KISSAT_assert (VALID_INTERNAL_INDEX (IDX)), ((IDX) << 1))
+
+#define NOT(LIT) (KISSAT_assert (VALID_INTERNAL_LITERAL (LIT)), ((LIT) ^ 1u))
+
+#define NEGATED(LIT) (KISSAT_assert (VALID_INTERNAL_LITERAL (LIT)), ((LIT) & 1u))
+
+#define STRIP(LIT) (KISSAT_assert (VALID_INTERNAL_LITERAL (LIT)), ((LIT) & ~1u))
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/logging.c b/src/sat/kissat/logging.c
new file mode 100644
index 000000000..6955873fe
--- /dev/null
+++ b/src/sat/kissat/logging.c
@@ -0,0 +1,458 @@
+#include "global.h"
+
+#if defined(LOGGING) && !defined(KISSAT_QUIET)
+
+#include "colors.h"
+#include "inline.h"
+
+#include <stdarg.h>
+#include <string.h>
+
+static void begin_logging (kissat *solver, const char *prefix,
+                           const char *fmt, va_list *ap) {
+  TERMINAL (stdout, 1);
+  KISSAT_assert (GET_OPTION (log));
+  fputs (solver->prefix, stdout);
+  COLOR (MAGENTA);
+  printf ("%s %u ", prefix, solver->level);
+  vprintf (fmt, *ap);
+}
+
+static void end_logging (void) {
+  TERMINAL (stdout, 1);
+  fputc ('\n', stdout);
+  COLOR (NORMAL);
+  fflush (stdout);
+}
+
+void kissat_begin_logging (kissat *solver, const char *prefix,
+                           const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+}
+
+void kissat_end_logging (void) { end_logging (); }
+
+void kissat_log_msg (kissat *solver, const char *prefix, const char *fmt,
+                     ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  end_logging ();
+}
+
+static void append_sprintf (char *str, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  const size_t len = strlen (str);
+  vsprintf (str + len, fmt, ap);
+  va_end (ap);
+}
+
+const char *kissat_log_repr (kissat *solver, unsigned lit,
+                             const unsigned *repr) {
+  KISSAT_assert (solver);
+  char *res = kissat_next_format_string (&solver->format);
+  sprintf (res, "%u", lit);
+  if (!solver->compacting && GET_OPTION (log) > 1)
+    append_sprintf (res, "(%d)", kissat_export_literal (solver, lit));
+  if (repr && repr[lit] != lit) {
+    strcat (res, "[");
+    unsigned repr_lit = repr[lit];
+    append_sprintf (res, "%u", repr_lit);
+    if (!solver->compacting && GET_OPTION (log) > 1)
+      append_sprintf (res, "(%d)",
+                      kissat_export_literal (solver, repr_lit));
+    strcat (res, "]");
+  }
+  if (!solver->compacting && GET_OPTION (log) > 1 && solver->values) {
+    const value value = VALUE (lit);
+    if (value) {
+      append_sprintf (res, "=%d", value);
+      if (solver->assigned)
+        append_sprintf (res, "@%u", LEVEL (lit));
+    }
+  }
+  KISSAT_assert (strlen (res) < FORMAT_STRING_SIZE);
+  return res;
+}
+
+const char *kissat_log_lit (kissat *solver, unsigned lit) {
+  return kissat_log_repr (solver, lit, 0);
+}
+
+const char *kissat_log_var (kissat *solver, unsigned idx) {
+  KISSAT_assert (solver);
+  char *res = kissat_next_format_string (&solver->format);
+  const unsigned lit = LIT (idx);
+  sprintf (res, "variable %u (literal %s)", idx, LOGLIT (lit));
+  KISSAT_assert (strlen (res) < FORMAT_STRING_SIZE);
+  return res;
+}
+
+static void log_lits (kissat *solver, size_t size, const unsigned *lits,
+                      const unsigned *counts) {
+  for (size_t i = 0; i < size; i++) {
+    const unsigned lit = lits[i];
+    fputc (' ', stdout);
+    fputs (LOGLIT (lit), stdout);
+    if (counts)
+      printf ("#%u", counts[lit]);
+  }
+}
+
+static void log_reprs (kissat *solver, size_t size, const unsigned *lits,
+                       const unsigned *repr) {
+  for (size_t i = 0; i < size; i++) {
+    const unsigned lit = lits[i];
+    fputc (' ', stdout);
+    fputs (LOGREPR (lit, repr), stdout);
+  }
+}
+
+void kissat_log_lits (kissat *solver, const char *prefix, size_t size,
+                      const unsigned *const lits, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" size %zu clause", size);
+  log_lits (solver, size, lits, 0);
+  end_logging ();
+}
+
+void kissat_log_litset (kissat *solver, const char *prefix, size_t size,
+                        const unsigned *const lits, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" size %zu literal set {", size);
+  log_lits (solver, size, lits, 0);
+  fputs (" }", stdout);
+  end_logging ();
+}
+
+void kissat_log_litpart (kissat *solver, const char *prefix, size_t size,
+                         const unsigned *const lits, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  size_t classes = 0;
+  for (size_t i = 0; i < size; i++)
+    if (lits[i] == INVALID_LIT)
+      classes++;
+  printf (" %zu literals %zu classes literal partition [", size - classes,
+          classes);
+  for (size_t i = 0; i < size; i++) {
+    const unsigned lit = lits[i];
+    if (lit == INVALID_LIT) {
+      if (i + 1 != size)
+        fputs (" |", stdout);
+    } else {
+      fputc (' ', stdout);
+      fputs (LOGLIT (lit), stdout);
+    }
+  }
+  fputs (" ]", stdout);
+  end_logging ();
+}
+
+void kissat_log_counted_ref_lits (kissat *solver, const char *prefix,
+                                  reference ref, size_t size,
+                                  const unsigned *const lits,
+                                  const unsigned *const counts,
+                                  const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" size %zu clause", size);
+  printf ("[%u]", ref);
+  log_lits (solver, size, lits, counts);
+  end_logging ();
+}
+
+void kissat_log_counted_lits (kissat *solver, const char *prefix,
+                              size_t size, const unsigned *const lits,
+                              const unsigned *const counts, const char *fmt,
+                              ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" size %zu literals", size);
+  log_lits (solver, size, lits, counts);
+  end_logging ();
+}
+
+void kissat_log_resolvent (kissat *solver, const char *prefix,
+                           const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  const size_t size = SIZE_STACK (solver->resolvent);
+  printf (" size %zu resolvent", size);
+  const unsigned *const lits = BEGIN_STACK (solver->resolvent);
+  log_lits (solver, size, lits, 0);
+  end_logging ();
+}
+
+void kissat_log_ints (kissat *solver, const char *prefix, size_t size,
+                      const int *const lits, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" size %zu external literals clause", size);
+  for (size_t i = 0; i < size; i++)
+    printf (" %d", lits[i]);
+  end_logging ();
+}
+
+void kissat_log_unsigneds (kissat *solver, const char *prefix, size_t size,
+                           const unsigned *const lits, const char *fmt,
+                           ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" size %zu clause", size);
+  for (size_t i = 0; i < size; i++)
+    printf (" %u", lits[i]);
+  end_logging ();
+}
+
+static void log_gate (kissat *solver, size_t id, const char *type,
+                      const char *op, const char *empty_rhs_constant,
+                      const unsigned *repr, unsigned lhs, size_t size,
+                      const unsigned *rhs) {
+  printf (" arity %zu %s gate", size, type);
+  if (id != INVALID_GATE_ID)
+    printf ("[%zu]", id);
+  fputc (' ', stdout);
+  if (lhs == INVALID_LIT)
+    fputs ("<LHS>", stdout);
+  else
+    fputs (LOGREPR (lhs, repr), stdout);
+  if (size)
+    for (size_t i = 0; i < size; i++) {
+      fputc (' ', stdout);
+      fputs (i ? op : ":=", stdout);
+      fputc (' ', stdout);
+      fputs (LOGREPR (rhs[i], repr), stdout);
+    }
+  else {
+    fputs (" := ", stdout);
+    fputs (empty_rhs_constant, stdout);
+  }
+}
+
+void kissat_log_and_gate (kissat *solver, const char *prefix, size_t id,
+                          unsigned *repr, unsigned lhs, size_t size,
+                          const unsigned *rhs, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  log_gate (solver, id, "AND", "&", "<true>", repr, lhs, size, rhs);
+  end_logging ();
+}
+
+void kissat_log_xor_gate (kissat *solver, const char *prefix, size_t id,
+                          unsigned *repr, unsigned lhs, size_t size,
+                          const unsigned *rhs, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  log_gate (solver, id, "XOR", "^", "<false>", repr, lhs, size, rhs);
+  end_logging ();
+}
+
+void kissat_log_ite_gate (kissat *solver, const char *prefix, size_t id,
+                          unsigned *repr, unsigned lhs, unsigned cond,
+                          unsigned then_lit, unsigned else_lit,
+                          const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" ITE gate");
+  if (id != INVALID_GATE_ID)
+    printf ("[%zu]", id);
+  fputc (' ', stdout);
+  if (lhs == INVALID_LIT)
+    fputs ("<LHS>", stdout);
+  else
+    fputs (LOGREPR (lhs, repr), stdout);
+  fputs (" := ", stdout);
+  fputs (LOGREPR (cond, repr), stdout);
+  fputs (" ? ", stdout);
+  fputs (LOGREPR (then_lit, repr), stdout);
+  fputs (" : ", stdout);
+  fputs (LOGREPR (else_lit, repr), stdout);
+  end_logging ();
+}
+
+void kissat_log_extensions (kissat *solver, const char *prefix, size_t size,
+                            const extension *const exts, const char *fmt,
+                            ...) {
+  KISSAT_assert (size > 0);
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  const extension *const begin = BEGIN_STACK (solver->extend);
+  const size_t pos = exts - begin;
+  printf (" extend[%zu]", pos);
+  printf (" %d", exts[0].lit);
+  if (size > 1)
+    fputs (" :", stdout);
+  for (size_t i = 1; i < size; i++)
+    printf (" %d", exts[i].lit);
+  end_logging ();
+}
+
+static void log_clause (kissat *solver, const clause *c) {
+  fputc (' ', stdout);
+  if (c == &solver->conflict) {
+    fputs ("static ", stdout);
+    fputs (c->redundant ? "redundant" : "irredundant", stdout);
+    fputs (" binary conflict clause", stdout);
+  } else {
+    if (c->redundant)
+      printf ("redundant glue %u", c->glue);
+    else
+      fputs ("irredundant", stdout);
+    printf (" size %u", c->size);
+    if (c->reason)
+      fputs (" reason", stdout);
+    if (c->garbage)
+      fputs (" garbage", stdout);
+    fputs (" clause", stdout);
+    if (kissat_clause_in_arena (solver, c)) {
+      reference ref = kissat_reference_clause (solver, c);
+      printf ("[%u]", ref);
+    }
+  }
+}
+
+void kissat_log_clause (kissat *solver, const char *prefix, const clause *c,
+                        const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  log_clause (solver, c);
+  log_lits (solver, c->size, c->lits, 0);
+  end_logging ();
+}
+
+void kissat_log_counted_clause (kissat *solver, const char *prefix,
+                                const clause *c, const unsigned *counts,
+                                const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  log_clause (solver, c);
+  log_lits (solver, c->size, c->lits, counts);
+  end_logging ();
+}
+
+void kissat_log_repr_clause (kissat *solver, const char *prefix,
+                             const clause *c, const unsigned *repr,
+                             const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  log_clause (solver, c);
+  log_reprs (solver, c->size, c->lits, repr);
+  end_logging ();
+}
+
+static void log_binary (kissat *solver, unsigned a, unsigned b) {
+  printf (" binary clause %s %s", LOGLIT (a), LOGLIT (b));
+}
+
+void kissat_log_binary (kissat *solver, const char *prefix, unsigned a,
+                        unsigned b, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  log_binary (solver, a, b);
+  end_logging ();
+}
+
+void kissat_log_unary (kissat *solver, const char *prefix, unsigned a,
+                       const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" unary clause %s", LOGLIT (a));
+  end_logging ();
+}
+
+static void log_ref (kissat *solver, reference ref) {
+  clause *c = kissat_dereference_clause (solver, ref);
+  log_clause (solver, c);
+  log_lits (solver, c->size, c->lits, 0);
+}
+
+void kissat_log_ref (kissat *solver, const char *prefix, reference ref,
+                     const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  log_ref (solver, ref);
+  end_logging ();
+}
+
+void kissat_log_watch (kissat *solver, const char *prefix, unsigned lit,
+                       watch watch, const char *fmt, ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  if (watch.type.binary)
+    log_binary (solver, lit, watch.binary.lit);
+  else
+    log_ref (solver, watch.large.ref);
+  end_logging ();
+}
+
+void kissat_log_xor (kissat *solver, const char *prefix, unsigned lit,
+                     unsigned size, const unsigned *lits, const char *fmt,
+                     ...) {
+  va_list ap;
+  va_start (ap, fmt);
+  begin_logging (solver, prefix, fmt, &ap);
+  va_end (ap);
+  printf (" size %u XOR gate ", size);
+  fputs (kissat_log_lit (solver, lit), stdout);
+  printf (" =");
+  for (unsigned i = 0; i < size; i++) {
+    if (i)
+      fputs (" ^ ", stdout);
+    else
+      fputc (' ', stdout);
+    fputs (kissat_log_lit (solver, lits[i]), stdout);
+  }
+  end_logging ();
+}
+
+#else
+
+int kissat_log_dummy_to_avoid_pedantic_warning;
+
+#endif
diff --git a/src/sat/kissat/logging.h b/src/sat/kissat/logging.h
new file mode 100644
index 000000000..65f06ef6b
--- /dev/null
+++ b/src/sat/kissat/logging.h
@@ -0,0 +1,469 @@
+#ifndef _logging_h_INCLUDED
+#define _logging_h_INCLUDED
+
+#include "attribute.h"
+#include "extend.h"
+#include "reference.h"
+#include "watch.h"
+
+#include <stdarg.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#if defined(LOGGING) && !defined(KISSAT_QUIET)
+
+// clang-format off
+
+const char * kissat_log_lit (kissat *, unsigned lit);
+const char * kissat_log_var (kissat *, unsigned idx);
+const char * kissat_log_repr (kissat *, unsigned lit, const unsigned *);
+
+void kissat_begin_logging (kissat *, const char *prefix,
+                           const char *fmt, ...)
+ATTRIBUTE_FORMAT (3, 4);
+
+void kissat_end_logging (void);
+
+void kissat_log_msg (kissat *, const char*, const char *fmt, ...)
+ATTRIBUTE_FORMAT (3, 4);
+
+void kissat_log_clause (kissat *, const char*, const clause *,
+                        const char *, ...)
+ATTRIBUTE_FORMAT (4, 5);
+
+void kissat_log_counted_clause (kissat *, const char*, const clause *,
+                                const unsigned *, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+void kissat_log_repr_clause (kissat *, const char*, const clause *,
+			     const unsigned *, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+void kissat_log_binary (kissat *, const char*,
+                        unsigned, unsigned, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+void kissat_log_unary (kissat *, const char*, unsigned, const char *, ...)
+ATTRIBUTE_FORMAT (4, 5);
+
+void kissat_log_lits (kissat *, const char*,
+                      size_t, const unsigned *, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+void kissat_log_litset (kissat *, const char*,
+                        size_t, const unsigned *, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+void kissat_log_litpart (kissat *, const char*,
+                         size_t, const unsigned *, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+void kissat_log_counted_ref_lits (kissat *, const char*, reference,
+                                  size_t, const unsigned *,
+			          const unsigned * counts, const char *, ...)
+ATTRIBUTE_FORMAT (7, 8);
+
+void kissat_log_counted_lits (kissat *, const char*,
+			      size_t, const unsigned *,
+			      const unsigned * counts, const char *, ...)
+ATTRIBUTE_FORMAT (6, 7);
+
+void kissat_log_unsigneds (kissat *, const char*,
+                           size_t, const unsigned *, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+#define INVALID_GATE_ID (~(size_t)0)
+
+void kissat_log_and_gate (kissat *, const char*, size_t id, unsigned * repr,
+                          unsigned lhs, size_t, const unsigned * rhs,
+			  const char *, ...)
+ATTRIBUTE_FORMAT (8, 9);
+
+void kissat_log_xor_gate (kissat *, const char*, size_t id, unsigned * repr,
+                          unsigned lhs, size_t, const unsigned * rhs,
+			  const char *, ...)
+ATTRIBUTE_FORMAT (8, 9);
+
+void kissat_log_ite_gate (kissat *, const char*, size_t id, unsigned * repr,
+                          unsigned lhs, unsigned cond, unsigned then_lit,
+			  unsigned else_lit, const char *, ...)
+ATTRIBUTE_FORMAT (9, 10);
+
+void kissat_log_ints (kissat *, const char*,
+                      size_t, const int *, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+void kissat_log_extensions (kissat *, const char *,
+			    size_t, const extension *, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+void kissat_log_xor (struct kissat *, const char*, unsigned lit,
+		     unsigned size, const unsigned *lits, const char *fmt, ...)
+ATTRIBUTE_FORMAT (6, 7);
+
+void kissat_log_ref (kissat *, const char*, reference, const char *, ...)
+ATTRIBUTE_FORMAT (4, 5);
+
+void kissat_log_resolvent (kissat *, const char*, const char *, ...)
+ATTRIBUTE_FORMAT (3, 4);
+
+void kissat_log_watch (kissat *, const char*,
+                       unsigned, watch, const char *, ...)
+ATTRIBUTE_FORMAT (5, 6);
+
+// clang-format on
+
+#ifndef LOGPREFIX
+#define LOGPREFIX "LOG"
+#endif
+
+#define LOG(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_msg (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOG2(...) \
+  do { \
+    if (solver && GET_OPTION (log) > 1) \
+      kissat_log_msg (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOG3(...) \
+  do { \
+    if (solver && GET_OPTION (log) > 2) \
+      kissat_log_msg (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOG4(...) \
+  do { \
+    if (solver && GET_OPTION (log) > 3) \
+      kissat_log_msg (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOG5(...) \
+  do { \
+    if (solver && GET_OPTION (log) > 4) \
+      kissat_log_msg (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGLITS(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_lits (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGLITSET(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_litset (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGLITPART(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_litpart (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGCOUNTEDREFLITS(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_counted_ref_lits (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGCOUNTEDLITS(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_counted_lits (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGLITS3(...) \
+  do { \
+    if (GET_OPTION (log) > 2) \
+      kissat_log_lits (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGRES(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_resolvent (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGRES2(...) \
+  do { \
+    if (solver && GET_OPTION (log) > 1) \
+      kissat_log_resolvent (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGEXT(...) \
+  do { \
+    if (GET_OPTION (log)) \
+      kissat_log_extensions (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGEXT2(...) \
+  do { \
+    if (GET_OPTION (log) > 1) \
+      kissat_log_extensions (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGINTS(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_ints (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGINTS3(...) \
+  do { \
+    if (GET_OPTION (log) > 2) \
+      kissat_log_ints (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGUNSIGNEDS2(...) \
+  do { \
+    if (GET_OPTION (log) > 1) \
+      kissat_log_unsigneds (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGUNSIGNEDS3(...) \
+  do { \
+    if (GET_OPTION (log) > 2) \
+      kissat_log_unsigneds (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGANDGATE(...) \
+  do { \
+    if (GET_OPTION (log) > 0) \
+      kissat_log_and_gate (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGXORGATE(...) \
+  do { \
+    if (GET_OPTION (log) > 0) \
+      kissat_log_xor_gate (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGITEGATE(...) \
+  do { \
+    if (GET_OPTION (log) > 0) \
+      kissat_log_ite_gate (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGCLS(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_clause (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGCOUNTEDCLS(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_counted_clause (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGREPRCLS(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_repr_clause (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGLINE(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_line (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGCLS2(...) \
+  do { \
+    if (GET_OPTION (log) > 1) \
+      kissat_log_clause (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGCLS3(...) \
+  do { \
+    if (GET_OPTION (log) > 2) \
+      kissat_log_clause (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGREF(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_ref (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGREF2(...) \
+  do { \
+    if (solver && GET_OPTION (log) > 1) \
+      kissat_log_ref (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGREF3(...) \
+  do { \
+    if (solver && GET_OPTION (log) > 2) \
+      kissat_log_ref (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGBINARY(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_binary (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGBINARY2(...) \
+  do { \
+    if (GET_OPTION (log) > 1) \
+      kissat_log_binary (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGBINARY3(...) \
+  do { \
+    if (GET_OPTION (log) > 2) \
+      kissat_log_binary (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGUNARY(...) \
+  do { \
+    if (solver && GET_OPTION (log)) \
+      kissat_log_unary (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGLIT(LIT) kissat_log_lit (solver, (LIT))
+#define LOGVAR(IDX) kissat_log_var (solver, (IDX))
+#define LOGREPR(LIT, REPR) kissat_log_repr (solver, (LIT), (REPR))
+
+#define LOGWATCH(...) \
+  do { \
+    if (GET_OPTION (log)) \
+      kissat_log_watch (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#define LOGXOR(...) \
+  do { \
+    if (GET_OPTION (log)) \
+      kissat_log_xor (solver, LOGPREFIX, __VA_ARGS__); \
+  } while (0)
+
+#else
+
+#define LOG(...) \
+  do { \
+  } while (0)
+#define LOG2(...) \
+  do { \
+  } while (0)
+#define LOG3(...) \
+  do { \
+  } while (0)
+#define LOG4(...) \
+  do { \
+  } while (0)
+#define LOG5(...) \
+  do { \
+  } while (0)
+#define LOGRES(...) \
+  do { \
+  } while (0)
+#define LOGRES2(...) \
+  do { \
+  } while (0)
+#define LOGLITS(...) \
+  do { \
+  } while (0)
+#define LOGLITSET(...) \
+  do { \
+  } while (0)
+#define LOGLITPART(...) \
+  do { \
+  } while (0)
+#define LOGLITS3(...) \
+  do { \
+  } while (0)
+#define LOGCOUNTEDREFLITS(...) \
+  do { \
+  } while (0)
+#define LOGCOUNTEDLITS(...) \
+  do { \
+  } while (0)
+#define LOGEXT(...) \
+  do { \
+  } while (0)
+#define LOGEXT2(...) \
+  do { \
+  } while (0)
+#define LOGINTS(...) \
+  do { \
+  } while (0)
+#define LOGINTS3(...) \
+  do { \
+  } while (0)
+#define LOGUNSIGNEDS2(...) \
+  do { \
+  } while (0)
+#define LOGUNSIGNEDS3(...) \
+  do { \
+  } while (0)
+#define LOGANDGATE(...) \
+  do { \
+  } while (0)
+#define LOGXORGATE(...) \
+  do { \
+  } while (0)
+#define LOGITEGATE(...) \
+  do { \
+  } while (0)
+#define LOGCLS(...) \
+  do { \
+  } while (0)
+#define LOGCLS2(...) \
+  do { \
+  } while (0)
+#define LOGCLS3(...) \
+  do { \
+  } while (0)
+#define LOGCOUNTEDCLS(...) \
+  do { \
+  } while (0)
+#define LOGREPRCLS(...) \
+  do { \
+  } while (0)
+#define LOGLINE(...) \
+  do { \
+  } while (0)
+#define LOGREF(...) \
+  do { \
+  } while (0)
+#define LOGREF2(...) \
+  do { \
+  } while (0)
+#define LOGREF3(...) \
+  do { \
+  } while (0)
+#define LOGBINARY(...) \
+  do { \
+  } while (0)
+#define LOGBINARY2(...) \
+  do { \
+  } while (0)
+#define LOGBINARY3(...) \
+  do { \
+  } while (0)
+#define LOGUNARY(...) \
+  do { \
+  } while (0)
+#define LOGWATCH(...) \
+  do { \
+  } while (0)
+#define LOGXOR(...) \
+  do { \
+  } while (0)
+
+#endif
+
+#define LOGTMP(...) \
+  LOGLITS (SIZE_STACK (solver->clause), BEGIN_STACK (solver->clause), \
+           __VA_ARGS__)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/lucky.h b/src/sat/kissat/lucky.h
new file mode 100644
index 000000000..2e7538ba8
--- /dev/null
+++ b/src/sat/kissat/lucky.h
@@ -0,0 +1,12 @@
+#ifndef _lucky_h_INCLUDED
+#define _lucky_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+int kissat_lucky (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/minimize.c b/src/sat/kissat/minimize.c
new file mode 100644
index 000000000..6739d7c6b
--- /dev/null
+++ b/src/sat/kissat/minimize.c
@@ -0,0 +1,215 @@
+#include "minimize.h"
+#include "inline.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static inline int minimized_index (kissat *solver, bool minimizing,
+                                   assigned *a, unsigned lit, unsigned idx,
+                                   unsigned depth) {
+#if !defined(LOGGING) && defined(KISSAT_NDEBUG)
+  (void) lit;
+#endif
+#ifdef KISSAT_NDEBUG
+  (void) idx;
+#endif
+  KISSAT_assert (IDX (lit) == idx);
+  KISSAT_assert (solver->assigned + idx == a);
+  if (!a->level) {
+    LOG2 ("skipping root level literal %s", LOGLIT (lit));
+    return 1;
+  }
+  if (a->removable && depth) {
+    LOG2 ("skipping removable literal %s", LOGLIT (lit));
+    return 1;
+  }
+  KISSAT_assert (a->reason != UNIT_REASON);
+  if (a->reason == DECISION_REASON) {
+    LOG2 ("can not remove decision literal %s", LOGLIT (lit));
+    return -1;
+  }
+  if (a->poisoned) {
+    LOG2 ("can not remove poisoned literal %s", LOGLIT (lit));
+    return -1;
+  }
+  if (minimizing || !depth) {
+    frame *frame = &FRAME (a->level);
+    if (frame->used <= 1) {
+      LOG2 ("can not remove singleton frame literal %s", LOGLIT (lit));
+      return -1;
+    }
+  }
+  return 0;
+}
+
+static bool minimize_literal (kissat *, bool, assigned *, unsigned lit,
+                              unsigned depth);
+
+static inline bool minimize_reference (kissat *solver, bool minimizing,
+                                       assigned *assigned, reference ref,
+                                       unsigned lit, unsigned depth) {
+  const unsigned next_depth = (depth == UINT_MAX) ? depth : depth + 1;
+  const unsigned not_lit = NOT (lit);
+  clause *c = kissat_dereference_clause (solver, ref);
+  if (GET_OPTION (minimizeticks))
+    INC (search_ticks);
+  for (all_literals_in_clause (other, c))
+    if (other != not_lit &&
+        !minimize_literal (solver, minimizing, assigned, other, next_depth))
+      return false;
+  return true;
+}
+
+static inline bool minimize_binary (kissat *solver, bool minimizing,
+                                    assigned *assigned, unsigned lit,
+                                    unsigned depth) {
+  const size_t saved = SIZE_STACK (solver->minimize);
+  bool res;
+  for (unsigned next = lit;;) {
+    const unsigned next_idx = IDX (next);
+    struct assigned *a = assigned + next_idx;
+    int tmp = minimized_index (solver, minimizing, a, next, next_idx, 1);
+    if (tmp) {
+      res = (tmp > 0);
+      break;
+    }
+    PUSH_STACK (solver->minimize, next_idx);
+    if (!a->binary) {
+      const unsigned next_depth = (depth == UINT_MAX) ? depth : depth + 1;
+      res = minimize_reference (solver, minimizing, assigned, a->reason,
+                                next, next_depth);
+      break;
+    }
+    next = a->reason;
+  }
+  unsigned *begin = BEGIN_STACK (solver->minimize) + saved;
+  const unsigned *const end = END_STACK (solver->minimize);
+  KISSAT_assert (begin <= end);
+  if (res)
+    for (const unsigned *p = begin; p != end; p++)
+      kissat_push_removable (solver, assigned, *p);
+  else
+    for (const unsigned *p = begin; p != end; p++)
+      kissat_push_poisoned (solver, assigned, *p);
+  SET_END_OF_STACK (solver->minimize, begin);
+  return res;
+}
+
+static bool minimize_literal (kissat *solver, bool minimizing,
+                              assigned *assigned, unsigned lit,
+                              unsigned depth) {
+  LOG ("trying to minimize literal %s at recursion depth %d", LOGLIT (lit),
+       depth);
+  KISSAT_assert (VALUE (lit) < 0);
+  KISSAT_assert (depth || EMPTY_STACK (solver->minimize));
+  KISSAT_assert (GET_OPTION (minimizedepth) > 0);
+  if (depth >= (unsigned) GET_OPTION (minimizedepth))
+    return false;
+  const unsigned idx = IDX (lit);
+  struct assigned *a = assigned + idx;
+  int tmp = minimized_index (solver, minimizing, a, lit, idx, depth);
+  if (tmp > 0)
+    return true;
+  if (tmp < 0)
+    return false;
+#ifdef LOGGING
+  const unsigned not_lit = NOT (lit);
+#endif
+  bool res;
+  if (a->binary) {
+    const unsigned other = a->reason;
+    LOGBINARY2 (not_lit, other, "minimizing along %s reason",
+                LOGLIT (not_lit));
+    res = minimize_binary (solver, minimizing, assigned, other, depth);
+  } else {
+    const reference ref = a->reason;
+    LOGREF2 (ref, "minimizing along %s reason", LOGLIT (not_lit));
+    res =
+        minimize_reference (solver, minimizing, assigned, ref, lit, depth);
+  }
+  if (!depth)
+    return res;
+  if (!res)
+    kissat_push_poisoned (solver, assigned, idx);
+  else if (!a->removable)
+    kissat_push_removable (solver, assigned, idx);
+  return res;
+}
+
+bool kissat_minimize_literal (kissat *solver, unsigned lit,
+                              bool lit_in_clause) {
+  KISSAT_assert (EMPTY_STACK (solver->minimize));
+  return minimize_literal (solver, false, solver->assigned, lit,
+                           !lit_in_clause);
+}
+
+void kissat_reset_poisoned (kissat *solver) {
+  LOG ("reset %zu poisoned variables", SIZE_STACK (solver->poisoned));
+  assigned *assigned = solver->assigned;
+  for (all_stack (unsigned, idx, solver->poisoned)) {
+    KISSAT_assert (idx < VARS);
+    struct assigned *a = assigned + idx;
+    KISSAT_assert (a->poisoned);
+    a->poisoned = false;
+  }
+  CLEAR_STACK (solver->poisoned);
+}
+
+void kissat_minimize_clause (kissat *solver) {
+  START (minimize);
+
+  KISSAT_assert (EMPTY_STACK (solver->minimize));
+  KISSAT_assert (EMPTY_STACK (solver->removable));
+  KISSAT_assert (EMPTY_STACK (solver->poisoned));
+  KISSAT_assert (!EMPTY_STACK (solver->clause));
+
+  unsigned *lits = BEGIN_STACK (solver->clause);
+  unsigned *end = END_STACK (solver->clause);
+
+  assigned *assigned = solver->assigned;
+#ifndef KISSAT_NDEBUG
+  KISSAT_assert (lits < end);
+  const unsigned not_uip = lits[0];
+  KISSAT_assert (assigned[IDX (not_uip)].level == solver->level);
+#endif
+  for (const unsigned *p = lits; p != end; p++)
+    kissat_push_removable (solver, assigned, IDX (*p));
+
+  if (GET_OPTION (shrink) > 2) {
+    STOP (minimize);
+    return;
+  }
+
+  unsigned minimized = 0;
+
+  for (unsigned *p = end; --p > lits;) {
+    const unsigned lit = *p;
+    KISSAT_assert (lit != not_uip);
+    if (minimize_literal (solver, true, assigned, lit, 0)) {
+      LOG ("minimized literal %s", LOGLIT (lit));
+      *p = INVALID_LIT;
+      minimized++;
+    } else
+      LOG ("keeping literal %s", LOGLIT (lit));
+  }
+
+  unsigned *q = lits;
+  for (const unsigned *p = lits; p != end; p++) {
+    const unsigned lit = *p;
+    if (lit != INVALID_LIT)
+      *q++ = lit;
+  }
+  KISSAT_assert (q + minimized == end);
+  SET_END_OF_STACK (solver->clause, q);
+  LOG ("clause minimization removed %u literals", minimized);
+
+  KISSAT_assert (!solver->probing);
+  ADD (literals_minimized, minimized);
+
+  LOGTMP ("minimized learned");
+
+  kissat_reset_poisoned (solver);
+
+  STOP (minimize);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/minimize.h b/src/sat/kissat/minimize.h
new file mode 100644
index 000000000..25d2f4d33
--- /dev/null
+++ b/src/sat/kissat/minimize.h
@@ -0,0 +1,19 @@
+#ifndef _minimize_h_INCLUDED
+#define _minimize_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_reset_poisoned (struct kissat *);
+
+void kissat_minimize_clause (struct kissat *);
+bool kissat_minimize_literal (struct kissat *, unsigned,
+                              bool lit_in_clause);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/mode.c b/src/sat/kissat/mode.c
new file mode 100644
index 000000000..e42027339
--- /dev/null
+++ b/src/sat/kissat/mode.c
@@ -0,0 +1,219 @@
+#include "bump.h"
+#include "decide.h"
+#include "inline.h"
+#include "print.h"
+#include "report.h"
+#include "resources.h"
+#include "restart.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#ifndef KISSAT_QUIET
+
+static const char *mode_string (kissat *solver) {
+  return solver->stable ? "stable" : "focused";
+}
+
+#endif
+
+void kissat_init_mode_limit (kissat *solver) {
+  limits *limits = &solver->limits;
+
+  if (GET_OPTION (stable) == 1) {
+    KISSAT_assert (!solver->stable);
+
+    const uint64_t conflicts_delta = GET_OPTION (modeinit);
+    const uint64_t conflicts_limit = CONFLICTS + conflicts_delta;
+
+    KISSAT_assert (conflicts_limit);
+
+    limits->mode.conflicts = conflicts_limit;
+    limits->mode.ticks = 0;
+    limits->mode.count = 0;
+
+    kissat_very_verbose (solver,
+                         "initial %s mode switching limit "
+                         "at %s after %s conflicts",
+                         mode_string (solver),
+                         FORMAT_COUNT (conflicts_limit),
+                         FORMAT_COUNT (conflicts_delta));
+
+    solver->mode.ticks = solver->statistics_.search_ticks;
+#ifndef KISSAT_QUIET
+    solver->mode.conflicts = CONFLICTS;
+#ifdef METRICS
+    solver->mode.propagations = solver->statistics_.search_propagations;
+#endif
+    // clang-format off
+      solver->mode.entered = kissat_process_time ();
+      kissat_very_verbose (solver,
+        "starting %s mode at %.2f seconds "
+        "(%" PRIu64 " conflicts, %" PRIu64 " ticks"
+#ifdef METRICS
+	", %" PRIu64 " propagations, %" PRIu64 " visits"
+#endif
+	")", mode_string (solver),
+        solver->mode.entered, solver->mode.conflicts, solver->mode.ticks
+#ifdef METRICS
+        , solver->mode.propagations, solver->mode.visits
+#endif
+	);
+// clang-format on
+#endif
+  } else
+    kissat_very_verbose (solver,
+                         "no need to set mode limit (only %s mode enabled)",
+                         mode_string (solver));
+}
+
+static void update_mode_limit (kissat *solver, uint64_t delta_ticks) {
+  kissat_init_averages (solver, &AVERAGES);
+
+  limits *limits = &solver->limits;
+  statistics *statistics = &solver->statistics_;
+
+  KISSAT_assert (GET_OPTION (stable) == 1);
+
+  if (limits->mode.count & 1) {
+    limits->mode.ticks = statistics->search_ticks + delta_ticks;
+#ifndef KISSAT_QUIET
+    KISSAT_assert (solver->stable);
+    kissat_phase (solver, "stable", GET (stable_modes),
+                  "new stable mode switching limit of %s "
+                  "after %s ticks",
+                  FORMAT_COUNT (limits->mode.ticks),
+                  FORMAT_COUNT (delta_ticks));
+#endif
+  } else {
+    KISSAT_assert (limits->mode.ticks);
+    const uint64_t interval = GET_OPTION (modeint);
+    const uint64_t count = (statistics->switched + 1) / 2;
+    const uint64_t scaled = interval * kissat_nlogpown (count, 4);
+    limits->mode.conflicts = statistics->conflicts + scaled;
+#ifndef KISSAT_QUIET
+    KISSAT_assert (!solver->stable);
+    kissat_phase (solver, "focused", GET (focused_modes),
+                  "new focused mode switching limit of %s "
+                  "after %s conflicts",
+                  FORMAT_COUNT (limits->mode.conflicts),
+                  FORMAT_COUNT (scaled));
+#endif
+  }
+
+  solver->mode.ticks = statistics->search_ticks;
+#ifndef KISSAT_QUIET
+  solver->mode.conflicts = statistics->conflicts;
+#ifdef METRICS
+  solver->mode.propagations = statistics->search_propagations;
+#endif
+#endif
+}
+
+static void report_switching_from_mode (kissat *solver,
+                                        uint64_t *delta_ticks) {
+  statistics *statistics = &solver->statistics_;
+  *delta_ticks = statistics->search_ticks - solver->mode.ticks;
+
+#ifndef KISSAT_QUIET
+  if (kissat_verbosity (solver) < 2)
+    return;
+
+  const double current_time = kissat_process_time ();
+  const double delta_time = current_time - solver->mode.entered;
+
+  const uint64_t delta_conflicts =
+      statistics->conflicts - solver->mode.conflicts;
+#ifdef METRICS
+  const uint64_t delta_propagations =
+      statistics->search_propagations - solver->mode.propagations;
+#endif
+  solver->mode.entered = current_time;
+
+  // clang-format off
+  kissat_very_verbose (solver, "%s mode took %.2f seconds "
+    "(%s conflicts, %s ticks"
+#ifdef METRICS
+    ", %s propagations"
+#endif
+    ")", solver->stable ? "stable" : "focused",
+    delta_time, FORMAT_COUNT (delta_conflicts), FORMAT_COUNT (*delta_ticks)
+#ifdef METRICS
+    , FORMAT_COUNT (delta_propagations)
+#endif
+    );
+  // clang-format on
+#else
+  (void) solver;
+#endif
+}
+
+static void switch_to_focused_mode (kissat *solver) {
+  KISSAT_assert (solver->stable);
+  uint64_t delta;
+  report_switching_from_mode (solver, &delta);
+  REPORT (0, ']');
+  STOP (stable);
+  INC (focused_modes);
+  kissat_phase (solver, "focus", GET (focused_modes),
+                "switching to focused mode after %s conflicts",
+                FORMAT_COUNT (CONFLICTS));
+  solver->stable = false;
+  update_mode_limit (solver, delta);
+  START (focused);
+  REPORT (0, '{');
+  kissat_reset_search_of_queue (solver);
+  kissat_update_focused_restart_limit (solver);
+}
+
+static void switch_to_stable_mode (kissat *solver) {
+  KISSAT_assert (!solver->stable);
+  uint64_t delta;
+  report_switching_from_mode (solver, &delta);
+  REPORT (0, '}');
+  STOP (focused);
+  INC (stable_modes);
+  solver->stable = true;
+  kissat_phase (solver, "stable", GET (stable_modes),
+                "switched to stable mode after %" PRIu64 " conflicts",
+                CONFLICTS);
+  update_mode_limit (solver, delta);
+  START (stable);
+  REPORT (0, '[');
+  kissat_init_reluctant (solver);
+  kissat_update_scores (solver);
+}
+
+bool kissat_switching_search_mode (kissat *solver) {
+  KISSAT_assert (!solver->inconsistent);
+
+  if (GET_OPTION (stable) != 1)
+    return false;
+
+  limits *limits = &solver->limits;
+  statistics *statistics = &solver->statistics_;
+
+  if (limits->mode.count & 1)
+    return statistics->search_ticks >= limits->mode.ticks;
+  else
+    return statistics->conflicts >= limits->mode.conflicts;
+}
+
+void kissat_switch_search_mode (kissat *solver) {
+  KISSAT_assert (kissat_switching_search_mode (solver));
+
+  INC (switched);
+  solver->limits.mode.count++;
+
+  if (solver->stable)
+    switch_to_focused_mode (solver);
+  else
+    switch_to_stable_mode (solver);
+
+  solver->averages[solver->stable].saved_decisions = DECISIONS;
+
+  kissat_start_random_sequence (solver);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/mode.h b/src/sat/kissat/mode.h
new file mode 100644
index 000000000..0b658113c
--- /dev/null
+++ b/src/sat/kissat/mode.h
@@ -0,0 +1,29 @@
+#ifndef _mode_h_INCLUDED
+#define _mode_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+typedef struct mode mode;
+
+struct mode {
+  uint64_t ticks;
+#ifndef KISSAT_QUIET
+  double entered;
+  uint64_t conflicts;
+#ifdef METRICS
+  uint64_t propagations;
+  uint64_t visits;
+#endif
+#endif
+};
+
+void kissat_init_mode_limit (struct kissat *);
+bool kissat_switching_search_mode (struct kissat *);
+void kissat_switch_search_mode (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/module.make b/src/sat/kissat/module.make
new file mode 100644
index 000000000..e6ca01394
--- /dev/null
+++ b/src/sat/kissat/module.make
@@ -0,0 +1,91 @@
+SRC += src/sat/kissat/kissatSolver.c \
+src/sat/kissat/kissatTest.c\
+src/sat/kissat/allocate.c \
+src/sat/kissat/analyze.c \
+src/sat/kissat/ands.c \
+src/sat/kissat/arena.c \
+src/sat/kissat/assign.c \
+src/sat/kissat/averages.c \
+src/sat/kissat/backbone.c \
+src/sat/kissat/backtrack.c \
+src/sat/kissat/build.c \
+src/sat/kissat/bump.c \
+src/sat/kissat/check.c \
+src/sat/kissat/classify.c \
+src/sat/kissat/clause.c \
+src/sat/kissat/collect.c \
+src/sat/kissat/colors.c \
+src/sat/kissat/compact.c \
+src/sat/kissat/config.c \
+src/sat/kissat/congruence.c \
+src/sat/kissat/decide.c \
+src/sat/kissat/deduce.c \
+src/sat/kissat/definition.c \
+src/sat/kissat/dense.c \
+src/sat/kissat/dump.c \
+src/sat/kissat/eliminate.c \
+src/sat/kissat/equivalences.c \
+src/sat/kissat/error.c \
+src/sat/kissat/extend.c \
+src/sat/kissat/factor.c \
+src/sat/kissat/fastel.c \
+src/sat/kissat/file.c \
+src/sat/kissat/flags.c \
+src/sat/kissat/format.c \
+src/sat/kissat/forward.c \
+src/sat/kissat/gates.c \
+src/sat/kissat/heap.c \
+src/sat/kissat/ifthenelse.c \
+src/sat/kissat/import.c \
+src/sat/kissat/internal.c \
+src/sat/kissat/kimits.c \
+src/sat/kissat/kitten.c \
+src/sat/kissat/krite.c \
+src/sat/kissat/learn.c \
+src/sat/kissat/logging.c \
+src/sat/kissat/kucky.c \
+src/sat/kissat/minimize.c \
+src/sat/kissat/mode.c \
+src/sat/kissat/kptions.c \
+src/sat/kissat/phases.c \
+src/sat/kissat/preprocess.c \
+src/sat/kissat/print.c \
+src/sat/kissat/probe.c \
+src/sat/kissat/profile.c \
+src/sat/kissat/promote.c \
+src/sat/kissat/proof.c \
+src/sat/kissat/propbeyond.c \
+src/sat/kissat/propdense.c \
+src/sat/kissat/propinitially.c \
+src/sat/kissat/proprobe.c \
+src/sat/kissat/propsearch.c \
+src/sat/kissat/queue.c \
+src/sat/kissat/reduce.c \
+src/sat/kissat/reluctant.c \
+src/sat/kissat/reorder.c \
+src/sat/kissat/rephase.c \
+src/sat/kissat/report.c \
+src/sat/kissat/resize.c \
+src/sat/kissat/resolve.c \
+src/sat/kissat/resources.c \
+src/sat/kissat/restart.c \
+src/sat/kissat/search.c \
+src/sat/kissat/shrink.c \
+src/sat/kissat/smooth.c \
+src/sat/kissat/sort.c \
+src/sat/kissat/stack.c \
+src/sat/kissat/statistics.c \
+src/sat/kissat/strengthen.c \
+src/sat/kissat/substitute.c \
+src/sat/kissat/sweep.c \
+src/sat/kissat/terminate.c \
+src/sat/kissat/tiers.c \
+src/sat/kissat/trail.c \
+src/sat/kissat/transitive.c \
+src/sat/kissat/utilities.c \
+src/sat/kissat/vector.c \
+src/sat/kissat/vivify.c \
+src/sat/kissat/walk.c \
+src/sat/kissat/warmup.c \
+src/sat/kissat/watch.c \
+src/sat/kissat/weaken.c \
diff --git a/src/sat/kissat/options.h b/src/sat/kissat/options.h
new file mode 100644
index 000000000..3746014bd
--- /dev/null
+++ b/src/sat/kissat/options.h
@@ -0,0 +1,304 @@
+#ifndef _options_h_INLCUDED
+#define _options_h_INLCUDED
+
+#include <assert.h>
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+// clang-format off
+
+#define OPTIONS \
+  OPTION (ands, 1, 0, 1, "extract and eliminate and gates") \
+  OPTION (backbone, 1, 0, 2, "binary clause backbone (2=eager)") \
+  OPTION (backboneeffort, 20, 0, 1e5, "effort in per mille") \
+  OPTION (backbonemaxrounds, 1e3, 1, INT_MAX, "maximum backbone rounds") \
+  OPTION (backbonerounds, 100, 1, INT_MAX, "backbone rounds limit") \
+  OPTION (bigbigfraction, 990, 0, 1000, "big binary clause fraction per mille") \
+  OPTION (bump, 1, 0, 1, "enable variable bumping") \
+  OPTION (bumpreasons, 1, 0, 1, "bump reason side literals too") \
+  OPTION (bumpreasonslimit, 10, 1, INT_MAX, "relative reason literals limit") \
+  OPTION (bumpreasonsrate, 10, 1, INT_MAX, "decision rate limit") \
+  DBGOPT (check, 2, 0, 2, "check model (1) and derived clauses (2)") \
+  OPTION (chrono, 1, 0, 1, "allow chronological backtracking") \
+  OPTION (chronolevels, 100, 0, INT_MAX, "maximum jumped over levels") \
+  OPTION (compact, 1, 0, 1, "enable compacting garbage collection") \
+  OPTION (compactlim, 10, 0, 100, "compact inactive limit (in percent)") \
+  OPTION (congruence, 1, 0, 1, "congruence closure on extracted gates") \
+  OPTION (congruenceandarity, 1000000, 2, 50000000, "AND gate arity limit") \
+  OPTION (congruenceands, 1, 0, 1, "extract AND gates for congruence closure") \
+  OPTION (congruencebinaries, 1, 0, 1, "extract certain binary clauses") \
+  OPTION (congruenceites, 1, 0, 1, "extract ITE gates for congruence closure") \
+  OPTION (congruenceonce, 0, 0, 1, "congruence closure only initially") \
+  OPTION (congruencexorarity, 4, 2, 20, "congruence XOR gate arity limit") \
+  OPTION (congruencexorcounts, 2, 1, INT_MAX, "XOR counting rounds") \
+  OPTION (congruencexors, 1, 0, 1, "extract XOR gates for congruence closure") \
+  OPTION (decay, 50, 1, 200, "per mille scores decay") \
+  OPTION (definitioncores, 2, 1, 100, "how many cores") \
+  OPTION (definitions, 1, 0, 1, "extract general definitions") \
+  OPTION (definitionticks, 1e6, 0, INT_MAX, "kitten ticks limits") \
+  OPTION (defraglim, 75, 50, 100, "usable defragmentation limit in percent") \
+  OPTION (defragsize, 1 << 18, 10, INT_MAX, "size defragmentation limit") \
+  OPTION (eagersubsume, 4, 0, 4, "eagerly subsume previous learned clauses") \
+  OPTION (eliminate, 1, 0, 1, "bounded variable elimination BVE") \
+  OPTION (eliminatebound, 16, 0, 1 << 13, "maximum elimination bound") \
+  OPTION (eliminateclslim, 100, 1, INT_MAX, "elimination clause size limit") \
+  OPTION (eliminateeffort, 100, 0, 2e3, "effort in per mille") \
+  OPTION (eliminateinit, 500, 0, INT_MAX, "initial elimination interval") \
+  OPTION (eliminateint, 500, 10, INT_MAX, "base elimination interval") \
+  OPTION (eliminateocclim, 2e3, 0, INT_MAX, "elimination occurrence limit") \
+  OPTION (eliminaterounds, 2, 1, 1e4, "elimination rounds limit") \
+  OPTION (emafast, 33, 10, 1e6, "fast exponential moving average window") \
+  OPTION (emaslow, 1e5, 100, 1e6, "slow exponential moving average window") \
+  EMBOPT (embedded, 1, 0, 1, "parse and apply embedded options") \
+  OPTION (equivalences, 1, 0, 1, "extract and eliminate equivalence gates") \
+  OPTION (extract, 1, 0, 1, "extract gates in variable elimination") \
+  OPTION (factor, 1, 0, 1, "bounded variable addition") \
+  OPTION (factorcandrounds, 2, 0, INT_MAX, "candidates reduction rounds") \
+  OPTION (factoreffort, 50, 0, 1e6, "bounded variable effort in per mille") \
+  OPTION (factorhops, 3, 1, 10, "structural factoring heuristic hops") \
+  OPTION (factoriniticks, 700, 1, 1000000, "initial ticks ticks in millions") \
+  OPTION (factorsize, 5, 2, INT_MAX, "bounded variable addition clause size") \
+  OPTION (factorstructural, 0, 0, 1, "structural bounded variable addition") \
+  OPTION (fastel, 1, 0, 1, "initial fast variable elimination") \
+  OPTION (fastelclslim, 100, 1, INT_MAX, "fast elimination clause length limit") \
+  OPTION (fastelim, 8, 1, 1000, "fast elimination resolvents limit") \
+  OPTION (fasteloccs, 100, 1, 1000, "fast elimination occurrence limit") \
+  OPTION (fastelrounds, 4, 1, 1000, "fast elimination rounds") \
+  OPTION (fastelsub, 1, 0, 1, "forward subsuming fast variable elimination") \
+  OPTION (flushproof, 0, 0, 1, "flush proof lines immediately") \
+  OPTION (focusedtiers, 1, 0, 1, "always used focused mode tiers") \
+  OPTION (forcephase, 0, 0, 1, "force initial phase") \
+  OPTION (forward, 1, 0, 1, "forward subsumption in BVE") \
+  OPTION (forwardeffort, 100, 0, 1e6, "effort in per mille") \
+  OPTION (ifthenelse, 1, 0, 1, "extract and eliminate if-then-else gates") \
+  OPTION (incremental, 0, 0, 1, "enable incremental solving") \
+  OPTION (jumpreasons, 1, 0, 1, "jump binary reasons") \
+  LOGOPT (log, 0, 0, 5, "logging level (1=on,2=more,3=check,4/5=mem)") \
+  OPTION (lucky, 1, 0, 1, "try some lucky assignments") \
+  OPTION (luckyearly, 1, 0, 1, "lucky assignments before preprocessing") \
+  OPTION (luckylate, 1, 0, 1, "lucky assignments after preprocessing") \
+  OPTION (mineffort, 10, 0, INT_MAX, "minimum absolute effort in millions") \
+  OPTION (minimize, 1, 0, 1, "learned clause minimization") \
+  OPTION (minimizedepth, 1e3, 1, 1e6, "minimization depth") \
+  OPTION (minimizeticks, 1, 0, 1, "count ticks in minimize and shrink") \
+  OPTION (modeinit, 1e3, 10, 1e8, "initial focused conflicts limit") \
+  OPTION (modeint, 1e3, 10, 1e8, "focused conflicts interval") \
+  OPTION (otfs, 1, 0, 1, "on-the-fly strengthening") \
+  OPTION (phase, 1, 0, 1, "initial decision phase") \
+  OPTION (phasesaving, 1, 0, 1, "enable phase saving") \
+  OPTION (preprocess, 1, 0, 1, "initial preprocessing") \
+  OPTION (preprocessbackbone, 1, 0, 1, "backbone preprocessing") \
+  OPTION (preprocesscongruence, 1, 0, 1, "congruence preprocessing") \
+  OPTION (preprocessfactor, 1, 0, 1, "variable addition preprocessing") \
+  OPTION (preprocessprobe, 1, 0, 1, "probing preprocessing") \
+  OPTION (preprocessrounds, 1, 1, INT_MAX, "initial preprocessing rounds") \
+  OPTION (preprocessweep, 1, 0, 1, "sweep preprocessing") \
+  OPTION (probe, 1, 0, 1, "enable probing") \
+  OPTION (probeinit, 100, 0, INT_MAX, "initial probing interval") \
+  OPTION (probeint, 100, 2, INT_MAX, "probing interval") \
+  OPTION (proberounds, 2, 1, INT_MAX, "probing rounds") \
+  NQTOPT (profile, 2, 0, 4, "profile level") \
+  OPTION (promote, 1, 0, 1, "promote clauses") \
+  NQTOPT (quiet, 0, 0, 1, "disable all messages") \
+  OPTION (randec, 1, 0, 1, "random decisions") \
+  OPTION (randecfocused, 1, 0, 1, "random decisions in focused mode") \
+  OPTION (randecinit, 500, 0, INT_MAX, "random decisions interval") \
+  OPTION (randecint, 500, 0, INT_MAX, "initial random decisions interval") \
+  OPTION (randeclength, 10, 1, INT_MAX, "random conflicts length") \
+  OPTION (randecstable, 0, 0, 1, "random decisions in stable mode") \
+  OPTION (reduce, 1, 0, 1, "learned clause reduction") \
+  OPTION (reducehigh, 900, 0, 1000, "high reduce fraction per mille") \
+  OPTION (reduceinit, 1e3, 2, 1e5, "initial reduce interval") \
+  OPTION (reduceint, 1e3, 2, 1e5, "base reduce interval") \
+  OPTION (reducelow, 500, 0, 1000, "low reduce fraction per mille") \
+  OPTION (reluctant, 1, 0, 1, "stable reluctant doubling restarting") \
+  OPTION (reluctantint, 1 << 10, 2, 1 << 15, "reluctant interval") \
+  OPTION (reluctantlim, 1 << 20, 0, 1 << 30, "reluctant limit (0=unlimited)") \
+  OPTION (reorder, 2, 0, 2, "reorder decisions (1=stable-mode-only)") \
+  OPTION (reorderinit, 1e4, 0, 1e5, "initial reorder interval") \
+  OPTION (reorderint, 1e4, 1, 1e5, "base reorder interval") \
+  OPTION (reordermaxsize, 100, 2, 256, "reorder maximum clause size") \
+  OPTION (rephase, 1, 0, 1, "reinitialization of decision phases") \
+  OPTION (rephaseinit, 1e3, 10, 1e5, "initial rephase interval") \
+  OPTION (rephaseint, 1e3, 10, 1e5, "base rephase interval") \
+  OPTION (restart, 1, 0, 1, "enable restarts") \
+  OPTION (restartint, RESTARTINT_DEFAULT, 1, 1e4, "base restart interval") \
+  OPTION (restartmargin, 10, 0, 25, "fast/slow margin in percent") \
+  OPTION (restartreusetrail, 1, 0, 1, "restarts tries to reuse trail") \
+  OPTION (seed, 0, 0, INT_MAX, "random seed") \
+  OPTION (shrink, 3, 0, 3, "learned clauses (1=bin,2=lrg,3=rec)") \
+  OPTION (simplify, 1, 0, 1, "enable probing and elimination") \
+  OPTION (smallclauses, 1e5, 0, INT_MAX, "small clauses limit") \
+  OPTION (stable, STABLE_DEFAULT, 0, 2, "enable stable search mode") \
+  NQTOPT (statistics, 0, 0, 1, "print complete statistics") \
+  OPTION (substitute, 1, 0, 1, "equivalent literal substitution") \
+  OPTION (substituteeffort, 10, 1, 1e3, "effort in per mille") \
+  OPTION (substituterounds, 2, 1, 100, "maximum substitution rounds") \
+  OPTION (subsumeclslim, 1e3, 1, INT_MAX, "subsumption clause size limit") \
+  OPTION (subsumeocclim, 1e3, 0, INT_MAX, "subsumption occurrence limit") \
+  OPTION (sweep, 1, 0, 1, "enable SAT sweeping") \
+  OPTION (sweepclauses, 1024, 0, INT_MAX, "environment clauses") \
+  OPTION (sweepcomplete, 0, 0, 1, "run SAT sweeping until completion") \
+  OPTION (sweepdepth, 2, 0, INT_MAX, "environment depth") \
+  OPTION (sweepeffort, 100, 0, 1e4, "effort in per mille") \
+  OPTION (sweepfliprounds, 1, 0, INT_MAX, "flipping rounds") \
+  OPTION (sweepmaxclauses, 32768, 2, INT_MAX, "maximum environment clauses") \
+  OPTION (sweepmaxdepth, 3, 1, INT_MAX, "maximum environment depth") \
+  OPTION (sweepmaxvars, 8192, 2, INT_MAX, "maximum environment variables") \
+  OPTION (sweeprand, 0, 0, 1, "randomize sweeping environment") \
+  OPTION (sweepvars, 256, 0, INT_MAX, "environment variables") \
+  OPTION (target, TARGET_DEFAULT, 0, 2, "target phases (1=stable,2=focused)") \
+  OPTION (tier1, 2, 1, 100, "learned clause tier one glue limit") \
+  OPTION (tier1relative, 500, 0, 1000, "relative tier one glue limit") \
+  OPTION (tier2, 6, 1, 1e3, "learned clause tier two glue limit") \
+  OPTION (tier2relative, 900, 0, 1000, "relative tier two glue limit") \
+  OPTION (transitive, 1, 0, 1, "transitive reduction of binary clauses") \
+  OPTION (transitiveeffort, 20, 0, 2e3, "effort in per mille") \
+  OPTION (transitivekeep, 1, 0, 1, "keep transitivity candidates") \
+  OPTION (tumble, 1, 0, 1, "tumbled external indices order") \
+  NQTOPT (verbose, 0, 0, 3, "verbosity level") \
+  OPTION (vivify, 1, 0, 1, "vivify clauses") \
+  OPTION (vivifyeffort, 100, 0, 1e3, "effort in per mille") \
+  OPTION (vivifyfocusedtiers, 1, 0, 1, "use focused tier limits") \
+  OPTION (vivifyirr, 3, 0, 100, "relative irredundant effort") \
+  OPTION (vivifysort, 1, 0, 1, "sort vivification candidates") \
+  OPTION (vivifytier1, 3, 0, 100, "relative tier1 effort") \
+  OPTION (vivifytier2, 3, 0, 100, "relative tier2 effort") \
+  OPTION (vivifytier3, 1, 0, 100, "relative tier3 effort") \
+  OPTION (walkeffort, 50, 0, 1e6, "effort in per mille") \
+  OPTION (walkinitially, 0, 0, 1, "initial local search") \
+  OPTION (warmup, 1, 0, 1, "initialize phases by unit propagation")
+
+// clang-format on
+
+#define TARGET_SAT 2
+#define TARGET_DEFAULT 1
+
+#define STABLE_DEFAULT 1
+#define STABLE_UNSAT 0
+
+#define RESTARTINT_DEFAULT 1
+#define RESTARTINT_SAT 50
+
+#ifdef SAT
+#undef TARGET_DEFAULT
+#define TARGET_DEFAULT TARGET_SAT
+#undef RESTARTINT_DEFAULT
+#define RESTARTINT_DEFAULT RESTARTINT_SAT
+#endif
+
+#ifdef UNSAT
+#undef STABLE_DEFAULT
+#define STABLE_DEFAULT STABLE_UNSAT
+#endif
+
+#if defined(LOGGING) && !defined(KISSAT_QUIET)
+#define LOGOPT OPTION
+#else
+#define LOGOPT(...) /**/
+#endif
+
+#ifndef KISSAT_QUIET
+#define NQTOPT OPTION
+#else
+#define NQTOPT(...) /**/
+#endif
+
+#ifndef KISSAT_NDEBUG
+#define DBGOPT OPTION
+#else
+#define DBGOPT(...) /**/
+#endif
+
+#ifdef EMBEDDED
+#define EMBOPT OPTION
+#else
+#define EMBOPT(...) /**/
+#endif
+
+// clang-format on
+
+#define TIER1RELATIVE (GET_OPTION (tier1relative) / 1000.0)
+#define TIER2RELATIVE (GET_OPTION (tier2relative) / 1000.0)
+
+typedef struct opt opt;
+
+struct opt {
+  const char *name;
+#ifndef KISSAT_NOPTIONS
+  int value;
+  const int low;
+  const int high;
+#else
+  const int value;
+#endif
+  const char *description;
+};
+
+extern const opt *kissat_options_begin;
+extern const opt *kissat_options_end;
+
+#define all_options(O) \
+  opt const *O = kissat_options_begin; \
+  O != kissat_options_end; \
+  ++O
+
+const char *kissat_parse_option_name (const char *arg, const char *name);
+bool kissat_parse_option_value (const char *val_str, int *res_ptr);
+
+#ifndef KISSAT_NOPTIONS
+
+void kissat_options_usage (void);
+
+const opt *kissat_options_has (const char *name);
+
+#define kissat_options_max_name_buffer_size ((size_t) 32)
+
+bool kissat_options_parse_arg (const char *arg, char *name, int *val_str);
+void kissat_options_print_value (int value, char *buffer);
+
+typedef struct options options;
+
+struct options {
+#define OPTION(N, V, L, H, D) int N;
+  OPTIONS
+#undef OPTION
+};
+
+void kissat_init_options (options *);
+
+int kissat_options_get (const options *, const char *name);
+int kissat_options_set_opt (options *, const opt *, int new_value);
+int kissat_options_set (options *, const char *name, int new_value);
+
+void kissat_print_embedded_option_list (void);
+void kissat_print_option_range_list (void);
+
+static inline int *kissat_options_ref (const options *options,
+                                       const opt *o) {
+  if (!o)
+    return 0;
+  KISSAT_assert (kissat_options_begin <= o);
+  KISSAT_assert (o < kissat_options_end);
+  return (int *) options + (o - kissat_options_begin);
+}
+
+#define GET_OPTION(NAME) ((int) solver->options.NAME)
+
+#else
+
+void kissat_init_options (void);
+int kissat_options_get (const char *name);
+
+#define GET_OPTION(N) kissat_options_##N
+
+#define OPTION(N, V, L, H, D) static const int GET_OPTION (N) = (int) (V);
+OPTIONS
+#undef OPTION
+#endif
+#define GET1K_OPTION(NAME) (((int64_t) 1000) * GET_OPTION (NAME))
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/parse.h b/src/sat/kissat/parse.h
new file mode 100644
index 000000000..709464648
--- /dev/null
+++ b/src/sat/kissat/parse.h
@@ -0,0 +1,24 @@
+#ifndef _parse_h_INCLUDED
+#define _parse_h_INCLUDED
+
+#include "file.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+enum strictness {
+  RELAXED_PARSING = 0,
+  NORMAL_PARSING = 1,
+  PEDANTIC_PARSING = 2,
+};
+
+typedef enum strictness strictness;
+
+struct kissat;
+
+const char *kissat_parse_dimacs (struct kissat *, strictness, file *,
+                                 uint64_t *linenoptr, int *max_var_ptr);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/phases.c b/src/sat/kissat/phases.c
new file mode 100644
index 000000000..ac1ea70df
--- /dev/null
+++ b/src/sat/kissat/phases.c
@@ -0,0 +1,72 @@
+#include "allocate.h"
+#include "internal.h"
+#include "logging.h"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#define realloc_phases(NAME) \
+  do { \
+    solver->phases.NAME = \
+      (value*) kissat_realloc (solver, solver->phases.NAME, old_size, new_size); \
+  } while (0)
+
+#define increase_phases(NAME) \
+  do { \
+    KISSAT_assert (old_size < new_size); \
+    realloc_phases (NAME); \
+    memset (solver->phases.NAME + old_size, 0, new_size - old_size); \
+  } while (0)
+
+void kissat_increase_phases (kissat *solver, unsigned new_size) {
+  const unsigned old_size = solver->size;
+  KISSAT_assert (old_size < new_size);
+  LOG ("increasing phases from %u to %u", old_size, new_size);
+  increase_phases (best);
+  increase_phases (saved);
+  increase_phases (target);
+}
+
+void kissat_decrease_phases (kissat *solver, unsigned new_size) {
+  const unsigned old_size = solver->size;
+  KISSAT_assert (old_size > new_size);
+  LOG ("decreasing phases from %u to %u", old_size, new_size);
+  realloc_phases (best);
+  realloc_phases (saved);
+  realloc_phases (target);
+}
+
+#define release_phases(NAME, SIZE) \
+  kissat_free (solver, solver->phases.NAME, SIZE)
+
+void kissat_release_phases (kissat *solver) {
+  const unsigned size = solver->size;
+  release_phases (best, size);
+  release_phases (saved, size);
+  release_phases (target, size);
+}
+
+static void save_phases (kissat *solver, value *phases) {
+  const value *const values = solver->values;
+  const value *const end = phases + VARS;
+  value const *v = values;
+  for (value *p = phases, tmp; p != end; p++, v += 2)
+    if ((tmp = *v))
+      *p = tmp;
+  KISSAT_assert (v == values + LITS);
+}
+
+void kissat_save_best_phases (kissat *solver) {
+  KISSAT_assert (sizeof (value) == 1);
+  LOG ("saving %u best values", VARS);
+  save_phases (solver, solver->phases.best);
+}
+
+void kissat_save_target_phases (kissat *solver) {
+  KISSAT_assert (sizeof (value) == 1);
+  LOG ("saving %u target values", VARS);
+  save_phases (solver, solver->phases.target);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/phases.h b/src/sat/kissat/phases.h
new file mode 100644
index 000000000..7f852b4e0
--- /dev/null
+++ b/src/sat/kissat/phases.h
@@ -0,0 +1,37 @@
+#ifndef _phases_h_INCLUDED
+#define _phases_h_INCLUDED
+
+#include "value.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct phases phases;
+
+struct phases {
+  value *best;
+  value *saved;
+  value *target;
+};
+
+#define BEST(IDX) \
+  (solver->phases.best[KISSAT_assert (VALID_INTERNAL_INDEX (IDX)), (IDX)])
+
+#define SAVED(IDX) \
+  (solver->phases.saved[KISSAT_assert (VALID_INTERNAL_INDEX (IDX)), (IDX)])
+
+#define TARGET(IDX) \
+  (solver->phases.target[KISSAT_assert (VALID_INTERNAL_INDEX (IDX)), (IDX)])
+
+struct kissat;
+
+void kissat_increase_phases (struct kissat *, unsigned);
+void kissat_decrease_phases (struct kissat *, unsigned);
+void kissat_release_phases (struct kissat *);
+
+void kissat_save_best_phases (struct kissat *);
+void kissat_save_target_phases (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/preprocess.c b/src/sat/kissat/preprocess.c
new file mode 100644
index 000000000..875b8f49a
--- /dev/null
+++ b/src/sat/kissat/preprocess.c
@@ -0,0 +1,182 @@
+#include "preprocess.h"
+#include "collect.h"
+#include "fastel.h"
+#include "internal.h"
+#include "print.h"
+#include "probe.h"
+#include "propinitially.h"
+#include "report.h"
+#include "sweep.h"
+#include "terminate.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_preprocessing (struct kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->inconsistent);
+  if (!GET_OPTION (preprocess))
+    return false;
+  if (!GET_OPTION (probe))
+    return false;
+  if (!GET_OPTION (preprocessprobe))
+    return false;
+#if defined(KISSAT_NDEBUG) && defined(KISSAT_NOPTIONS)
+  (void) solver;
+#endif
+  return true;
+}
+
+int kissat_preprocess (struct kissat *solver) {
+  KISSAT_assert (kissat_preprocessing (solver));
+  if (!kissat_initially_propagate (solver)) {
+    KISSAT_assert (solver->inconsistent);
+    return 20;
+  }
+  START (preprocess);
+  KISSAT_assert (!solver->preprocessing);
+  solver->preprocessing = true;
+  REPORT (0, '(');
+  const unsigned max_rounds = GET_OPTION (preprocessrounds);
+#ifndef KISSAT_QUIET
+  const unsigned variables_initially = solver->active;
+  const uint64_t clauses_initially = BINIRR_CLAUSES;
+  const unsigned variables_originally = SIZE_STACK (solver->import);
+  const uint64_t clauses_originally = solver->statistics.clauses_original;
+  kissat_verbose (solver,
+                  "[preprocess] running at most %u preprocesing rounds",
+                  max_rounds);
+  kissat_verbose (
+      solver,
+      "[preprocess] initially %u variables %.0f%% and %" PRIu64
+      " clauses %.0f%%",
+      variables_initially,
+      kissat_percent (variables_initially, variables_originally),
+      clauses_initially,
+      kissat_percent (clauses_initially, clauses_originally));
+#endif
+  kissat_initial_sparse_collect (solver);
+  unsigned round = 1;
+  for (;;) {
+    if (solver->inconsistent)
+      break;
+    if (TERMINATED (preprocess_terminated_1))
+      break;
+    const unsigned variables_before = solver->active;
+    const uint64_t clauses_before = BINIRR_CLAUSES;
+#ifndef KISSAT_QUIET
+    kissat_verbose (solver,
+                    "[preprocess-%u] started preprocessing round %u", round,
+                    round);
+#endif
+    if (GET_OPTION (preprocessprobe))
+      kissat_probe_initially (solver);
+    if (GET_OPTION (fastel))
+      kissat_fast_variable_elimination (solver);
+    const unsigned variables_after = solver->active;
+    const uint64_t clauses_after = BINIRR_CLAUSES;
+#ifndef KISSAT_QUIET
+    if (variables_after < variables_before) {
+      unsigned removed = variables_before - variables_after;
+      kissat_verbose (
+          solver, "[preprocess-%u] removed %u variables %.0f%% in round %u",
+          round, removed, kissat_percent (removed, variables_before),
+          round);
+    } else if (variables_after > variables_before) {
+      unsigned added = variables_after - variables_before;
+      kissat_verbose (
+          solver, "[preprocess-%u] added %u variables %.0f%% in round %u",
+          round, added, kissat_percent (added, variables_before), round);
+    } else
+      kissat_verbose (
+          solver,
+          "[preprocess-%u] number variables %u unchanged in round %u",
+          round, variables_before, round);
+    if (clauses_after < clauses_before) {
+      uint64_t removed = clauses_before - clauses_after;
+      kissat_verbose (solver,
+                      "[preprocess-%u] removed %" PRIu64
+                      " irredundant and binary clauses %.0f%% in round %u",
+                      round, removed,
+                      kissat_percent (removed, clauses_before), round);
+    } else if (clauses_after > clauses_before) {
+      uint64_t added = clauses_after - clauses_before;
+      kissat_verbose (solver,
+                      "[preprocess-%u] added %" PRIu64
+                      " irredundant and binary clauses %.0f%% in round %u",
+                      round, added, kissat_percent (added, clauses_before),
+                      round);
+    } else
+      kissat_verbose (
+          solver,
+          "[preprocess-%u] number irredundant and binary clauses %" PRIu64
+          " unchanged in round %u",
+          round, clauses_before, round);
+#endif
+    if (round == max_rounds)
+      break;
+    if (variables_before == variables_after &&
+        clauses_before == clauses_after)
+      break;
+    round++;
+  }
+#ifndef KISSAT_QUIET
+  const unsigned variables_finally = solver->active;
+  const uint64_t clauses_finally = BINIRR_CLAUSES;
+  kissat_verbose (solver, "[preprocess] finished after %u rounds", round);
+  if (variables_finally < variables_initially) {
+    unsigned removed = variables_initially - variables_finally;
+    kissat_verbose (
+        solver,
+        "[preprocess] removed %u variables %.0f%% (%u remain %.0f%%)",
+        removed, kissat_percent (removed, variables_initially),
+        variables_finally,
+        kissat_percent (variables_finally, variables_originally));
+  } else if (variables_finally > variables_initially) {
+    unsigned added = variables_finally - variables_initially;
+    kissat_verbose (
+        solver, "[preprocess] added %u variables %.0f%% (%u remain %.0f%%)",
+        added, kissat_percent (added, variables_initially),
+        variables_finally,
+        kissat_percent (variables_finally, variables_originally));
+  } else
+    kissat_verbose (
+        solver,
+        "[preprocess] number variables %u unchanged (%u remain %.0f%%)",
+        variables_initially, variables_finally,
+        kissat_percent (variables_finally, variables_originally));
+  if (clauses_finally < clauses_initially) {
+    uint64_t removed = clauses_initially - clauses_finally;
+    kissat_verbose (solver,
+                    "[preprocess] removed %" PRIu64
+                    " irredundant and binary clauses %.0f%% (%" PRIu64
+                    " remain %.0f%%)",
+                    removed, kissat_percent (removed, clauses_initially),
+                    clauses_finally,
+                    kissat_percent (clauses_finally, clauses_originally));
+  } else if (clauses_finally > clauses_initially) {
+    uint64_t added = clauses_finally - clauses_initially;
+    kissat_verbose (solver,
+                    "[preprocess] added %" PRIu64
+                    " irredundant and binary clauses %.0f%% (%" PRIu64
+                    " remain %.0f%%)",
+                    added, kissat_percent (added, clauses_initially),
+                    clauses_finally,
+                    kissat_percent (clauses_finally, clauses_originally));
+  } else
+    kissat_verbose (
+        solver,
+        "[preprocess] number irredundant and binary clauses %" PRIu64
+        " unchanged (%" PRIu64 " remain %.0f%%)",
+        clauses_initially, clauses_finally,
+        kissat_percent (clauses_finally, clauses_originally));
+#endif
+  REPORT (0, ')');
+  KISSAT_assert (solver->preprocessing);
+  solver->preprocessing = false;
+  STOP (preprocess);
+  return solver->inconsistent ? 20 : 0;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/preprocess.h b/src/sat/kissat/preprocess.h
new file mode 100644
index 000000000..7826a656e
--- /dev/null
+++ b/src/sat/kissat/preprocess.h
@@ -0,0 +1,15 @@
+#ifndef _kissat_preprocess_h_INCLUDED
+#define _kissat_preprocess_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+bool kissat_preprocessing (struct kissat *);
+int kissat_preprocess (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/print.c b/src/sat/kissat/print.c
new file mode 100644
index 000000000..3d50141fd
--- /dev/null
+++ b/src/sat/kissat/print.c
@@ -0,0 +1,174 @@
+#include "global.h"
+
+#ifndef KISSAT_QUIET
+
+#include "print.h"
+#include "colors.h"
+#include "handle.h"
+#include "internal.h"
+
+#include <inttypes.h>
+#include <stdarg.h>
+#include <string.h>
+
+static inline int verbosity (kissat *solver) {
+  if (!solver)
+    return -1;
+#ifdef LOGGING
+  if (GET_OPTION (log))
+    return 3;
+#endif
+#ifndef KISSAT_QUIET
+  if (GET_OPTION (quiet))
+    return -1;
+  return GET_OPTION (verbose);
+#else
+  return 0;
+#endif
+}
+
+void kissat_warning (kissat *solver, const char *fmt, ...) {
+  if (verbosity (solver) < 0)
+    return;
+  TERMINAL (stdout, 1);
+  fputs (solver->prefix, stdout);
+  COLOR (BOLD YELLOW);
+  fputs ("warning:", stdout);
+  COLOR (NORMAL);
+  fputc (' ', stdout);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+#ifdef KISSAT_NOPTIONS
+  (void) solver;
+#endif
+}
+
+void kissat_signal (kissat *solver, const char *type, int sig) {
+  if (verbosity (solver) < 0)
+    return;
+  TERMINAL (stdout, 1);
+  fputs (solver->prefix, stdout);
+  COLOR (BOLD RED);
+  printf ("%s signal %d (%s)", type, sig, kissat_signal_name (sig));
+  COLOR (NORMAL);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+static void print_message (kissat *solver, const char *color,
+                           const char *fmt, va_list *ap) {
+  TERMINAL (stdout, 1);
+  fputs (solver->prefix, stdout);
+  COLOR (color);
+  vprintf (fmt, *ap);
+  fputc ('\n', stdout);
+  COLOR (NORMAL);
+  fflush (stdout);
+}
+
+static void print_line (kissat *solver) {
+  char ch;
+  for (const char *p = solver->prefix; (ch = *p); p++)
+    if (ch && (ch != ' ' || p[1]))
+      fputc (ch, stdout);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+int kissat_verbosity (kissat *solver) { return verbosity (solver); }
+
+void kissat_message (kissat *solver, const char *fmt, ...) {
+  if (verbosity (solver) < 0)
+    return;
+  va_list ap;
+  va_start (ap, fmt);
+  print_message (solver, "", fmt, &ap);
+  va_end (ap);
+}
+
+void kissat_line (kissat *solver) {
+  if (verbosity (solver) >= 0)
+    print_line (solver);
+}
+
+void kissat_prefix (kissat *solver) { fputs (solver->prefix, stdout); }
+
+void kissat_verbose (kissat *solver, const char *fmt, ...) {
+  if (verbosity (solver) < 1)
+    return;
+  va_list ap;
+  va_start (ap, fmt);
+  print_message (solver, LIGHT_GRAY, fmt, &ap);
+  va_end (ap);
+}
+
+void kissat_very_verbose (kissat *solver, const char *fmt, ...) {
+  if (verbosity (solver) < 2)
+    return;
+  va_list ap;
+  va_start (ap, fmt);
+  print_message (solver, DARK_GRAY, fmt, &ap);
+  va_end (ap);
+}
+
+void kissat_extremely_verbose (kissat *solver, const char *fmt, ...) {
+  if (verbosity (solver) < 3)
+    return;
+  va_list ap;
+  va_start (ap, fmt);
+  print_message (solver, DARK_GRAY, fmt, &ap);
+  va_end (ap);
+}
+
+void kissat_section (kissat *solver, const char *name) {
+  if (verbosity (solver) < 0)
+    return;
+  TERMINAL (stdout, 1);
+  if (solver->sectioned)
+    kissat_line (solver);
+  else
+    solver->sectioned = true;
+  fputs (solver->prefix, stdout);
+  COLOR (BLUE);
+  fputs ("---- [ ", stdout);
+  COLOR (BOLD BLUE);
+  fputs (name, stdout);
+  COLOR (NORMAL BLUE);
+  fputs (" ] ", stdout);
+  for (size_t i = strlen (name); i < 66; i++)
+    fputc ('-', stdout);
+  COLOR (NORMAL);
+  fputc ('\n', stdout);
+  print_line (solver);
+  fflush (stdout);
+}
+
+void kissat_phase (kissat *solver, const char *name, uint64_t count,
+                   const char *fmt, ...) {
+  if (verbosity (solver) < 1)
+    return;
+  TERMINAL (stdout, 1);
+  fputs (solver->prefix, stdout);
+  if (solver->stable)
+    COLOR (CYAN);
+  else
+    COLOR (BOLD CYAN);
+  printf ("[%s", name);
+  if (count != UINT64_MAX)
+    printf ("-%" PRIu64, count);
+  fputs ("] ", stdout);
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  COLOR (NORMAL);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#else
+int kissat_print_dummy_to_avoid_warning;
+#endif
diff --git a/src/sat/kissat/print.h b/src/sat/kissat/print.h
new file mode 100644
index 000000000..941e94c50
--- /dev/null
+++ b/src/sat/kissat/print.h
@@ -0,0 +1,70 @@
+// clang-format off
+
+#ifndef _print_h_INCLUDED
+#define _print_h_INCLUDED
+
+#include <stdint.h>
+
+#include "attribute.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifndef KISSAT_QUIET
+
+struct kissat;
+
+int kissat_verbosity (struct kissat *);
+
+void kissat_line (struct kissat *);
+void kissat_prefix (struct kissat*);
+void kissat_signal (struct kissat *, const char *type, int sig);
+void kissat_section (struct kissat *, const char *name);
+
+void
+kissat_message (struct kissat *, const char *fmt, ...)
+ATTRIBUTE_FORMAT (2, 3);
+
+void kissat_verbose (struct kissat *, const char *fmt, ...)
+ATTRIBUTE_FORMAT (2, 3);
+
+void kissat_very_verbose (struct kissat *, const char *fmt, ...)
+ATTRIBUTE_FORMAT (2, 3);
+
+void kissat_extremely_verbose (struct kissat *, const char *fmt, ...)
+ATTRIBUTE_FORMAT (2, 3);
+
+void kissat_warning (struct kissat *, const char *fmt, ...)
+ATTRIBUTE_FORMAT (2, 3);
+
+void kissat_phase (struct kissat *, const char *name, uint64_t,
+		   const char * fmt, ...)
+ATTRIBUTE_FORMAT (4, 5);
+
+#else
+
+#define kissat_line(...) do { } while (0)
+#define kissat_message(...) do { } while (0)
+#define kissat_phase(...) do { } while (0)
+#define kissat_section(...) do { } while (0)
+#define kissat_signal(...) do { } while (0)
+#define kissat_verbose(...) do { } while (0)
+#define kissat_very_verbose(...) do { } while (0)
+#define kissat_extremely_verbose(...) do { } while (0)
+#define kissat_warning(...) do { } while (0)
+
+#endif
+
+#define VERY_VERBOSE_OR_LOG(ONLY_LOG, SOLVER, ...) \
+do { \
+  if (ONLY_LOG) \
+    LOG (__VA_ARGS__); \
+  else \
+    kissat_very_verbose (SOLVER, __VA_ARGS__); \
+} while (0)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+// clang-format on
diff --git a/src/sat/kissat/probe.c b/src/sat/kissat/probe.c
new file mode 100644
index 000000000..f77ba6619
--- /dev/null
+++ b/src/sat/kissat/probe.c
@@ -0,0 +1,108 @@
+#include "probe.h"
+#include "backbone.h"
+#include "backtrack.h"
+#include "congruence.h"
+#include "factor.h"
+#include "internal.h"
+#include "print.h"
+#include "substitute.h"
+#include "sweep.h"
+#include "terminate.h"
+#include "transitive.h"
+#include "vivify.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_probing (kissat *solver) {
+  if (!solver->enabled.probe)
+    return false;
+  statistics *statistics = &solver->statistics_;
+  const uint64_t conflicts = statistics->conflicts;
+  if (solver->last.conflicts.reduce == conflicts)
+    return false;
+  return solver->limits.probe.conflicts < conflicts;
+}
+
+static void probe (kissat *solver) {
+  kissat_backtrack_propagate_and_flush_trail (solver);
+  KISSAT_assert (!solver->inconsistent);
+  STOP_SEARCH_AND_START_SIMPLIFIER (probe);
+  kissat_phase (solver, "probe", GET (probings),
+                "probing limit hit after %" PRIu64 " conflicts",
+                solver->limits.probe.conflicts);
+  kissat_congruence (solver);
+  kissat_substitute (solver, false);
+  kissat_binary_clauses_backbone (solver);
+  kissat_vivify (solver);
+  kissat_sweep (solver);
+  kissat_substitute (solver, false);
+  kissat_transitive_reduction (solver);
+  kissat_binary_clauses_backbone (solver);
+  kissat_factor (solver);
+  STOP_SIMPLIFIER_AND_RESUME_SEARCH (probe);
+}
+
+static void probe_initially (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->inconsistent);
+  kissat_phase (solver, "probe", GET (probings), "initial probing");
+  bool substitute_at_the_end = true;
+  if (GET_OPTION (preprocesscongruence)) {
+    if (kissat_congruence (solver)) {
+      kissat_substitute (solver, true);
+      substitute_at_the_end = false;
+    }
+  }
+  if (GET_OPTION (preprocessbackbone))
+    kissat_binary_clauses_backbone (solver);
+  if (GET_OPTION (preprocessweep)) {
+    if (kissat_sweep (solver)) {
+      kissat_substitute (solver, true);
+      substitute_at_the_end = false;
+    }
+  }
+  if (substitute_at_the_end)
+    kissat_substitute (solver, false);
+  if (GET_OPTION (preprocessfactor))
+    kissat_factor (solver);
+}
+
+int kissat_probe (kissat *solver) {
+  KISSAT_assert (!solver->inconsistent);
+  INC (probings);
+  KISSAT_assert (!solver->probing);
+  solver->probing = true;
+  const unsigned max_rounds = GET_OPTION (proberounds);
+  for (unsigned round = 0; round != max_rounds; round++) {
+    unsigned before = solver->active;
+    probe (solver);
+    if (solver->inconsistent)
+      break;
+    if (before == solver->active)
+      break;
+  }
+  kissat_classify (solver);
+  UPDATE_CONFLICT_LIMIT (probe, probings, NLOGN, true);
+  solver->last.ticks.probe = solver->statistics_.search_ticks;
+  KISSAT_assert (solver->probing);
+  solver->probing = false;
+  return solver->inconsistent ? 20 : 0;
+}
+
+int kissat_probe_initially (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->inconsistent);
+  INC (probings);
+  START (probe);
+  KISSAT_assert (!solver->probing);
+  solver->probing = true;
+  probe_initially (solver);
+  KISSAT_assert (solver->probing);
+  solver->probing = false;
+  STOP (probe);
+  return solver->inconsistent ? 20 : 0;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/probe.h b/src/sat/kissat/probe.h
new file mode 100644
index 000000000..8226325fb
--- /dev/null
+++ b/src/sat/kissat/probe.h
@@ -0,0 +1,17 @@
+#ifndef _probe_h_INCLUDED
+#define _probe_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_probing (struct kissat *);
+int kissat_probe (struct kissat *);
+int kissat_probe_initially (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/profile.c b/src/sat/kissat/profile.c
new file mode 100644
index 000000000..d301e8cbb
--- /dev/null
+++ b/src/sat/kissat/profile.c
@@ -0,0 +1,150 @@
+#include "global.h"
+
+#ifndef KISSAT_QUIET
+
+#include "internal.h"
+#include "resources.h"
+#include "sort.h"
+
+#include <stdio.h>
+#include <string.h>
+
+void kissat_init_profiles (profiles *profiles) {
+#define PROF(NAME, LEVEL) profiles->NAME = (profile){LEVEL, #NAME, 0, 0};
+  PROFS
+#undef PROF
+}
+
+#define SIZE_PROFS (sizeof (profiles) / sizeof (profile))
+
+static inline bool less_profile (profile *p, profile *q) {
+  if (p->time > q->time)
+    return true;
+  if (p->time < q->time)
+    return false;
+  return strcmp (p->name, q->name) < 0;
+}
+
+static void print_profile (kissat *solver, profile *p, double total) {
+  printf ("%s%14.2f %7.2f %%  %s\n", solver->prefix, p->time,
+          kissat_percent (p->time, total), p->name);
+}
+
+static double flush_profile (profile *profile, double now) {
+  const double delta = now - profile->entered;
+  profile->time += delta;
+  profile->entered = now;
+  return delta;
+}
+
+static void flush_profiles (profiles *profiles, const double now) {
+  for (all_pointers (profile, p, profiles->stack))
+    flush_profile (p, now);
+}
+
+static void push_profile (kissat *solver, profile *profile, double now) {
+  profile->entered = now;
+  PUSH_STACK (solver->profiles.stack, profile);
+}
+
+void kissat_profiles_print (kissat *solver) {
+  profiles *named = &solver->profiles;
+  double now = kissat_process_time ();
+  flush_profiles (named, now);
+  profile *unsorted = (profile *) named;
+  profile *sorted[SIZE_PROFS];
+  const profile *const end = unsorted + SIZE_PROFS;
+  size_t size = 0;
+  for (profile *p = unsorted; p != end; p++)
+    if (p->level <= GET_OPTION (profile) &&
+        (p == &named->search || p == &named->simplify ||
+         (p != &named->total && p->time)))
+      sorted[size++] = p;
+  INSERTION_SORT (profile *, size, sorted, less_profile);
+  const double total = named->total.time;
+  for (size_t i = 0; i < size; i++)
+    print_profile (solver, sorted[i], total);
+  printf ("%s=============================================\n",
+          solver->prefix);
+  print_profile (solver, &named->total, total);
+}
+
+void kissat_start (kissat *solver, profile *profile) {
+  const double now = kissat_process_time ();
+  push_profile (solver, profile, now);
+}
+
+void kissat_stop (kissat *solver, profile *profile) {
+  KISSAT_assert (TOP_STACK (solver->profiles.stack) == profile);
+  (void) POP_STACK (solver->profiles.stack);
+  const double now = kissat_process_time ();
+  flush_profile (profile, now);
+}
+
+void kissat_stop_search_and_start_simplifier (kissat *solver,
+                                              profile *profile) {
+  struct profile *search = &PROFILE (search);
+  KISSAT_assert (search->level <= GET_OPTION (profile));
+  const double now = kissat_process_time ();
+  while (TOP_STACK (solver->profiles.stack) != search) {
+    struct profile *mode = POP_STACK (solver->profiles.stack);
+    KISSAT_assert (search->level <= mode->level);
+#ifndef KISSAT_NDEBUG
+    if (solver->stable)
+      KISSAT_assert (mode == &PROFILE (stable));
+    else
+      KISSAT_assert (mode == &PROFILE (focused));
+#endif
+    flush_profile (mode, now);
+  }
+  (void) POP_STACK (solver->profiles.stack);
+  struct profile *simplify = &PROFILE (simplify);
+  KISSAT_assert (search->level == simplify->level);
+  KISSAT_assert (simplify->level <= profile->level);
+  flush_profile (search, now);
+  push_profile (solver, simplify, now);
+  if (profile->level <= GET_OPTION (profile))
+    push_profile (solver, profile, now);
+}
+
+void kissat_stop_simplifier_and_resume_search (kissat *solver,
+                                               profile *profile) {
+  struct profile *simplify = &PROFILE (simplify);
+  struct profile *top = POP_STACK (solver->profiles.stack);
+  const double now = kissat_process_time ();
+  const double delta = flush_profile (simplify, now);
+#ifndef KISSAT_NDEBUG
+  const double entered = now - delta;
+  KISSAT_assert (solver->mode.entered <= entered);
+#endif
+  solver->mode.entered += delta;
+  if (top == profile) {
+    flush_profile (profile, now);
+    KISSAT_assert (TOP_STACK (solver->profiles.stack) == simplify);
+    (void) POP_STACK (solver->profiles.stack);
+  } else {
+    KISSAT_assert (simplify == top);
+    KISSAT_assert (profile->level > GET_OPTION (profile));
+  }
+#ifndef KISSAT_NDEBUG
+  struct profile *search = &PROFILE (search);
+  KISSAT_assert (search->level == simplify->level);
+#endif
+  KISSAT_assert (simplify->level <= profile->level);
+  push_profile (solver, &PROFILE (search), now);
+  struct profile *mode =
+      solver->stable ? &PROFILE (stable) : &PROFILE (focused);
+  KISSAT_assert (search->level <= mode->level);
+  if (mode->level <= GET_OPTION (profile))
+    push_profile (solver, mode, now);
+}
+
+double kissat_time (kissat *solver) {
+  const double now = kissat_process_time ();
+  flush_profiles (&solver->profiles, now);
+  return PROFILE (total).time;
+}
+
+#else
+int kissat_profile_dummy_to_avoid_warning;
+#endif
diff --git a/src/sat/kissat/profile.h b/src/sat/kissat/profile.h
new file mode 100644
index 000000000..155724f26
--- /dev/null
+++ b/src/sat/kissat/profile.h
@@ -0,0 +1,148 @@
+#ifndef _profile_h_INCLUDED
+#define _profile_h_INCLUDED
+
+#include "stack.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifndef KISSAT_QUIET
+
+typedef struct profile profile;
+typedef struct profiles profiles;
+
+#define PROFS \
+  PROF (analyze, 3) \
+  PROF (backbone, 2) \
+  PROF (bump, 3) \
+  PROF (collect, 3) \
+  PROF (congruence, 2) \
+  PROF (decide, 4) \
+  PROF (deduce, 3) \
+  PROF (definition, 3) \
+  PROF (defrag, 3) \
+  PROF (dominate, 4) \
+  PROF (eliminate, 2) \
+  PROF (extend, 2) \
+  PROF (extract, 3) \
+  PROF (extractands, 3) \
+  PROF (extractbinaries, 3) \
+  PROF (extractites, 3) \
+  PROF (extractxors, 3) \
+  PROF (factor, 2) \
+  PROF (fastel, 2) \
+  PROF (focused, 2) \
+  PROF (forward, 4) \
+  PROF (lucky, 2) \
+  PROF (matching, 3) \
+  PROF (merge, 3) \
+  PROF (minimize, 3) \
+  PROF (parse, 1) \
+  PROF (preprocess, 2) \
+  PROF (probe, 2) \
+  PROF (propagate, 4) \
+  PROF (radix, 4) \
+  PROF (reduce, 2) \
+  PROF (reorder, 3) \
+  PROF (rephase, 3) \
+  PROF (restart, 3) \
+  PROF (search, 1) \
+  PROF (shrink, 3) \
+  PROF (simplify, 1) \
+  PROF (sort, 4) \
+  PROF (stable, 2) \
+  PROF (substitute, 2) \
+  PROF (subsume, 2) \
+  PROF (sweep, 2) \
+  PROF (sweepbackbone, 3) \
+  PROF (sweepequivalences, 3) \
+  PROF (total, 0) \
+  PROF (transitive, 2) \
+  PROF (vivify, 2) \
+  PROF (vivify0, 3) \
+  PROF (vivify1, 3) \
+  PROF (vivify2, 3) \
+  PROF (vivify3, 3) \
+  PROF (vivifysort, 4) \
+  PROF (walking, 2) \
+  PROF (warmup, 3)
+
+struct profile {
+  int level;
+  const char *name;
+  double entered;
+  double time;
+};
+
+struct profiles {
+#define PROF(NAME, LEVEL) profile NAME;
+  PROFS
+#undef PROF
+  STACK (profile *) stack;
+};
+
+struct kissat;
+
+void kissat_init_profiles (profiles *);
+void kissat_profiles_print (struct kissat *);
+void kissat_start (struct kissat *, profile *);
+void kissat_stop (struct kissat *, profile *);
+
+void kissat_stop_search_and_start_simplifier (struct kissat *, profile *);
+void kissat_stop_simplifier_and_resume_search (struct kissat *, profile *);
+
+double kissat_time (struct kissat *);
+
+#define PROFILE(NAME) (solver->profiles.NAME)
+
+#define START(NAME) \
+  do { \
+    profile *profile = &PROFILE (NAME); \
+    if (GET_OPTION (profile) >= profile->level) \
+      kissat_start (solver, profile); \
+  } while (0)
+
+#define STOP(NAME) \
+  do { \
+    profile *profile = &PROFILE (NAME); \
+    if (GET_OPTION (profile) >= profile->level) \
+      kissat_stop (solver, profile); \
+  } while (0)
+
+#define STOP_SEARCH_AND_START_SIMPLIFIER(NAME) \
+  do { \
+    if (GET_OPTION (profile) >= PROFILE (search).level) \
+      kissat_stop_search_and_start_simplifier (solver, &PROFILE (NAME)); \
+  } while (0)
+
+#define STOP_SIMPLIFIER_AND_RESUME_SEARCH(NAME) \
+  do { \
+    if (GET_OPTION (profile) >= PROFILE (search).level) \
+      kissat_stop_simplifier_and_resume_search (solver, &PROFILE (NAME)); \
+  } while (0)
+
+#else
+
+#define START(...) \
+  do { \
+  } while (0)
+#define STOP(...) \
+  do { \
+  } while (0)
+
+#define STOP_SEARCH_AND_START_SIMPLIFIER(...) \
+  do { \
+  } while (0)
+#define STOP_SIMPLIFIER_AND_RESUME_SEARCH(...) \
+  do { \
+  } while (0)
+
+#define STOP_AND_START(...) \
+  do { \
+  } while (0)
+
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/promote.c b/src/sat/kissat/promote.c
new file mode 100644
index 000000000..19d519596
--- /dev/null
+++ b/src/sat/kissat/promote.c
@@ -0,0 +1,46 @@
+#include "promote.h"
+#include "internal.h"
+#include "logging.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_promote_clause (kissat *solver, clause *c, unsigned new_glue) {
+  if (!GET_OPTION (promote))
+    return;
+  KISSAT_assert (c->redundant);
+  const unsigned old_glue = c->glue;
+  KISSAT_assert (new_glue < old_glue);
+  const unsigned tier1 = TIER1;
+  const unsigned tier2 = MAX (TIER2, TIER1);
+  if (old_glue <= tier1) {
+    LOGCLS (c, "keeping with new glue %u in tier1", new_glue);
+    INC (clauses_kept1);
+  } else if (new_glue <= tier1) {
+    KISSAT_assert (tier1 < old_glue);
+    KISSAT_assert (new_glue <= tier1);
+    LOGCLS (c, "promoting with new glue %u to tier1", new_glue);
+    INC (clauses_promoted1);
+  } else if (tier2 < old_glue && new_glue <= tier2) {
+    KISSAT_assert (tier2 < old_glue);
+    KISSAT_assert (tier1 < new_glue), KISSAT_assert (new_glue <= tier2);
+    LOGCLS (c, "promoting with new glue %u to tier2", new_glue);
+    INC (clauses_promoted2);
+  } else if (old_glue <= tier2) {
+    KISSAT_assert (tier1 < old_glue), KISSAT_assert (old_glue <= tier2);
+    KISSAT_assert (tier1 < new_glue), KISSAT_assert (new_glue <= tier2);
+    LOGCLS (c, "keeping with new glue %u in tier2", new_glue);
+    INC (clauses_kept2);
+  } else {
+    KISSAT_assert (tier2 < old_glue);
+    KISSAT_assert (tier2 < new_glue);
+    LOGCLS (c, "keeping with new glue %u in tier3", new_glue);
+    INC (clauses_kept3);
+  }
+  INC (clauses_improved);
+  c->glue = new_glue;
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/promote.h b/src/sat/kissat/promote.h
new file mode 100644
index 000000000..0d96577bf
--- /dev/null
+++ b/src/sat/kissat/promote.h
@@ -0,0 +1,38 @@
+#ifndef _promote_h_INCLUDED
+#define _promote_h_INCLUDED
+
+#include "internal.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+void kissat_promote_clause (struct kissat *, clause *, unsigned new_glue);
+
+static inline unsigned kissat_recompute_glue (kissat *solver, clause *c,
+                                              unsigned limit) {
+  KISSAT_assert (limit);
+  KISSAT_assert (EMPTY_STACK (solver->promote));
+  unsigned res = 0;
+  for (all_literals_in_clause (lit, c)) {
+    KISSAT_assert (VALUE (lit));
+    const unsigned level = LEVEL (lit);
+    frame *frame = &FRAME (level);
+    if (frame->promote)
+      continue;
+    if (++res == limit)
+      break;
+    frame->promote = true;
+    PUSH_STACK (solver->promote, level);
+  }
+  for (all_stack (unsigned, level, solver->promote)) {
+    frame *frame = &FRAME (level);
+    KISSAT_assert (frame->promote);
+    frame->promote = false;
+  }
+  CLEAR_STACK (solver->promote);
+  return res;
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/proof.c b/src/sat/kissat/proof.c
new file mode 100644
index 000000000..769655de8
--- /dev/null
+++ b/src/sat/kissat/proof.c
@@ -0,0 +1,410 @@
+#include "global.h"
+
+#ifndef KISSAT_NPROOFS
+
+#include "allocate.h"
+#include "error.h"
+#include "file.h"
+#include "inline.h"
+
+#undef KISSAT_NDEBUG
+
+#ifndef KISSAT_NDEBUG
+#include <string.h>
+#endif
+
+#define size_buffer (1u << 20)
+
+struct write_buffer {
+  unsigned char chars[size_buffer];
+  size_t pos;
+};
+
+typedef struct write_buffer write_buffer;
+
+struct proof {
+  write_buffer buffer;
+  kissat *solver;
+  bool binary;
+  file *file;
+  ints line;
+  uint64_t added;
+  uint64_t deleted;
+  uint64_t lines;
+  uint64_t literals;
+#ifndef KISSAT_NDEBUG
+  bool empty;
+  char *units;
+  size_t size_units;
+#endif
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+  unsigneds imported;
+#endif
+};
+
+#undef LOGPREFIX
+#define LOGPREFIX "PROOF"
+
+#define LOGIMPORTED3(...) \
+  LOGLITS3 (SIZE_STACK (proof->imported), BEGIN_STACK (proof->imported), \
+            __VA_ARGS__)
+
+#define LOGLINE3(...) \
+  LOGINTS3 (SIZE_STACK (proof->line), BEGIN_STACK (proof->line), \
+            __VA_ARGS__)
+
+void kissat_init_proof (kissat *solver, file *file, bool binary) {
+  KISSAT_assert (file);
+  KISSAT_assert (!solver->proof);
+  proof *proof = kissat_calloc (solver, 1, sizeof (struct proof));
+  proof->binary = binary;
+  proof->file = file;
+  proof->solver = solver;
+  solver->proof = proof;
+  LOG ("starting to trace %s proof", binary ? "binary" : "non-binary");
+}
+
+static void flush_buffer (proof *proof) {
+  size_t bytes = proof->buffer.pos;
+  if (!bytes)
+    return;
+  size_t written = kissat_write (proof->file, proof->buffer.chars, bytes);
+  if (bytes != written)
+    kissat_fatal ("flushing %zu bytes in proof write-buffer failed", bytes);
+  proof->buffer.pos = 0;
+}
+
+void kissat_release_proof (kissat *solver) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  LOG ("stopping to trace proof");
+  flush_buffer (proof);
+  kissat_flush (proof->file);
+  RELEASE_STACK (proof->line);
+#ifndef KISSAT_NDEBUG
+  kissat_free (solver, proof->units, proof->size_units);
+#endif
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+  RELEASE_STACK (proof->imported);
+#endif
+  kissat_free (solver, proof, sizeof (struct proof));
+  solver->proof = 0;
+}
+
+#ifndef KISSAT_QUIET
+
+#include <inttypes.h>
+
+#define PERCENT_LINES(NAME) kissat_percent (proof->NAME, proof->lines)
+
+void kissat_print_proof_statistics (kissat *solver, bool verbose) {
+  proof *proof = solver->proof;
+  PRINT_STAT ("proof_added", proof->added, PERCENT_LINES (added), "%",
+              "per line");
+  PRINT_STAT ("proof_bytes", proof->file->bytes,
+              proof->file->bytes / (double) (1 << 20), "MB", "");
+  PRINT_STAT ("proof_deleted", proof->deleted, PERCENT_LINES (deleted), "%",
+              "per line");
+  if (verbose)
+    PRINT_STAT ("proof_lines", proof->lines, 100, "%", "");
+  if (verbose)
+    PRINT_STAT ("proof_literals", proof->literals,
+                kissat_average (proof->literals, proof->lines), "",
+                "per line");
+}
+
+#endif
+
+// clang-format off
+
+static inline void write_char (proof *, unsigned char)
+  ATTRIBUTE_ALWAYS_INLINE;
+
+static inline void import_external_proof_literal (kissat *, proof *, int)
+  ATTRIBUTE_ALWAYS_INLINE;
+
+static inline void
+import_internal_proof_literal (kissat *, proof *, unsigned)
+  ATTRIBUTE_ALWAYS_INLINE;
+
+// clang-format on
+
+static inline void write_char (proof *proof, unsigned char ch) {
+  write_buffer *buffer = &proof->buffer;
+  if (buffer->pos == size_buffer)
+    flush_buffer (proof);
+  buffer->chars[buffer->pos++] = ch;
+}
+
+static inline void import_internal_proof_literal (kissat *solver,
+                                                  proof *proof,
+                                                  unsigned ilit) {
+  int elit = kissat_export_literal (solver, ilit);
+  KISSAT_assert (elit);
+  PUSH_STACK (proof->line, elit);
+  proof->literals++;
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+  PUSH_STACK (proof->imported, ilit);
+#endif
+}
+
+static inline void import_external_proof_literal (kissat *solver,
+                                                  proof *proof, int elit) {
+  KISSAT_assert (elit);
+  PUSH_STACK (proof->line, elit);
+  proof->literals++;
+#ifndef KISSAT_NDEBUG
+  KISSAT_assert (EMPTY_STACK (proof->imported));
+#endif
+}
+
+static void import_internal_proof_binary (kissat *solver, proof *proof,
+                                          unsigned a, unsigned b) {
+  KISSAT_assert (EMPTY_STACK (proof->line));
+  import_internal_proof_literal (solver, proof, a);
+  import_internal_proof_literal (solver, proof, b);
+}
+
+static void import_internal_proof_literals (kissat *solver, proof *proof,
+                                            size_t size,
+                                            const unsigned *ilits) {
+  KISSAT_assert (EMPTY_STACK (proof->line));
+  KISSAT_assert (size <= UINT_MAX);
+  for (size_t i = 0; i < size; i++)
+    import_internal_proof_literal (solver, proof, ilits[i]);
+}
+
+static void import_external_proof_literals (kissat *solver, proof *proof,
+                                            size_t size, const int *elits) {
+  KISSAT_assert (EMPTY_STACK (proof->line));
+  KISSAT_assert (size <= UINT_MAX);
+  for (size_t i = 0; i < size; i++)
+    import_external_proof_literal (solver, proof, elits[i]);
+}
+
+static void import_proof_clause (kissat *solver, proof *proof,
+                                 const clause *c) {
+  import_internal_proof_literals (solver, proof, c->size, c->lits);
+}
+
+static void print_binary_proof_line (proof *proof) {
+  KISSAT_assert (proof->binary);
+  for (all_stack (int, elit, proof->line)) {
+    unsigned x = 2u * ABS (elit) + (elit < 0);
+    unsigned char ch;
+    while (x & ~0x7f) {
+      ch = (x & 0x7f) | 0x80;
+      write_char (proof, ch);
+      x >>= 7;
+    }
+    write_char (proof, x);
+  }
+  write_char (proof, 0);
+}
+
+static void print_non_binary_proof_line (proof *proof) {
+  KISSAT_assert (!proof->binary);
+  char buffer[16];
+  char *end_of_buffer = buffer + sizeof buffer;
+  *--end_of_buffer = 0;
+  for (all_stack (int, elit, proof->line)) {
+    char *p = end_of_buffer;
+    KISSAT_assert (!*p);
+    KISSAT_assert (elit);
+    KISSAT_assert (elit != INT_MIN);
+    unsigned eidx;
+    if (elit < 0) {
+      write_char (proof, '-');
+      eidx = -elit;
+    } else
+      eidx = elit;
+    for (unsigned tmp = eidx; tmp; tmp /= 10)
+      *--p = '0' + (tmp % 10);
+    while (p != end_of_buffer)
+      write_char (proof, *p++);
+    write_char (proof, ' ');
+  }
+  write_char (proof, '0');
+  write_char (proof, '\n');
+}
+
+static void print_proof_line (proof *proof) {
+  proof->lines++;
+  if (proof->binary)
+    print_binary_proof_line (proof);
+  else
+    print_non_binary_proof_line (proof);
+  CLEAR_STACK (proof->line);
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+  CLEAR_STACK (proof->imported);
+#endif
+#ifndef KISSAT_NOPTIONS
+  kissat *solver = proof->solver;
+#endif
+  if (GET_OPTION (flushproof)) {
+    flush_buffer (proof);
+    kissat_flush (proof->file);
+  }
+}
+
+#ifndef KISSAT_NDEBUG
+
+static unsigned external_to_proof_literal (int elit) {
+  KISSAT_assert (elit);
+  KISSAT_assert (elit != INT_MIN);
+  return 2u * (abs (elit) - 1) + (elit < 0);
+}
+
+static void resize_proof_units (proof *proof, unsigned plit) {
+  kissat *solver = proof->solver;
+  const size_t old_size = proof->size_units;
+  size_t new_size = old_size ? old_size : 2;
+  while (new_size <= plit)
+    new_size *= 2;
+  char *new_units = kissat_calloc (solver, new_size, 1);
+  if (old_size)
+    memcpy (new_units, proof->units, old_size);
+  kissat_dealloc (solver, proof->units, old_size, 1);
+  proof->units = new_units;
+  proof->size_units = new_size;
+}
+
+static void check_repeated_proof_lines (proof *proof) {
+  size_t size = SIZE_STACK (proof->line);
+  if (!size) {
+    KISSAT_assert (!proof->empty);
+    proof->empty = true;
+  } else if (size == 1) {
+    const int eunit = PEEK_STACK (proof->line, 0);
+    const unsigned punit = external_to_proof_literal (eunit);
+    KISSAT_assert (punit != INVALID_LIT);
+    if (!proof->size_units || proof->size_units <= punit)
+      resize_proof_units (proof, punit);
+    proof->units[punit] = 1;
+  }
+}
+
+#endif
+
+static void print_added_proof_line (proof *proof) {
+  proof->added++;
+#ifdef LOGGING
+  struct kissat *solver = proof->solver;
+  KISSAT_assert (SIZE_STACK (proof->imported) == SIZE_STACK (proof->line));
+  LOGIMPORTED3 ("added proof line");
+  LOGLINE3 ("added proof line");
+#endif
+#ifndef KISSAT_NDEBUG
+  check_repeated_proof_lines (proof);
+#endif
+  if (proof->binary)
+    write_char (proof, 'a');
+  print_proof_line (proof);
+}
+
+static void print_delete_proof_line (proof *proof) {
+  proof->deleted++;
+#ifdef LOGGING
+  struct kissat *solver = proof->solver;
+  if (SIZE_STACK (proof->imported) == SIZE_STACK (proof->line))
+    LOGIMPORTED3 ("deleted internal proof line");
+  LOGLINE3 ("deleted external proof line");
+#endif
+  write_char (proof, 'd');
+  if (!proof->binary)
+    write_char (proof, ' ');
+  print_proof_line (proof);
+}
+
+void kissat_add_binary_to_proof (kissat *solver, unsigned a, unsigned b) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  import_internal_proof_binary (solver, proof, a, b);
+  print_added_proof_line (proof);
+}
+
+void kissat_add_clause_to_proof (kissat *solver, const clause *c) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  import_proof_clause (solver, proof, c);
+  print_added_proof_line (proof);
+}
+
+void kissat_add_empty_to_proof (kissat *solver) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  KISSAT_assert (EMPTY_STACK (proof->line));
+  print_added_proof_line (proof);
+}
+
+void kissat_add_lits_to_proof (kissat *solver, size_t size,
+                               const unsigned *ilits) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  import_internal_proof_literals (solver, proof, size, ilits);
+  print_added_proof_line (proof);
+}
+
+void kissat_add_unit_to_proof (kissat *solver, unsigned ilit) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  KISSAT_assert (EMPTY_STACK (proof->line));
+  import_internal_proof_literal (solver, proof, ilit);
+  print_added_proof_line (proof);
+}
+
+void kissat_shrink_clause_in_proof (kissat *solver, const clause *c,
+                                    unsigned remove, unsigned keep) {
+  proof *proof = solver->proof;
+  const value *const values = solver->values;
+  KISSAT_assert (EMPTY_STACK (proof->line));
+  const unsigned *ilits = c->lits;
+  const unsigned size = c->size;
+  for (unsigned i = 0; i != size; i++) {
+    const unsigned ilit = ilits[i];
+    if (ilit == remove)
+      continue;
+    if (ilit != keep && values[ilit] < 0 && !LEVEL (ilit))
+      continue;
+    import_internal_proof_literal (solver, proof, ilit);
+  }
+  print_added_proof_line (proof);
+  import_proof_clause (solver, proof, c);
+  print_delete_proof_line (proof);
+}
+
+void kissat_delete_binary_from_proof (kissat *solver, unsigned a,
+                                      unsigned b) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  import_internal_proof_binary (solver, proof, a, b);
+  print_delete_proof_line (proof);
+}
+
+void kissat_delete_clause_from_proof (kissat *solver, const clause *c) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  import_proof_clause (solver, proof, c);
+  print_delete_proof_line (proof);
+}
+
+void kissat_delete_external_from_proof (kissat *solver, size_t size,
+                                        const int *elits) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  LOGINTS3 (size, elits, "explicitly deleted");
+  import_external_proof_literals (solver, proof, size, elits);
+  print_delete_proof_line (proof);
+}
+
+void kissat_delete_internal_from_proof (kissat *solver, size_t size,
+                                        const unsigned *ilits) {
+  proof *proof = solver->proof;
+  KISSAT_assert (proof);
+  import_internal_proof_literals (solver, proof, size, ilits);
+  print_delete_proof_line (proof);
+}
+
+#else
+int kissat_proof_dummy_to_avoid_warning;
+#endif
diff --git a/src/sat/kissat/proof.h b/src/sat/kissat/proof.h
new file mode 100644
index 000000000..d22fedb17
--- /dev/null
+++ b/src/sat/kissat/proof.h
@@ -0,0 +1,169 @@
+#ifndef _proof_h_INCLUDED
+#define _proof_h_INCLUDED
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifndef KISSAT_NPROOFS
+
+typedef struct proof proof;
+
+struct clause;
+struct file;
+
+void kissat_init_proof (struct kissat *, struct file *, bool binary);
+void kissat_release_proof (struct kissat *);
+
+#ifndef KISSAT_QUIET
+void kissat_print_proof_statistics (struct kissat *, bool verbose);
+#endif
+
+void kissat_add_binary_to_proof (struct kissat *, unsigned, unsigned);
+void kissat_add_clause_to_proof (struct kissat *, const struct clause *c);
+void kissat_add_empty_to_proof (struct kissat *);
+void kissat_add_lits_to_proof (struct kissat *, size_t, const unsigned *);
+void kissat_add_unit_to_proof (struct kissat *, unsigned);
+
+void kissat_shrink_clause_in_proof (struct kissat *, const struct clause *,
+                                    unsigned remove, unsigned keep);
+
+void kissat_delete_binary_from_proof (struct kissat *, unsigned, unsigned);
+void kissat_delete_clause_from_proof (struct kissat *,
+                                      const struct clause *c);
+void kissat_delete_external_from_proof (struct kissat *, size_t,
+                                        const int *);
+void kissat_delete_internal_from_proof (struct kissat *, size_t,
+                                        const unsigned *);
+
+#define ADD_BINARY_TO_PROOF(A, B) \
+  do { \
+    if (solver->proof) \
+      kissat_add_binary_to_proof (solver, (A), (B)); \
+  } while (0)
+
+#define ADD_TERNARY_TO_PROOF(A, B, C) \
+  do { \
+    if (solver->proof) { \
+      unsigned CLAUSE[3] = {(A), (B), (C)}; \
+      kissat_add_lits_to_proof (solver, 3, CLAUSE); \
+    } \
+  } while (0)
+
+#define ADD_CLAUSE_TO_PROOF(CLAUSE) \
+  do { \
+    if (solver->proof) \
+      kissat_add_clause_to_proof (solver, (CLAUSE)); \
+  } while (0)
+
+#define ADD_EMPTY_TO_PROOF() \
+  do { \
+    if (solver->proof) \
+      kissat_add_empty_to_proof (solver); \
+  } while (0)
+
+#define ADD_LITS_TO_PROOF(SIZE, LITS) \
+  do { \
+    if (solver->proof) \
+      kissat_add_lits_to_proof (solver, (SIZE), (LITS)); \
+  } while (0)
+
+#define ADD_STACK_TO_PROOF(S) \
+  ADD_LITS_TO_PROOF (SIZE_STACK (S), BEGIN_STACK (S))
+
+#define ADD_UNIT_TO_PROOF(A) \
+  do { \
+    if (solver->proof) \
+      kissat_add_unit_to_proof (solver, (A)); \
+  } while (0)
+
+#define SHRINK_CLAUSE_IN_PROOF(C, REMOVE, KEEP) \
+  do { \
+    if (solver->proof) \
+      kissat_shrink_clause_in_proof (solver, (C), (REMOVE), (KEEP)); \
+  } while (0)
+
+#define DELETE_BINARY_FROM_PROOF(A, B) \
+  do { \
+    if (solver->proof) \
+      kissat_delete_binary_from_proof (solver, (A), (B)); \
+  } while (0)
+
+#define DELETE_TERNARY_FROM_PROOF(A, B, C) \
+  do { \
+    if (solver->proof) { \
+      unsigned CLAUSE[3] = {(A), (B), (C)}; \
+      kissat_delete_internal_from_proof (solver, 3, CLAUSE); \
+    } \
+  } while (0)
+
+#define DELETE_CLAUSE_FROM_PROOF(CLAUSE) \
+  do { \
+    if (solver->proof) \
+      kissat_delete_clause_from_proof (solver, (CLAUSE)); \
+  } while (0)
+
+#define DELETE_LITS_FROM_PROOF(SIZE, LITS) \
+  do { \
+    if (solver->proof) \
+      kissat_delete_internal_from_proof (solver, (SIZE), (LITS)); \
+  } while (0)
+
+#define DELETE_STACK_FROM_PROOF(S) \
+  do { \
+    if (solver->proof) \
+      kissat_delete_internal_from_proof (solver, SIZE_STACK (S), \
+                                         BEGIN_STACK (S)); \
+  } while (0)
+
+#else
+
+#define ADD_BINARY_TO_PROOF(...) \
+  do { \
+  } while (0)
+#define ADD_TERNARY_TO_PROOF(...) \
+  do { \
+  } while (0)
+#define ADD_CLAUSE_TO_PROOF(...) \
+  do { \
+  } while (0)
+#define ADD_LITS_TO_PROOF(...) \
+  do { \
+  } while (0)
+#define ADD_EMPTY_TO_PROOF(...) \
+  do { \
+  } while (0)
+#define ADD_STACK_TO_PROOF(...) \
+  do { \
+  } while (0)
+#define ADD_UNIT_TO_PROOF(...) \
+  do { \
+  } while (0)
+
+#define SHRINK_CLAUSE_IN_PROOF(...) \
+  do { \
+  } while (0)
+
+#define DELETE_BINARY_FROM_PROOF(...) \
+  do { \
+  } while (0)
+#define DELETE_TERNARY_FROM_PROOF(...) \
+  do { \
+  } while (0)
+#define DELETE_CLAUSE_FROM_PROOF(...) \
+  do { \
+  } while (0)
+#define DELETE_LITS_FROM_PROOF(...) \
+  do { \
+  } while (0)
+#define DELETE_STACK_FROM_PROOF(...) \
+  do { \
+  } while (0)
+
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/propbeyond.c b/src/sat/kissat/propbeyond.c
new file mode 100644
index 000000000..8ffeb0432
--- /dev/null
+++ b/src/sat/kissat/propbeyond.c
@@ -0,0 +1,52 @@
+#include "propbeyond.h"
+#include "fastassign.h"
+#include "trail.h"
+
+ABC_NAMESPACE_IMPL_START
+
+#define PROPAGATE_LITERAL propagate_literal_beyond_conflicts
+#define CONTINUE_PROPAGATING_AFTER_CONFLICT
+#define PROPAGATION_TYPE "beyond conflict"
+
+#include "proplit.h"
+
+static inline void
+update_beyond_propagation_statistics (kissat *solver,
+                                      const unsigned *saved_propagate) {
+  KISSAT_assert (saved_propagate <= solver->propagate);
+  const unsigned propagated = solver->propagate - saved_propagate;
+
+  LOG ("propagated %u literals", propagated);
+  LOG ("propagation took %" PRIu64 " ticks", solver->ticks);
+
+  ADD (ticks, solver->ticks);
+
+  ADD (propagations, propagated);
+  ADD (warming_propagations, propagated);
+}
+
+static void propagate_literals_beyond_conflicts (kissat *solver) {
+  unsigned *propagate = solver->propagate;
+  while (propagate != END_ARRAY (solver->trail))
+    if (propagate_literal_beyond_conflicts (solver, *propagate++))
+      INC (warming_conflicts);
+  solver->propagate = propagate;
+}
+
+void kissat_propagate_beyond_conflicts (kissat *solver) {
+  KISSAT_assert (!solver->probing);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (solver->warming);
+  KISSAT_assert (!solver->inconsistent);
+
+  START (propagate);
+
+  solver->ticks = 0;
+  const unsigned *saved_propagate = solver->propagate;
+  propagate_literals_beyond_conflicts (solver);
+  update_beyond_propagation_statistics (solver, saved_propagate);
+
+  STOP (propagate);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/propbeyond.h b/src/sat/kissat/propbeyond.h
new file mode 100644
index 000000000..85d78d75d
--- /dev/null
+++ b/src/sat/kissat/propbeyond.h
@@ -0,0 +1,14 @@
+#ifndef _propall_h_INCLUDED
+#define _propall_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+struct clause;
+
+void kissat_propagate_beyond_conflicts (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/propdense.c b/src/sat/kissat/propdense.c
new file mode 100644
index 000000000..18bbb49d6
--- /dev/null
+++ b/src/sat/kissat/propdense.c
@@ -0,0 +1,112 @@
+#include "propdense.h"
+#include "fastassign.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static inline bool non_watching_propagate_literal (kissat *solver,
+                                                   unsigned lit) {
+  KISSAT_assert (!solver->watching);
+  LOG ("propagating %s", LOGLIT (lit));
+  KISSAT_assert (VALUE (lit) > 0);
+  const unsigned not_lit = NOT (lit);
+
+  watches *watches = &WATCHES (not_lit);
+  const size_t size_watches = SIZE_WATCHES (*watches);
+  unsigned ticks = 1 + kissat_cache_lines (size_watches, sizeof (watch));
+
+  ward *const arena = BEGIN_STACK (solver->arena);
+  assigned *assigned = solver->assigned;
+  value *values = solver->values;
+  flags *flags = solver->flags;
+
+  for (all_binary_large_watches (watch, *watches)) {
+    if (watch.type.binary) {
+      const unsigned other = watch.binary.lit;
+      KISSAT_assert (VALID_INTERNAL_LITERAL (other));
+      const value other_value = values[other];
+      if (other_value > 0)
+        continue;
+      if (other_value < 0) {
+        LOGBINARY (not_lit, other, "conflicting");
+        return false;
+      }
+      const unsigned other_idx = IDX (other);
+      if (flags[other_idx].eliminated)
+        continue;
+      KISSAT_assert (!solver->level);
+      kissat_fast_binary_assign (solver, solver->probing, 0, values,
+                                 assigned, other, not_lit);
+    } else {
+      const reference ref = watch.large.ref;
+      KISSAT_assert (ref < SIZE_STACK (solver->arena));
+      clause *c = (clause *) (arena + ref);
+      KISSAT_assert (c->size > 2);
+      KISSAT_assert (!c->redundant);
+      ticks++;
+      if (c->garbage)
+        continue;
+      unsigned non_false = 0;
+      unsigned unit = INVALID_LIT;
+      bool satisfied = false;
+      for (all_literals_in_clause (other, c)) {
+        if (other == not_lit)
+          continue;
+        KISSAT_assert (VALID_INTERNAL_LITERAL (other));
+        const value other_value = values[other];
+        if (other_value < 0)
+          continue;
+        if (other_value > 0) {
+          satisfied = true;
+          KISSAT_assert (!solver->level);
+          LOGCLS (c, "%s satisfied", LOGLIT (other));
+          kissat_mark_clause_as_garbage (solver, c);
+          break;
+        }
+        if (!non_false++)
+          unit = other;
+        else if (non_false > 1)
+          break;
+      }
+      if (satisfied)
+        continue;
+      if (!non_false) {
+        LOGREF (ref, "conflicting");
+        return false;
+      }
+      if (non_false == 1)
+        kissat_fast_assign_reference (solver, values, assigned, unit, ref,
+                                      c);
+    }
+  }
+
+  ADD (ticks, ticks);
+  ADD (dense_ticks, ticks);
+
+  return true;
+}
+
+bool kissat_dense_propagate (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+  START (propagate);
+  unsigned *propagate = solver->propagate;
+  bool res = true;
+  while (res && propagate != END_ARRAY (solver->trail))
+    res = non_watching_propagate_literal (solver, *propagate++);
+  const unsigned propagated = propagate - solver->propagate;
+  solver->propagate = propagate;
+  ADD (dense_propagations, propagated);
+  ADD (propagations, propagated);
+  if (!res) {
+    KISSAT_assert (!solver->inconsistent);
+    LOG ("inconsistent root propagation");
+    CHECK_AND_ADD_EMPTY ();
+    ADD_EMPTY_TO_PROOF ();
+    solver->inconsistent = true;
+  }
+  STOP (propagate);
+  return res;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/propdense.h b/src/sat/kissat/propdense.h
new file mode 100644
index 000000000..cdfbc7280
--- /dev/null
+++ b/src/sat/kissat/propdense.h
@@ -0,0 +1,16 @@
+#ifndef _propdense_h_INCLUDED
+#define _propdense_h_INCLUDED
+
+#include <limits.h>
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_dense_propagate (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/propinitially.c b/src/sat/kissat/propinitially.c
new file mode 100644
index 000000000..d534d0e86
--- /dev/null
+++ b/src/sat/kissat/propinitially.c
@@ -0,0 +1,60 @@
+#include "propinitially.h"
+#include "analyze.h"
+#include "fastassign.h"
+#include "print.h"
+#include "trail.h"
+
+ABC_NAMESPACE_IMPL_START
+
+#define PROPAGATE_LITERAL initially_propagate_literal
+#define PROPAGATION_TYPE "initially"
+
+#include "proplit.h"
+
+static inline void
+update_initial_propagation_statistics (kissat *solver,
+                                       const unsigned *saved_propagate) {
+  KISSAT_assert (saved_propagate <= solver->propagate);
+  const unsigned propagated = solver->propagate - saved_propagate;
+
+  LOG ("propagated %u literals", propagated);
+  LOG ("propagation took %" PRIu64 " ticks", solver->ticks);
+
+  ADD (propagations, propagated);
+  ADD (ticks, solver->ticks);
+}
+
+static clause *initially_propagate (kissat *solver) {
+  clause *res = 0;
+  unsigned *propagate = solver->propagate;
+  while (!res && propagate != END_ARRAY (solver->trail))
+    res = initially_propagate_literal (solver, *propagate++);
+  solver->propagate = propagate;
+  return res;
+}
+
+bool kissat_initially_propagate (kissat *solver) {
+  KISSAT_assert (!solver->probing);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+
+  START (propagate);
+
+  solver->ticks = 0;
+  const unsigned *saved_propagate = solver->propagate;
+  clause *conflict = initially_propagate (solver);
+  update_initial_propagation_statistics (solver, saved_propagate);
+  kissat_update_conflicts_and_trail (solver, conflict, true);
+  if (conflict) {
+    int res = kissat_analyze (solver, conflict);
+    KISSAT_assert (solver->inconsistent);
+    KISSAT_assert (res == 20);
+    (void) res;
+  }
+
+  STOP (propagate);
+
+  return !conflict;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/propinitially.h b/src/sat/kissat/propinitially.h
new file mode 100644
index 000000000..7203cacaf
--- /dev/null
+++ b/src/sat/kissat/propinitially.h
@@ -0,0 +1,15 @@
+#ifndef _propinitially_h_INCLUDED
+#define _propinitially_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_initially_propagate (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/proplit.h b/src/sat/kissat/proplit.h
new file mode 100644
index 000000000..be0632d0c
--- /dev/null
+++ b/src/sat/kissat/proplit.h
@@ -0,0 +1,204 @@
+static inline void kissat_watch_large_delayed (kissat *solver,
+                                               watches *all_watches,
+                                               unsigneds *delayed) {
+  KISSAT_assert (all_watches == solver->watches);
+  KISSAT_assert (delayed == &solver->delayed);
+  const unsigned *const end_delayed = END_STACK (*delayed);
+  unsigned const *d = BEGIN_STACK (*delayed);
+  while (d != end_delayed) {
+    const unsigned lit = *d++;
+    KISSAT_assert (d != end_delayed);
+    const watch watch = {.raw = *d++};
+    KISSAT_assert (!watch.type.binary);
+    KISSAT_assert (lit < LITS);
+    watches *const lit_watches = all_watches + lit;
+    KISSAT_assert (d != end_delayed);
+    const reference ref = *d++;
+    const unsigned blocking = watch.blocking.lit;
+    LOGREF3 (ref, "watching %s blocking %s in", LOGLIT (lit),
+             LOGLIT (blocking));
+    kissat_push_blocking_watch (solver, lit_watches, blocking, ref);
+  }
+  CLEAR_STACK (*delayed);
+}
+
+static inline void
+kissat_delay_watching_large (kissat *solver, unsigneds *const delayed,
+                             unsigned lit, unsigned other, reference ref) {
+  const watch watch = kissat_blocking_watch (other);
+  PUSH_STACK (*delayed, lit);
+  PUSH_STACK (*delayed, watch.raw);
+  PUSH_STACK (*delayed, ref);
+}
+
+static inline clause *PROPAGATE_LITERAL (kissat *solver,
+#if defined(PROBING_PROPAGATION)
+                                         const clause *const ignore,
+#endif
+                                         const unsigned lit) {
+  KISSAT_assert (solver->watching);
+  LOG (PROPAGATION_TYPE " propagating %s", LOGLIT (lit));
+  KISSAT_assert (VALUE (lit) > 0);
+  KISSAT_assert (EMPTY_STACK (solver->delayed));
+
+  watches *const all_watches = solver->watches;
+  ward *const arena = BEGIN_STACK (solver->arena);
+  assigned *const assigned = solver->assigned;
+  value *const values = solver->values;
+
+  const unsigned not_lit = NOT (lit);
+
+  KISSAT_assert (not_lit < LITS);
+  watches *watches = all_watches + not_lit;
+
+  watch *const begin_watches = BEGIN_WATCHES (*watches);
+  const watch *const end_watches = END_WATCHES (*watches);
+
+  watch *q = begin_watches;
+  const watch *p = q;
+
+  unsigneds *const delayed = &solver->delayed;
+  KISSAT_assert (EMPTY_STACK (*delayed));
+
+  const size_t size_watches = SIZE_WATCHES (*watches);
+  uint64_t ticks = 1 + kissat_cache_lines (size_watches, sizeof (watch));
+  const unsigned idx = IDX (lit);
+  struct assigned *const a = assigned + idx;
+  const bool probing = solver->probing;
+  const unsigned level = a->level;
+  clause *res = 0;
+
+  while (p != end_watches) {
+    const watch head = *q++ = *p++;
+    const unsigned blocking = head.blocking.lit;
+    KISSAT_assert (VALID_INTERNAL_LITERAL (blocking));
+    const value blocking_value = values[blocking];
+    const bool binary = head.type.binary;
+    watch tail;
+    if (!binary)
+      tail = *q++ = *p++;
+    if (blocking_value > 0)
+      continue;
+    if (binary) {
+      if (blocking_value < 0) {
+        res = kissat_binary_conflict (solver, not_lit, blocking);
+#ifndef CONTINUE_PROPAGATING_AFTER_CONFLICT
+        break;
+#endif
+      } else {
+        KISSAT_assert (!blocking_value);
+        kissat_fast_binary_assign (solver, probing, level, values, assigned,
+                                   blocking, not_lit);
+        ticks++;
+      }
+    } else {
+      const reference ref = tail.raw;
+      KISSAT_assert (ref < SIZE_STACK (solver->arena));
+      clause *const c = (clause *) (arena + ref);
+      ticks++;
+      if (c->garbage) {
+        q -= 2;
+        continue;
+      }
+      unsigned *const lits = BEGIN_LITS (c);
+      const unsigned other = lits[0] ^ lits[1] ^ not_lit;
+      KISSAT_assert (lits[0] != lits[1]);
+      KISSAT_assert (VALID_INTERNAL_LITERAL (other));
+      KISSAT_assert (not_lit != other);
+      KISSAT_assert (lit != other);
+      const value other_value = values[other];
+      if (other_value > 0) {
+        q[-2].blocking.lit = other;
+        continue;
+      }
+      const unsigned *const end_lits = lits + c->size;
+      unsigned *const searched = lits + c->searched;
+      KISSAT_assert (c->lits + 2 <= searched);
+      KISSAT_assert (searched < end_lits);
+      unsigned *r, replacement = INVALID_LIT;
+      value replacement_value = -1;
+      for (r = searched; r != end_lits; r++) {
+        replacement = *r;
+        KISSAT_assert (VALID_INTERNAL_LITERAL (replacement));
+        replacement_value = values[replacement];
+        if (replacement_value >= 0)
+          break;
+      }
+      if (replacement_value < 0) {
+        for (r = lits + 2; r != searched; r++) {
+          replacement = *r;
+          KISSAT_assert (VALID_INTERNAL_LITERAL (replacement));
+          replacement_value = values[replacement];
+          if (replacement_value >= 0)
+            break;
+        }
+      }
+
+      if (replacement_value >= 0) {
+        c->searched = r - lits;
+        KISSAT_assert (replacement != INVALID_LIT);
+        LOGREF3 (ref, "unwatching %s in", LOGLIT (not_lit));
+        q -= 2;
+        lits[0] = other;
+        lits[1] = replacement;
+        KISSAT_assert (lits[0] != lits[1]);
+        *r = not_lit;
+        kissat_delay_watching_large (solver, delayed, replacement, other,
+                                     ref);
+        ticks++;
+      } else if (other_value) {
+        KISSAT_assert (replacement_value < 0);
+        KISSAT_assert (blocking_value < 0);
+        KISSAT_assert (other_value < 0);
+#if defined(PROBING_PROPAGATION)
+        if (c == ignore) {
+          LOGREF (ref, "conflicting but ignored");
+          continue;
+        }
+#endif
+        LOGREF (ref, "conflicting");
+        res = c;
+#ifndef CONTINUE_PROPAGATING_AFTER_CONFLICT
+        break;
+#endif
+      } else {
+        KISSAT_assert (replacement_value < 0);
+#if defined(PROBING_PROPAGATION)
+        if (c == ignore) {
+          LOGREF (ref, "forcing %s but ignored", LOGLIT (other));
+          continue;
+        }
+#endif
+        kissat_fast_assign_reference (solver, values, assigned, other, ref,
+                                      c);
+        ticks++;
+      }
+    }
+  }
+  solver->ticks += ticks;
+
+  while (p != end_watches)
+    *q++ = *p++;
+  SET_END_OF_WATCHES (*watches, q);
+
+  kissat_watch_large_delayed (solver, all_watches, delayed);
+
+  return res;
+}
+
+static inline void kissat_update_conflicts_and_trail (kissat *solver,
+                                                      clause *conflict,
+                                                      bool flush) {
+  if (conflict) {
+#ifndef PROBING_PROPAGATION
+    INC (conflicts);
+#endif
+    if (!solver->level) {
+      LOG (PROPAGATION_TYPE " propagation on root-level failed");
+      solver->inconsistent = true;
+      CHECK_AND_ADD_EMPTY ();
+      ADD_EMPTY_TO_PROOF ();
+    }
+  } else if (flush && !solver->level && solver->unflushed)
+    kissat_flush_trail (solver);
+}
diff --git a/src/sat/kissat/proprobe.c b/src/sat/kissat/proprobe.c
new file mode 100644
index 000000000..f75799ed4
--- /dev/null
+++ b/src/sat/kissat/proprobe.c
@@ -0,0 +1,63 @@
+#include "proprobe.h"
+#include "fastassign.h"
+#include "trail.h"
+
+ABC_NAMESPACE_IMPL_START
+
+#define PROPAGATE_LITERAL probing_propagate_literal
+#define PROPAGATION_TYPE "probing"
+#define PROBING_PROPAGATION
+
+#include "proplit.h"
+
+static void update_probing_propagation_statistics (kissat *solver,
+                                                   unsigned propagated) {
+  const uint64_t ticks = solver->ticks;
+  LOG (PROPAGATION_TYPE " propagation took %u propagations", propagated);
+  LOG (PROPAGATION_TYPE " propagation took %" PRIu64 " ticks", ticks);
+
+  ADD (propagations, propagated);
+  ADD (probing_propagations, propagated);
+
+#if defined(METRICS)
+  if (solver->backbone_computing) {
+    ADD (backbone_propagations, propagated);
+    ADD (backbone_ticks, ticks);
+  }
+  if (solver->vivifying) {
+    ADD (vivify_propagations, propagated);
+    ADD (vivify_ticks, ticks);
+  }
+#endif
+
+  ADD (probing_ticks, ticks);
+  ADD (ticks, ticks);
+}
+
+clause *kissat_probing_propagate (kissat *solver, clause *ignore,
+                                  bool flush) {
+  KISSAT_assert (solver->probing);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+
+  START (propagate);
+
+  clause *conflict = 0;
+  unsigned *propagate = solver->propagate;
+  solver->ticks = 0;
+  while (!conflict && propagate != END_ARRAY (solver->trail)) {
+    const unsigned lit = *propagate++;
+    conflict = probing_propagate_literal (solver, ignore, lit);
+  }
+
+  const unsigned propagated = propagate - solver->propagate;
+  solver->propagate = propagate;
+  update_probing_propagation_statistics (solver, propagated);
+  kissat_update_conflicts_and_trail (solver, conflict, flush);
+
+  STOP (propagate);
+
+  return conflict;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/proprobe.h b/src/sat/kissat/proprobe.h
new file mode 100644
index 000000000..327c8bd01
--- /dev/null
+++ b/src/sat/kissat/proprobe.h
@@ -0,0 +1,17 @@
+#ifndef _proprobe_h_INCLUDED
+#define _proprobe_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+struct clause;
+
+struct clause *kissat_probing_propagate (struct kissat *, struct clause *,
+                                         bool flush);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/propsearch.c b/src/sat/kissat/propsearch.c
new file mode 100644
index 000000000..301bd02ca
--- /dev/null
+++ b/src/sat/kissat/propsearch.c
@@ -0,0 +1,75 @@
+#include "propsearch.h"
+#include "fastassign.h"
+#include "print.h"
+#include "trail.h"
+
+ABC_NAMESPACE_IMPL_START
+
+#define PROPAGATE_LITERAL search_propagate_literal
+#define PROPAGATION_TYPE "search"
+
+#include "proplit.h"
+
+static inline void
+update_search_propagation_statistics (kissat *solver,
+                                      const unsigned *saved_propagate) {
+  KISSAT_assert (saved_propagate <= solver->propagate);
+  const unsigned propagated = solver->propagate - saved_propagate;
+
+  LOG ("propagated %u literals", propagated);
+  LOG ("propagation took %" PRIu64 " ticks", solver->ticks);
+
+  ADD (propagations, propagated);
+  ADD (ticks, solver->ticks);
+
+  ADD (search_propagations, propagated);
+  ADD (search_ticks, solver->ticks);
+
+  if (solver->stable) {
+    ADD (stable_propagations, propagated);
+    ADD (stable_ticks, solver->ticks);
+  } else {
+    ADD (focused_propagations, propagated);
+    ADD (focused_ticks, solver->ticks);
+  }
+}
+
+static clause *search_propagate (kissat *solver) {
+  clause *res = 0;
+  unsigned *propagate = solver->propagate;
+  while (!res && propagate != END_ARRAY (solver->trail))
+    res = search_propagate_literal (solver, *propagate++);
+  solver->propagate = propagate;
+  return res;
+}
+
+clause *kissat_search_propagate (kissat *solver) {
+  KISSAT_assert (!solver->probing);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+
+  START (propagate);
+
+  solver->ticks = 0;
+  const unsigned *saved_propagate = solver->propagate;
+  clause *conflict = search_propagate (solver);
+  update_search_propagation_statistics (solver, saved_propagate);
+  kissat_update_conflicts_and_trail (solver, conflict, true);
+  if (conflict && solver->randec) {
+    if (!--solver->randec)
+      kissat_very_verbose (solver, "last random decision conflict");
+    else if (solver->randec == 1)
+      kissat_very_verbose (solver,
+                           "one more random decision conflict to go");
+    else
+      kissat_very_verbose (solver,
+                           "%s more random decision conflicts to go",
+                           FORMAT_COUNT (solver->randec));
+  }
+
+  STOP (propagate);
+
+  return conflict;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/propsearch.h b/src/sat/kissat/propsearch.h
new file mode 100644
index 000000000..c932e66fb
--- /dev/null
+++ b/src/sat/kissat/propsearch.h
@@ -0,0 +1,14 @@
+#ifndef _propsearch_h_INCLUDED
+#define _propsearch_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+struct clause;
+
+struct clause *kissat_search_propagate (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/queue.c b/src/sat/kissat/queue.c
new file mode 100644
index 000000000..14deb0c6f
--- /dev/null
+++ b/src/sat/kissat/queue.c
@@ -0,0 +1,59 @@
+#include "inline.h"
+#include "inlinequeue.h"
+#include "print.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_init_queue (kissat *solver) {
+  queue *queue = &solver->queue;
+  queue->first = queue->last = DISCONNECT;
+  KISSAT_assert (!queue->stamp);
+  queue->search.idx = DISCONNECT;
+  KISSAT_assert (!queue->search.stamp);
+}
+
+void kissat_reset_search_of_queue (kissat *solver) {
+  LOG ("reset last search cache of queue");
+  queue *queue = &solver->queue;
+  links *links = solver->links;
+  const unsigned last = queue->last;
+  KISSAT_assert (!DISCONNECTED (last));
+  kissat_update_queue (solver, links, last);
+}
+
+void kissat_reassign_queue_stamps (kissat *solver) {
+  kissat_very_verbose (solver, "need to reassign enqueue stamps on queue");
+
+  queue *queue = &solver->queue;
+  links *links = solver->links;
+  queue->stamp = 0;
+
+  struct links *l;
+  for (unsigned idx = queue->first; !DISCONNECTED (idx); idx = l->next)
+    (l = links + idx)->stamp = ++queue->stamp;
+
+  if (!DISCONNECTED (queue->search.idx))
+    queue->search.stamp = links[queue->search.idx].stamp;
+}
+
+#if defined(CHECK_QUEUE) && !defined(KISSAT_NDEBUG)
+void kissat_check_queue (kissat *solver) {
+  links *links = solver->links;
+  queue *queue = &solver->queue;
+  bool passed_search_idx = false;
+  const bool focused = !solver->stable;
+  for (unsigned idx = queue->first, prev = DISCONNECT; !DISCONNECTED (idx);
+       idx = links[idx].next) {
+    if (!DISCONNECTED (prev))
+      KISSAT_assert (links[prev].stamp < links[idx].stamp);
+    if (focused && passed_search_idx)
+      KISSAT_assert (VALUE (LIT (idx)));
+    if (idx == queue->search.idx)
+      passed_search_idx = true;
+  }
+  if (!DISCONNECTED (queue->search.idx))
+    KISSAT_assert (links[queue->search.idx].stamp == queue->search.stamp);
+}
+#endif
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/queue.h b/src/sat/kissat/queue.h
new file mode 100644
index 000000000..c6e40ebe1
--- /dev/null
+++ b/src/sat/kissat/queue.h
@@ -0,0 +1,43 @@
+#ifndef _queue_h_INCLUDED
+#define _queue_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define DISCONNECT UINT_MAX
+#define DISCONNECTED(IDX) ((int) (IDX) < 0)
+
+struct kissat;
+
+typedef struct links links;
+typedef struct queue queue;
+
+struct links {
+  unsigned prev, next;
+  unsigned stamp;
+};
+
+struct queue {
+  unsigned first, last, stamp;
+  struct {
+    unsigned idx, stamp;
+  } search;
+};
+
+void kissat_init_queue (struct kissat *);
+void kissat_reset_search_of_queue (struct kissat *);
+void kissat_reassign_queue_stamps (struct kissat *);
+
+#define LINK(IDX) (solver->links[KISSAT_assert ((IDX) < VARS), (IDX)])
+
+#if defined(CHECK_QUEUE) && !defined(KISSAT_NDEBUG)
+void kissat_check_queue (struct kissat *);
+#else
+#define kissat_check_queue(...) \
+  do { \
+  } while (0)
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/random.h b/src/sat/kissat/random.h
new file mode 100644
index 000000000..5a8057950
--- /dev/null
+++ b/src/sat/kissat/random.h
@@ -0,0 +1,49 @@
+#ifndef _random_h_INCLUDED
+#define _random_h_INCLUDED
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef uint64_t generator;
+
+static inline uint64_t kissat_next_random64 (generator *rng) {
+  *rng *= 6364136223846793005ul;
+  *rng += 1442695040888963407ul;
+  return *rng;
+}
+
+static inline unsigned kissat_next_random32 (generator *rng) {
+  return kissat_next_random64 (rng) >> 32;
+}
+
+static inline unsigned kissat_pick_random (generator *rng, unsigned l,
+                                           unsigned r) {
+  KISSAT_assert (l <= r);
+  if (l == r)
+    return l;
+  const unsigned delta = r - l;
+  const unsigned tmp = kissat_next_random32 (rng);
+  const double fraction = tmp / 4294967296.0;
+  KISSAT_assert (0 <= fraction), KISSAT_assert (fraction < 1);
+  const unsigned scaled = delta * fraction;
+  KISSAT_assert (scaled < delta);
+  const unsigned res = l + scaled;
+  KISSAT_assert (l <= res), KISSAT_assert (res < r);
+  return res;
+}
+
+static inline bool kissat_pick_bool (generator *rng) {
+  return kissat_pick_random (rng, 0, 2);
+}
+
+static inline double kissat_pick_double (generator *rng) {
+  return kissat_next_random32 (rng) / 4294967296.0;
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/rank.h b/src/sat/kissat/rank.h
new file mode 100644
index 000000000..08ac1e8e8
--- /dev/null
+++ b/src/sat/kissat/rank.h
@@ -0,0 +1,145 @@
+#ifndef _rank_h_INCLUDED
+#define _rank_h_INCLUDED
+
+#include "allocate.h"
+
+#include <string.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifdef KISSAT_NDEBUG
+#define CHECK_RANKED(...) \
+  do { \
+  } while (0)
+#else
+#define CHECK_RANKED(N, A, RANK) \
+  do { \
+    KISSAT_assert (0 < (N)); \
+    for (size_t I_CHECK_RANKED = 0; I_CHECK_RANKED < N - 1; \
+         I_CHECK_RANKED++) \
+      KISSAT_assert (RANK (A[I_CHECK_RANKED]) <= RANK (A[I_CHECK_RANKED + 1])); \
+  } while (0)
+#endif
+
+#define RADIX_SORT(VTYPE, RTYPE, N, V, RANK) \
+  do { \
+    const size_t N_RADIX = (N); \
+    if (N_RADIX <= 1) \
+      break; \
+\
+    START (radix); \
+\
+    VTYPE *V_RADIX = (V); \
+\
+    const size_t LENGTH_RADIX = 8; \
+    const size_t WIDTH_RADIX = (1 << LENGTH_RADIX); \
+    const RTYPE MASK_RADIX = WIDTH_RADIX - 1; \
+\
+    size_t COUNT_RADIX[256]; \
+\
+    VTYPE *TMP_RADIX = 0; \
+    const size_t BYTES_TMP_RADIX = N_RADIX * sizeof (VTYPE); \
+\
+    VTYPE *A_RADIX = V_RADIX; \
+    VTYPE *B_RADIX = 0; \
+    VTYPE *C_RADIX = A_RADIX; \
+\
+    RTYPE MLOWER_RADIX = 0; \
+    RTYPE MUPPER_RADIX = MASK_RADIX; \
+\
+    bool BOUNDED_RADIX = false; \
+    RTYPE UPPER_RADIX = 0; \
+    RTYPE LOWER_RADIX = ~UPPER_RADIX; \
+    RTYPE SHIFT_RADIX = MASK_RADIX; \
+\
+    for (size_t I_RADIX = 0; I_RADIX < 8 * sizeof (RTYPE); \
+         I_RADIX += LENGTH_RADIX, SHIFT_RADIX <<= LENGTH_RADIX) { \
+      if (BOUNDED_RADIX && \
+          (LOWER_RADIX & SHIFT_RADIX) == (UPPER_RADIX & SHIFT_RADIX)) \
+        continue; \
+\
+      memset (COUNT_RADIX + MLOWER_RADIX, 0, \
+              (MUPPER_RADIX - MLOWER_RADIX + 1) * sizeof *COUNT_RADIX); \
+\
+      VTYPE *END_RADIX = C_RADIX + N_RADIX; \
+\
+      bool SORTED_RADIX = true; \
+      RTYPE LAST_RADIX = 0; \
+\
+      for (VTYPE *P_RADIX = C_RADIX; P_RADIX != END_RADIX; P_RADIX++) { \
+        RTYPE R_RADIX = RANK (*P_RADIX); \
+        if (!BOUNDED_RADIX) { \
+          LOWER_RADIX &= R_RADIX; \
+          UPPER_RADIX |= R_RADIX; \
+        } \
+        RTYPE S_RADIX = R_RADIX >> I_RADIX; \
+        RTYPE M_RADIX = S_RADIX & MASK_RADIX; \
+        if (SORTED_RADIX && LAST_RADIX > M_RADIX) \
+          SORTED_RADIX = false; \
+        else \
+          LAST_RADIX = M_RADIX; \
+        COUNT_RADIX[M_RADIX]++; \
+      } \
+\
+      MLOWER_RADIX = (LOWER_RADIX >> I_RADIX) & MASK_RADIX; \
+      MUPPER_RADIX = (UPPER_RADIX >> I_RADIX) & MASK_RADIX; \
+\
+      if (!BOUNDED_RADIX) { \
+        BOUNDED_RADIX = true; \
+        if ((LOWER_RADIX & SHIFT_RADIX) == (UPPER_RADIX & SHIFT_RADIX)) \
+          continue; \
+      } \
+\
+      if (SORTED_RADIX) \
+        continue; \
+\
+      size_t POS_RADIX = 0; \
+      for (size_t J_RADIX = MLOWER_RADIX; J_RADIX <= MUPPER_RADIX; \
+           J_RADIX++) { \
+        const size_t DELTA_RADIX = COUNT_RADIX[J_RADIX]; \
+        COUNT_RADIX[J_RADIX] = POS_RADIX; \
+        POS_RADIX += DELTA_RADIX; \
+      } \
+\
+      if (!TMP_RADIX) { \
+        KISSAT_assert (C_RADIX == A_RADIX); \
+        TMP_RADIX = (VTYPE*)kissat_malloc (solver, BYTES_TMP_RADIX);     \
+        B_RADIX = TMP_RADIX; \
+      } \
+\
+      KISSAT_assert (B_RADIX == TMP_RADIX); \
+\
+      VTYPE *D_RADIX = (C_RADIX == A_RADIX) ? B_RADIX : A_RADIX; \
+\
+      for (VTYPE *P_RADIX = C_RADIX; P_RADIX != END_RADIX; P_RADIX++) { \
+        RTYPE R_RADIX = RANK (*P_RADIX); \
+        RTYPE S_RADIX = R_RADIX >> I_RADIX; \
+        RTYPE M_RADIX = S_RADIX & MASK_RADIX; \
+        const size_t POS_RADIX = COUNT_RADIX[M_RADIX]++; \
+        D_RADIX[POS_RADIX] = *P_RADIX; \
+      } \
+\
+      C_RADIX = D_RADIX; \
+    } \
+\
+    if (C_RADIX == B_RADIX) \
+      memcpy (A_RADIX, B_RADIX, N_RADIX * sizeof *A_RADIX); \
+\
+    if (TMP_RADIX) \
+      kissat_free (solver, TMP_RADIX, BYTES_TMP_RADIX); \
+\
+    CHECK_RANKED (N_RADIX, V_RADIX, RANK); \
+    STOP (radix); \
+  } while (0)
+
+#define RADIX_STACK(VTYPE, RTYPE, S, RANK) \
+  do { \
+    const size_t N_RADIX_STACK = SIZE_STACK (S); \
+    VTYPE *A_RADIX_STACK = BEGIN_STACK (S); \
+    RADIX_SORT (VTYPE, RTYPE, N_RADIX_STACK, A_RADIX_STACK, RANK); \
+  } while (0)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/reduce.c b/src/sat/kissat/reduce.c
new file mode 100644
index 000000000..8d8716cc3
--- /dev/null
+++ b/src/sat/kissat/reduce.c
@@ -0,0 +1,202 @@
+#include "reduce.h"
+#include "allocate.h"
+#include "collect.h"
+#include "inline.h"
+#include "print.h"
+#include "rank.h"
+#include "report.h"
+#include "tiers.h"
+#include "trail.h"
+
+#include <inttypes.h>
+#include <math.h>
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_reducing (kissat *solver) {
+  if (!GET_OPTION (reduce))
+    return false;
+  if (!solver->statistics_.clauses_redundant)
+    return false;
+  if (CONFLICTS < solver->limits.reduce.conflicts)
+    return false;
+  return true;
+}
+
+typedef struct reducible reducible;
+
+struct reducible {
+  uint64_t rank;
+  unsigned ref;
+};
+
+#define RANK_REDUCIBLE(RED) (RED).rank
+
+// clang-format off
+typedef STACK (reducible) reducibles;
+// clang-format on
+
+static bool collect_reducibles (kissat *solver, reducibles *reds,
+                                reference start_ref) {
+  KISSAT_assert (start_ref != INVALID_REF);
+  KISSAT_assert (start_ref <= SIZE_STACK (solver->arena));
+  ward *const arena = BEGIN_STACK (solver->arena);
+  clause *start = (clause *) (arena + start_ref);
+  const clause *const end = (clause *) END_STACK (solver->arena);
+  KISSAT_assert (start < end);
+  while (start != end && !start->redundant)
+    start = kissat_next_clause (start);
+  if (start == end) {
+    solver->first_reducible = INVALID_REF;
+    LOG ("no reducible clause candidate left");
+    return false;
+  }
+  const reference redundant = (ward *) start - arena;
+#ifdef LOGGING
+  if (redundant < solver->first_reducible)
+    LOG ("updating start of redundant clauses from %zu to %zu",
+         (size_t) solver->first_reducible, (size_t) redundant);
+  else
+    LOG ("no update to start of redundant clauses %zu",
+         (size_t) solver->first_reducible);
+#endif
+  solver->first_reducible = redundant;
+  const unsigned tier1 = TIER1;
+  const unsigned tier2 = MAX (tier1, TIER2);
+  KISSAT_assert (tier1 <= tier2);
+  for (clause *c = start; c != end; c = kissat_next_clause (c)) {
+    if (!c->redundant)
+      continue;
+    if (c->garbage)
+      continue;
+    const unsigned used = c->used;
+    if (used)
+      c->used = used - 1;
+    if (c->reason)
+      continue;
+    const unsigned glue = c->glue;
+    if (glue <= tier1 && used)
+      continue;
+    if (glue <= tier2 && used >= MAX_USED - 1)
+      continue;
+    KISSAT_assert (kissat_clause_in_arena (solver, c));
+    reducible red;
+    const uint64_t negative_size = ~c->size;
+    const uint64_t negative_glue = ~c->glue;
+    red.rank = negative_size | (negative_glue << 32);
+    red.ref = (ward *) c - arena;
+    PUSH_STACK (*reds, red);
+  }
+  if (EMPTY_STACK (*reds)) {
+    kissat_phase (solver, "reduce", GET (reductions),
+                  "did not find any reducible redundant clause");
+    return false;
+  }
+  return true;
+}
+
+#define USEFULNESS RANK_REDUCIBLE
+
+static void sort_reducibles (kissat *solver, reducibles *reds) {
+  RADIX_STACK (reducible, uint64_t, *reds, USEFULNESS);
+}
+
+static void mark_less_useful_clauses_as_garbage (kissat *solver,
+                                                 reducibles *reds) {
+  statistics *statistics = &solver->statistics_;
+  const double high = GET_OPTION (reducehigh) * 0.1;
+  const double low = GET_OPTION (reducelow) * 0.1;
+  double percent;
+  if (low < high) {
+    const double delta = high - low;
+    percent = high - delta / log10 (statistics->reductions + 9);
+  } else
+    percent = low;
+  const double fraction = percent / 100.0;
+  const size_t size = SIZE_STACK (*reds);
+  size_t target = size * fraction;
+#ifndef KISSAT_QUIET
+  const size_t clauses =
+      statistics->clauses_irredundant + statistics->clauses_redundant;
+  kissat_phase (solver, "reduce", GET (reductions),
+                "reducing %zu (%.0f%%) out of %zu (%.0f%%) "
+                "reducible clauses",
+                target, kissat_percent (target, size), size,
+                kissat_percent (size, clauses));
+#endif
+  unsigned reduced = 0, reduced1 = 0, reduced2 = 0, reduced3 = 0;
+  ward *arena = BEGIN_STACK (solver->arena);
+  const reducible *const begin = BEGIN_STACK (*reds);
+  const reducible *const end = END_STACK (*reds);
+  const unsigned tier1 = TIER1;
+  const unsigned tier2 = TIER2;
+  for (const reducible *p = begin; p != end && target--; p++) {
+    clause *c = (clause *) (arena + p->ref);
+    KISSAT_assert (kissat_clause_in_arena (solver, c));
+    KISSAT_assert (!c->garbage);
+    KISSAT_assert (!c->reason);
+    KISSAT_assert (c->redundant);
+    LOGCLS (c, "reducing");
+    kissat_mark_clause_as_garbage (solver, c);
+    reduced++;
+    if (c->glue <= tier1)
+      reduced1++;
+    else if (c->glue <= tier2)
+      reduced2++;
+    else
+      reduced3++;
+  }
+  ADD (clauses_reduced_tier1, reduced1);
+  ADD (clauses_reduced_tier2, reduced2);
+  ADD (clauses_reduced_tier3, reduced3);
+  ADD (clauses_reduced, reduced);
+}
+
+int kissat_reduce (kissat *solver) {
+  START (reduce);
+  INC (reductions);
+  kissat_phase (solver, "reduce", GET (reductions),
+                "reduce limit %" PRIu64 " hit after %" PRIu64 " conflicts",
+                solver->limits.reduce.conflicts, CONFLICTS);
+  kissat_compute_and_set_tier_limits (solver);
+  bool compact = kissat_compacting (solver);
+  reference start = compact ? 0 : solver->first_reducible;
+  if (start != INVALID_REF) {
+#ifndef KISSAT_QUIET
+    size_t arena_size = SIZE_STACK (solver->arena);
+    size_t words_to_sweep = arena_size - start;
+    size_t bytes_to_sweep = sizeof (word) * words_to_sweep;
+    kissat_phase (solver, "reduce", GET (reductions),
+                  "reducing clauses after offset %" REFERENCE_FORMAT
+                  " in arena",
+                  start);
+    kissat_phase (solver, "reduce", GET (reductions),
+                  "reducing %zu words %s %.0f%%", words_to_sweep,
+                  FORMAT_BYTES (bytes_to_sweep),
+                  kissat_percent (words_to_sweep, arena_size));
+#endif
+    if (kissat_flush_and_mark_reason_clauses (solver, start)) {
+      reducibles reds;
+      INIT_STACK (reds);
+      if (collect_reducibles (solver, &reds, start)) {
+        sort_reducibles (solver, &reds);
+        mark_less_useful_clauses_as_garbage (solver, &reds);
+        RELEASE_STACK (reds);
+        kissat_sparse_collect (solver, compact, start);
+      } else if (compact)
+        kissat_sparse_collect (solver, compact, start);
+      else
+        kissat_unmark_reason_clauses (solver, start);
+    } else
+      KISSAT_assert (solver->inconsistent);
+  } else
+    kissat_phase (solver, "reduce", GET (reductions), "nothing to reduce");
+  kissat_classify (solver);
+  UPDATE_CONFLICT_LIMIT (reduce, reductions, SQRT, false);
+  solver->last.conflicts.reduce = CONFLICTS;
+  REPORT (0, '-');
+  STOP (reduce);
+  return solver->inconsistent ? 20 : 0;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/reduce.h b/src/sat/kissat/reduce.h
new file mode 100644
index 000000000..134e654c3
--- /dev/null
+++ b/src/sat/kissat/reduce.h
@@ -0,0 +1,16 @@
+#ifndef _reduce_h_INCLUDED
+#define _reduce_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_reducing (struct kissat *);
+int kissat_reduce (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/reference.h b/src/sat/kissat/reference.h
new file mode 100644
index 000000000..437ad8642
--- /dev/null
+++ b/src/sat/kissat/reference.h
@@ -0,0 +1,24 @@
+#ifndef _reference_h_INCLUDED
+#define _reference_h_INCLUDED
+
+#include "stack.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef unsigned reference;
+
+#define REFERENCE_FORMAT "u"
+
+#define LD_MAX_REF 31u
+#define MAX_REF ((1u << LD_MAX_REF) - 1)
+
+#define INVALID_REF UINT_MAX
+
+// clang-format off
+typedef STACK (reference) references;
+// clang-format on
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/reluctant.c b/src/sat/kissat/reluctant.c
new file mode 100644
index 000000000..ddab37c45
--- /dev/null
+++ b/src/sat/kissat/reluctant.c
@@ -0,0 +1,71 @@
+#include "internal.h"
+#include "logging.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_enable_reluctant (reluctant *reluctant, uint64_t period,
+                              uint64_t limit) {
+  if (limit && period > limit)
+    period = limit;
+  reluctant->limited = (limit > 0);
+  reluctant->trigger = false;
+  reluctant->period = period;
+  reluctant->wait = period;
+  reluctant->u = reluctant->v = 1;
+  reluctant->limit = limit;
+}
+
+void kissat_disable_reluctant (reluctant *reluctant) {
+  reluctant->period = 0;
+}
+
+void kissat_tick_reluctant (reluctant *reluctant) {
+  if (!reluctant->period)
+    return;
+
+  if (reluctant->trigger)
+    return;
+
+  KISSAT_assert (reluctant->wait > 0);
+  if (--reluctant->wait)
+    return;
+
+  uint64_t u = reluctant->u;
+  uint64_t v = reluctant->v;
+
+  if ((u & -u) == v) {
+    u++;
+    v = 1;
+  } else {
+    KISSAT_assert (UINT64_MAX / 2 >= v);
+    v *= 2;
+  }
+
+  KISSAT_assert (v);
+  KISSAT_assert (UINT64_MAX / v >= reluctant->period);
+  uint64_t wait = v * reluctant->period;
+
+  if (reluctant->limited && wait > reluctant->limit) {
+    u = v = 1;
+    wait = reluctant->period;
+  }
+
+  reluctant->trigger = true;
+  reluctant->wait = wait;
+  reluctant->u = u;
+  reluctant->v = v;
+}
+
+void kissat_init_reluctant (kissat *solver) {
+  if (GET_OPTION (reluctant)) {
+    LOG ("enable reluctant doubling with period %d limit %d",
+         GET_OPTION (reluctantint), GET_OPTION (reluctantlim));
+    kissat_enable_reluctant (&solver->reluctant, GET_OPTION (reluctantint),
+                             GET_OPTION (reluctantlim));
+  } else {
+    LOG ("reluctant doubling disabled and thus no stable restarts");
+    kissat_disable_reluctant (&solver->reluctant);
+  }
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/reluctant.h b/src/sat/kissat/reluctant.h
new file mode 100644
index 000000000..1ee419f56
--- /dev/null
+++ b/src/sat/kissat/reluctant.h
@@ -0,0 +1,38 @@
+#ifndef _reluctant_h_INCLUDED
+#define _reluctant_h_INCLUDED
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct reluctant reluctant;
+
+struct reluctant {
+  bool limited;
+  bool trigger;
+  uint64_t period;
+  uint64_t wait;
+  uint64_t u, v;
+  uint64_t limit;
+};
+
+void kissat_enable_reluctant (reluctant *, uint64_t period, uint64_t limit);
+void kissat_disable_reluctant (reluctant *);
+void kissat_tick_reluctant (reluctant *);
+
+static inline bool kissat_reluctant_triggered (reluctant *reluctant) {
+  if (!reluctant->trigger)
+    return false;
+  reluctant->trigger = false;
+  return true;
+}
+
+struct kissat;
+
+void kissat_init_reluctant (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/reorder.c b/src/sat/kissat/reorder.c
new file mode 100644
index 000000000..fc04d3a9a
--- /dev/null
+++ b/src/sat/kissat/reorder.c
@@ -0,0 +1,226 @@
+#include "reorder.h"
+#include "backtrack.h"
+#include "bump.h"
+#include "inline.h"
+#include "inlineheap.h"
+#include "inlinequeue.h"
+#include "inlinevector.h"
+#include "internal.h"
+#include "logging.h"
+#include "print.h"
+#include "report.h"
+#include "sort.h"
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_reordering (kissat *solver) {
+  if (!GET_OPTION (reorder))
+    return false;
+  if (!solver->stable && GET_OPTION (reorder) < 2)
+    return false;
+  if (solver->level)
+    return false;
+  return CONFLICTS >= solver->limits.reorder.conflicts;
+}
+
+static double *compute_weights (kissat *solver) {
+  double *weights = (double*)kissat_calloc (solver, LITS, sizeof *weights);
+  const unsigned max_size = GET_OPTION (reordermaxsize);
+  LOG ("limiting weight computation to maximum clause size %u", max_size);
+  KISSAT_assert (2 <= max_size);
+  double *table = (double*)kissat_nalloc (solver, max_size + 1, sizeof *table);
+  {
+    double weight = 1;
+    for (unsigned size = 2; size <= max_size; size++) {
+      LOG ("score table[%u] = %g", size, weight);
+      table[size] = weight, weight /= 2.0;
+    }
+  }
+  {
+    KISSAT_assert (!solver->level);
+    const signed char *const values = solver->values;
+    const clause *last = kissat_last_irredundant_clause (solver);
+    for (all_clauses (c)) {
+      if (last && c > last)
+        break;
+      if (c->redundant)
+        continue;
+      if (c->garbage)
+        continue;
+      unsigned size = 0;
+      int continue_with_next_clause = 0;
+      for (all_literals_in_clause (lit, c)) {
+        const signed char value = values[lit];
+        if (value > 0) {
+          continue_with_next_clause = 1;
+          break;
+        }
+        if (!value && size < max_size && ++size == max_size)
+          break;
+      }
+      if(continue_with_next_clause) {
+        continue;
+      }
+      const double weight = table[size];
+      for (all_literals_in_clause (lit, c))
+        weights[lit] += weight;
+    }
+  }
+  KISSAT_assert (solver->watching);
+  {
+    double weight = table[2];
+    kissat_dealloc (solver, table, max_size + 1, sizeof *table);
+    for (all_literals (lit)) {
+      const unsigned idx = IDX (lit);
+      if (!ACTIVE (idx))
+        continue;
+      watches *watches = &WATCHES (lit);
+      for (all_binary_blocking_watches (watch, *watches)) {
+        if (!watch.type.binary)
+          continue;
+        const unsigned other = watch.type.lit;
+        if (other < lit)
+          continue;
+        const unsigned other_idx = IDX (other);
+        if (!ACTIVE (other_idx))
+          continue;
+        weights[lit] += weight;
+        weights[other] += weight;
+      }
+    }
+  }
+  for (all_variables (idx)) {
+    if (!ACTIVE (idx))
+      continue;
+    unsigned lit = LIT (idx), not_lit = NOT (lit);
+    double pos = weights[lit], neg = weights[not_lit];
+    double max_pos_neg = MAX (pos, neg);
+    double min_pos_neg = MIN (pos, neg);
+    double scaled_min_pos_neg = 2 * min_pos_neg;
+    double weight = max_pos_neg + scaled_min_pos_neg;
+    LOG ("computed weight %g "
+         "= %g + %g = max (%g, %g) + 2 * min (%g, %g) of %s",
+         weight, max_pos_neg, scaled_min_pos_neg, pos, neg, pos, neg,
+         LOGVAR (idx));
+    weights[idx] = weight;
+  }
+  return weights;
+}
+
+static bool less_focused_order (unsigned a, unsigned b, links *links,
+                                double *weights) {
+  double u = weights[a], v = weights[b];
+  if (u < v)
+    return true;
+  if (u > v)
+    return false;
+  unsigned s = links[a].stamp, t = links[b].stamp;
+  return s < t;
+}
+
+static bool less_stable_order (unsigned a, unsigned b, heap *scores,
+                               double *weights) {
+  double u = weights[a], v = weights[b];
+  if (u < v)
+    return true;
+  if (u > v)
+    return false;
+  double s = kissat_get_heap_score (scores, a);
+  double t = kissat_get_heap_score (scores, b);
+  if (s < t)
+    return true;
+  if (s > t)
+    return false;
+  return b < a;
+}
+
+#define LESS_FOCUSED_ORDER(A, B) less_focused_order (A, B, links, weights)
+
+#define LESS_STABLE_ORDER(A, B) less_stable_order (A, B, scores, weights)
+
+static void sort_active_variables_by_weight (kissat *solver,
+                                             unsigneds *sorted,
+                                             double *weights) {
+  INIT_STACK (*sorted);
+  for (all_variables (idx))
+    if (ACTIVE (idx))
+      PUSH_STACK (*sorted, idx);
+  if (solver->stable) {
+    heap *scores = SCORES;
+    SORT_STACK (unsigned, *sorted, LESS_STABLE_ORDER);
+#ifdef LOGGING
+    for (all_stack (unsigned, idx, *sorted))
+      if (ACTIVE (idx))
+        LOG ("reordered %s with weight %g score %g", LOGVAR (idx),
+             weights[idx], kissat_get_heap_score (scores, idx));
+#endif
+  } else {
+    struct links *links = solver->links;
+    SORT_STACK (unsigned, *sorted, LESS_FOCUSED_ORDER);
+#ifdef LOGGING
+    for (all_stack (unsigned, idx, *sorted))
+      if (ACTIVE (idx))
+        LOG ("reordered %s with weight %g stamp %u", LOGVAR (idx),
+             weights[idx], links[idx].stamp);
+#endif
+  }
+}
+
+static void reorder_focused (kissat *solver) {
+  INC (reordered_focused);
+  KISSAT_assert (!solver->stable);
+  double *weights = compute_weights (solver);
+  unsigneds sorted;
+  sort_active_variables_by_weight (solver, &sorted, weights);
+  kissat_dealloc (solver, weights, LITS, sizeof *weights);
+  for (all_stack (unsigned, idx, sorted)) {
+    KISSAT_assert (ACTIVE (idx));
+    kissat_move_to_front (solver, idx);
+  }
+  RELEASE_STACK (sorted);
+}
+
+static void reorder_stable (kissat *solver) {
+  INC (reordered_stable);
+  KISSAT_assert (solver->stable);
+  double *weights = compute_weights (solver);
+  kissat_rescale_scores (solver);
+  unsigneds sorted;
+  sort_active_variables_by_weight (solver, &sorted, weights);
+  heap *scores = SCORES;
+  while (!EMPTY_STACK (sorted)) {
+    unsigned idx = POP_STACK (sorted);
+    KISSAT_assert (ACTIVE (idx));
+    const double old_score = kissat_get_heap_score (scores, idx);
+    const double weight = weights[idx];
+    const double new_score = old_score + weight;
+    LOG ("updating score of %s to %g = %g (old score) + %g (weight)",
+         LOGVAR (idx), new_score, old_score, weight);
+    kissat_update_heap (solver, scores, idx, new_score);
+  }
+  kissat_dealloc (solver, weights, LITS, sizeof *weights);
+  RELEASE_STACK (sorted);
+}
+
+void kissat_reorder (kissat *solver) {
+  START (reorder);
+  INC (reordered);
+  KISSAT_assert (!solver->level);
+  kissat_phase (solver, "reorder", GET (reordered),
+                "reorder limit %" PRIu64 " hit a after %" PRIu64
+                " conflicts in %s mode ",
+                solver->limits.reorder.conflicts, CONFLICTS,
+                solver->stable ? "stable" : "focused");
+  if (solver->stable)
+    reorder_stable (solver);
+  else
+    reorder_focused (solver);
+  kissat_phase (solver, "reorder", GET (reordered),
+                "reordered decisions in %s search mode",
+                solver->stable ? "stable" : "focused");
+  UPDATE_CONFLICT_LIMIT (reorder, reordered, LINEAR, false);
+  REPORT (0, 'o');
+  STOP (reorder);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/reorder.h b/src/sat/kissat/reorder.h
new file mode 100644
index 000000000..d26dd0721
--- /dev/null
+++ b/src/sat/kissat/reorder.h
@@ -0,0 +1,16 @@
+#ifndef _reorder_h_INCLUDED
+#define _reorder_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_reordering (struct kissat *);
+void kissat_reorder (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/rephase.c b/src/sat/kissat/rephase.c
new file mode 100644
index 000000000..00e0dfadb
--- /dev/null
+++ b/src/sat/kissat/rephase.c
@@ -0,0 +1,141 @@
+#include "rephase.h"
+#include "backtrack.h"
+#include "decide.h"
+#include "internal.h"
+#include "logging.h"
+#include "print.h"
+#include "report.h"
+#include "terminate.h"
+#include "walk.h"
+
+#include <inttypes.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void kissat_reset_best_assigned (kissat *solver) {
+  if (!solver->best_assigned)
+    return;
+  kissat_extremely_verbose (solver,
+                            "resetting best assigned trail height %u to 0",
+                            solver->best_assigned);
+  solver->best_assigned = 0;
+}
+
+static void kissat_reset_target_assigned (kissat *solver) {
+  if (!solver->target_assigned)
+    return;
+  kissat_extremely_verbose (
+      solver, "resetting target assigned trail height %u to 0",
+      solver->target_assigned);
+  solver->target_assigned = 0;
+}
+
+bool kissat_rephasing (kissat *solver) {
+  if (!GET_OPTION (rephase))
+    return false;
+  if (!solver->stable)
+    return false;
+  return CONFLICTS > solver->limits.rephase.conflicts;
+}
+
+static char rephase_best (kissat *solver) {
+  const value *const best = solver->phases.best;
+  const value *const end_of_best = best + VARS;
+  value const *b;
+
+  value *const saved = solver->phases.saved;
+  value *s, tmp;
+
+  for (s = saved, b = best; b != end_of_best; s++, b++)
+    if ((tmp = *b))
+      *s = tmp;
+
+  INC (rephased_best);
+
+  return 'B';
+}
+
+static char rephase_original (kissat *solver) {
+  const value initial_phase = INITIAL_PHASE;
+  value *s = solver->phases.saved;
+  const value *const end = s + VARS;
+  while (s != end)
+    *s++ = initial_phase;
+  INC (rephased_original);
+  return 'O';
+}
+
+static char rephase_inverted (kissat *solver) {
+  const value inverted_initial_phase = -INITIAL_PHASE;
+  value *s = solver->phases.saved;
+  const value *const end = s + VARS;
+  while (s != end)
+    *s++ = inverted_initial_phase;
+  INC (rephased_inverted);
+  return 'I';
+}
+
+static char rephase_walking (kissat *solver) {
+  KISSAT_assert (kissat_walking (solver));
+  STOP (rephase);
+  kissat_walk (solver);
+  START (rephase);
+  INC (rephased_walking);
+  return 'W';
+}
+
+static char (*rephase_schedule[]) (kissat *) = {
+    rephase_best, rephase_walking, rephase_inverted,
+    rephase_best, rephase_walking, rephase_original,
+};
+
+#define size_rephase_schedule \
+  (sizeof rephase_schedule / sizeof *rephase_schedule)
+
+#ifndef KISSAT_QUIET
+
+static const char *rephase_type_as_string (char type) {
+  if (type == 'B')
+    return "best";
+  if (type == 'I')
+    return "inverted";
+  if (type == 'O')
+    return "original";
+  KISSAT_assert (type == 'W');
+  return "walking";
+}
+
+#endif
+
+static char reset_phases (kissat *solver) {
+  const uint64_t count = GET (rephased);
+  KISSAT_assert (count > 0);
+  const uint64_t select = (count - 1) % (uint64_t) size_rephase_schedule;
+  const char type = rephase_schedule[select](solver);
+  kissat_phase (
+      solver, "rephase", GET (rephased), "%s phases in %s search mode",
+      rephase_type_as_string (type), solver->stable ? "stable" : "focused");
+  LOG ("copying saved phases as target phases");
+  memcpy (solver->phases.target, solver->phases.saved, VARS);
+  UPDATE_CONFLICT_LIMIT (rephase, rephased, NLOG3N, false);
+  kissat_reset_target_assigned (solver);
+  if (type == 'B')
+    kissat_reset_best_assigned (solver);
+  return type;
+}
+
+void kissat_rephase (kissat *solver) {
+  kissat_backtrack_propagate_and_flush_trail (solver);
+  KISSAT_assert (!solver->inconsistent);
+  START (rephase);
+  INC (rephased);
+#ifndef KISSAT_QUIET
+  const char type =
+#endif
+      reset_phases (solver);
+  REPORT (0, type);
+  STOP (rephase);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/rephase.h b/src/sat/kissat/rephase.h
new file mode 100644
index 000000000..4ab597866
--- /dev/null
+++ b/src/sat/kissat/rephase.h
@@ -0,0 +1,16 @@
+#ifndef _rephase_h_INCLUDED
+#define _rephase_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_rephasing (struct kissat *);
+void kissat_rephase (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/report.c b/src/sat/kissat/report.c
new file mode 100644
index 000000000..820774b96
--- /dev/null
+++ b/src/sat/kissat/report.c
@@ -0,0 +1,161 @@
+#include "global.h"
+
+#ifndef KISSAT_QUIET
+
+#include "report.h"
+#include "colors.h"
+#include "internal.h"
+#include "print.h"
+#include "resources.h"
+
+#include <inttypes.h>
+#include <string.h>
+
+#define MB (kissat_current_resident_set_size () / (double) (1 << 20))
+
+#define REMAINING_VARIABLES \
+  kissat_percent (solver->active, statistics->variables_original)
+
+#define REPORTS \
+  REP ("seconds", "5.2f", kissat_time (solver)) \
+  REP ("MB", "2.0f", MB) \
+  REP ("level", ".0f", AVERAGE (level)) \
+  REP ("switched", "1" PRIu64, statistics->switched) \
+  REP ("reductions", "1" PRIu64, statistics->reductions) \
+  REP ("restarts", "2" PRIu64, statistics->restarts) \
+  REP ("rate", ".0f", AVERAGE (decision_rate)) \
+  REP ("conflicts", "3" PRIu64, CONFLICTS) \
+  REP ("redundant", "3" PRIu64, REDUNDANT_CLAUSES) \
+  REP ("size/glue", ".1f", \
+       kissat_average (AVERAGE (size), AVERAGE (slow_glue))) \
+  REP ("size", ".0f", AVERAGE (size)) \
+  REP ("glue", ".0f", AVERAGE (slow_glue)) \
+  REP ("tier1", "1u", solver->tier1[solver->stable]) \
+  REP ("tier2", "1u", solver->tier2[solver->stable]) \
+  REP ("trail", ".0f%%", AVERAGE (trail)) \
+  REP ("binary", "3" PRIu64, BINARY_CLAUSES) \
+  REP ("irredundant", "2" PRIu64, IRREDUNDANT_CLAUSES) \
+  REP ("variables", "2u", solver->active) \
+  REP ("remaining", "1.0f%%", REMAINING_VARIABLES)
+
+void kissat_report (kissat *solver, bool verbose, char type) {
+  statistics *statistics = &solver->statistics;
+  const int verbosity = kissat_verbosity (solver);
+  if (verbosity < 0)
+    return;
+  if (verbose && verbosity < 2)
+    return;
+  char line[128], *p = line;
+  unsigned pad[32], n = 1, pos = 0;
+  pad[0] = 0;
+  // clang-format off
+#define REP(NAME,FMT,VALUE) \
+  do { \
+    *p++ = ' ', pos++; \
+    sprintf (p, "%" FMT, VALUE); \
+    while (*p) \
+      p++, pos++; \
+    pad[n++] = pos; \
+  } while (0);
+  REPORTS
+#undef REP
+  // clang-format on
+  KISSAT_assert (p < line + sizeof line);
+  TERMINAL (stdout, 1);
+  if (!(solver->limits.reports++ % 20)) {
+#define ROWS 3
+    unsigned last[ROWS];
+    char rows[ROWS][128], *r[ROWS];
+    for (unsigned j = 0; j < ROWS; j++)
+      last[j] = 0, rows[j][0] = 0, r[j] = rows[j];
+    unsigned row = 0, i = 1;
+#define REP(NAME, FMT, VALUE) \
+  do { \
+    if (last[row]) \
+      *r[row]++ = ' ', last[row]++; \
+    unsigned target = pad[i]; \
+    const unsigned name_len = strlen (NAME); \
+    const unsigned val_len = target - pad[i - 1] - 1; \
+    if (val_len < name_len) \
+      target += (name_len - val_len) / 2; \
+    while (last[row] + name_len < target) \
+      *r[row]++ = ' ', last[row]++; \
+    for (const char *p = NAME; *p; p++) \
+      *r[row]++ = *p, last[row]++; \
+    if (++row == ROWS) \
+      row = 0; \
+    i++; \
+  } while (0);
+    REPORTS
+#undef REP
+    KISSAT_assert (i == n);
+    for (unsigned j = 0; j < ROWS; j++) {
+      KISSAT_assert (r[j] < rows[j] + sizeof rows[j]);
+      *r[j] = 0;
+    }
+    if (solver->limits.reports > 1)
+      kissat_line (solver);
+    for (unsigned j = 0; j < ROWS; j++) {
+      fputs (solver->prefix, stdout);
+      COLOR (CYAN);
+      fputs (rows[j], stdout);
+      COLOR (NORMAL);
+      fputc ('\n', stdout);
+    }
+    kissat_line (solver);
+  }
+  kissat_prefix (solver);
+  switch (type) {
+  case '1':
+  case '0':
+  case '?':
+  case 'i':
+  case '.':
+    COLOR (BOLD);
+    break;
+  case 'e':
+    COLOR (BOLD GREEN);
+    break;
+  case '2':
+  case 's':
+    COLOR (GREEN);
+    break;
+  case 'f':
+  case 't':
+  case 'u':
+  case 'v':
+  case 'w':
+  case 'x':
+    COLOR (BLUE);
+    break;
+  case 'b':
+  case 'c':
+  case 'd':
+  case '=':
+    COLOR (BOLD BLUE);
+    break;
+  case '[':
+  case ']':
+    COLOR (MAGENTA);
+    break;
+  case '(':
+  case ')':
+    COLOR (BOLD YELLOW);
+  }
+  fputc (type, stdout);
+  COLOR (NORMAL);
+  if (solver->preprocessing)
+    COLOR (YELLOW);
+  else if (solver->stable)
+    COLOR (MAGENTA);
+  fputs (line, stdout);
+  COLOR (NORMAL);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#else
+
+int kissat_report_dummy_to_avoid_warning;
+
+#endif
diff --git a/src/sat/kissat/report.h b/src/sat/kissat/report.h
new file mode 100644
index 000000000..9b6207890
--- /dev/null
+++ b/src/sat/kissat/report.h
@@ -0,0 +1,30 @@
+#ifndef _report_h_INCLUDED
+#define _report_h_INCLUDED
+
+#include "global.h"
+
+#ifdef KISSAT_QUIET
+
+ABC_NAMESPACE_HEADER_START
+
+#define REPORT(...) \
+  do { \
+  } while (0)
+
+#else
+
+#include <stdbool.h>
+
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_report (struct kissat *, bool verbose, char type);
+
+#define REPORT(LEVEL, TYPE) kissat_report (solver, (LEVEL), (TYPE))
+
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/require.h b/src/sat/kissat/require.h
new file mode 100644
index 000000000..d938691f3
--- /dev/null
+++ b/src/sat/kissat/require.h
@@ -0,0 +1,35 @@
+#ifndef _require_h_INCLUDED
+#define _require_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define kissat_require(COND, ...) \
+  do { \
+    if ((COND)) \
+      break; \
+    kissat_fatal_message_start (); \
+    fprintf (stderr, "calling '%s': ", __func__); \
+    fprintf (stderr, __VA_ARGS__); \
+    fputc ('\n', stderr); \
+    fflush (stderr); \
+    kissat_abort (); \
+  } while (0)
+
+#define kissat_require_initialized(SOLVER) \
+  kissat_require (SOLVER, "uninitialized")
+
+#define kissat_require_valid_external_internal(LIT) \
+  do { \
+    kissat_require ((LIT) != INT_MIN, "invalid literal '%d' (INT_MIN)", \
+                    (LIT)); \
+    const int TMP_IDX = ABS (LIT); \
+    kissat_require (TMP_IDX <= EXTERNAL_MAX_VAR, \
+                    "invalid literal '%d' (variable larger than %d)", \
+                    (LIT), EXTERNAL_MAX_VAR); \
+    KISSAT_assert (VALID_EXTERNAL_LITERAL (LIT)); \
+  } while (0)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/resize.c b/src/sat/kissat/resize.c
new file mode 100644
index 000000000..83306a772
--- /dev/null
+++ b/src/sat/kissat/resize.c
@@ -0,0 +1,141 @@
+#include "resize.h"
+#include "allocate.h"
+#include "inline.h"
+#include "require.h"
+
+#include <limits.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#define NREALLOC_GENERIC(TYPE, NAME, ELEMENTS_PER_BLOCK) \
+  do { \
+    const size_t block_size = sizeof (TYPE); \
+    solver->NAME = \
+      (TYPE*) kissat_nrealloc (solver, solver->NAME, old_size, new_size,      \
+                         ELEMENTS_PER_BLOCK * block_size); \
+  } while (0)
+
+#define CREALLOC_GENERIC(TYPE, NAME, ELEMENTS_PER_BLOCK) \
+  do { \
+    const size_t block_size = sizeof (TYPE); \
+    TYPE *NAME = \
+      (TYPE*) kissat_calloc (solver, ELEMENTS_PER_BLOCK * new_size, block_size); \
+    if (old_size) { \
+      const size_t bytes = ELEMENTS_PER_BLOCK * old_size * block_size; \
+      memcpy (NAME, solver->NAME, bytes); \
+    } \
+    kissat_dealloc (solver, solver->NAME, ELEMENTS_PER_BLOCK *old_size, \
+                    block_size); \
+    solver->NAME = NAME; \
+  } while (0)
+
+#define NREALLOC_VARIABLE_INDEXED(TYPE, NAME) \
+  NREALLOC_GENERIC (TYPE, NAME, 1)
+
+#define NREALLOC_LITERAL_INDEXED(TYPE, NAME) \
+  NREALLOC_GENERIC (TYPE, NAME, 2)
+
+#define CREALLOC_VARIABLE_INDEXED(TYPE, NAME) \
+  CREALLOC_GENERIC (TYPE, NAME, 1)
+
+#define CREALLOC_LITERAL_INDEXED(TYPE, NAME) \
+  CREALLOC_GENERIC (TYPE, NAME, 2)
+
+static void reallocate_trail (kissat *solver, unsigned old_size,
+                              unsigned new_size) {
+  unsigned propagated = solver->propagate - BEGIN_ARRAY (solver->trail);
+  REALLOCATE_ARRAY (unsigned, solver->trail, old_size, new_size);
+  solver->propagate = BEGIN_ARRAY (solver->trail) + propagated;
+}
+
+void kissat_increase_size (kissat *solver, unsigned new_size) {
+  KISSAT_assert (solver->vars <= new_size);
+  const unsigned old_size = solver->size;
+  if (old_size >= new_size)
+    return;
+
+#ifdef METRICS
+  LOG ("%s before increasing size from %u to %u",
+       FORMAT_BYTES (kissat_allocated (solver)), old_size, new_size);
+#endif
+  CREALLOC_VARIABLE_INDEXED (struct assigned, assigned);
+  CREALLOC_VARIABLE_INDEXED (struct flags, flags);
+  NREALLOC_VARIABLE_INDEXED (struct links, links);
+
+  CREALLOC_LITERAL_INDEXED (mark, marks);
+  CREALLOC_LITERAL_INDEXED (value, values);
+  CREALLOC_LITERAL_INDEXED (struct vector, watches);
+
+  reallocate_trail (solver, old_size, new_size);
+  kissat_resize_heap (solver, SCORES, new_size);
+  kissat_increase_phases (solver, new_size);
+
+  solver->size = new_size;
+
+#ifdef METRICS
+  LOG ("%s after increasing size from %u to %u",
+       FORMAT_BYTES (kissat_allocated (solver)), old_size, new_size);
+#endif
+}
+
+void kissat_decrease_size (kissat *solver) {
+  const unsigned old_size = solver->size;
+  const unsigned new_size = solver->vars;
+
+#ifdef METRICS
+  LOG ("%s before decreasing size from %u to %u",
+       FORMAT_BYTES (kissat_allocated (solver)), old_size, new_size);
+#endif
+
+  NREALLOC_VARIABLE_INDEXED (assigned, assigned);
+  NREALLOC_VARIABLE_INDEXED (flags, flags);
+  NREALLOC_VARIABLE_INDEXED (links, links);
+
+  NREALLOC_LITERAL_INDEXED (mark, marks);
+  NREALLOC_LITERAL_INDEXED (value, values);
+  NREALLOC_LITERAL_INDEXED (watches, watches);
+
+  reallocate_trail (solver, old_size, new_size);
+  kissat_resize_heap (solver, SCORES, new_size);
+  kissat_decrease_phases (solver, new_size);
+
+  solver->size = new_size;
+
+#ifdef METRICS
+  LOG ("%s after decreasing size from %u to %u",
+       FORMAT_BYTES (kissat_allocated (solver)), old_size, new_size);
+#endif
+}
+
+void kissat_enlarge_variables (kissat *solver, unsigned new_vars) {
+  if (solver->vars >= new_vars)
+    return;
+  KISSAT_assert (new_vars <= INTERNAL_MAX_VAR + 1);
+  LOG ("enlarging variables from %u to %u", solver->vars, new_vars);
+  const size_t old_size = solver->size;
+  if (old_size < new_vars) {
+    LOG ("old size %zu below requested new number of variables %u",
+         old_size, new_vars);
+    size_t new_size;
+    if (!old_size)
+      new_size = new_vars;
+    else {
+      if (kissat_is_power_of_two (old_size)) {
+        KISSAT_assert (old_size <= UINT_MAX / 2);
+        new_size = 2 * old_size;
+      } else {
+        KISSAT_assert (1 < old_size);
+        new_size = 2;
+      }
+      while (new_size < new_vars) {
+        KISSAT_assert (new_size <= UINT_MAX / 2);
+        new_size *= 2;
+      }
+    }
+    kissat_increase_size (solver, new_size);
+  }
+  solver->vars = new_vars;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/resize.h b/src/sat/kissat/resize.h
new file mode 100644
index 000000000..55e578574
--- /dev/null
+++ b/src/sat/kissat/resize.h
@@ -0,0 +1,15 @@
+#ifndef _resize_h_INCLUDED
+#define _resize_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_decrease_size (struct kissat *solver);
+void kissat_increase_size (struct kissat *, unsigned new_size);
+void kissat_enlarge_variables (struct kissat *, unsigned new_vars);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/resolve.c b/src/sat/kissat/resolve.c
new file mode 100644
index 000000000..f6b1e6902
--- /dev/null
+++ b/src/sat/kissat/resolve.c
@@ -0,0 +1,374 @@
+#include "resolve.h"
+#include "eliminate.h"
+#include "gates.h"
+#include "inline.h"
+#include "print.h"
+
+#include <inttypes.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static inline unsigned occurrences_literal (kissat *solver, unsigned lit,
+                                            bool *update) {
+  KISSAT_assert (!solver->watching);
+
+  watches *watches = &WATCHES (lit);
+#ifdef LOGGING
+  const size_t size_watches = SIZE_WATCHES (*watches);
+  LOG ("literal %s has %zu watches", LOGLIT (lit), size_watches);
+#endif
+  const unsigned clslim = GET_OPTION (eliminateclslim);
+
+  watch *const begin = BEGIN_WATCHES (*watches), *q = begin;
+  const watch *const end = END_WATCHES (*watches), *p = q;
+
+  const value *const values = solver->values;
+  ward *const arena = BEGIN_STACK (solver->arena);
+
+  bool failed = false;
+  unsigned res = 0;
+
+  while (p != end) {
+    const watch head = *q++ = *p++;
+    if (head.type.binary) {
+      const unsigned other = head.binary.lit;
+      const value value = values[other];
+      KISSAT_assert (value >= 0);
+      if (value > 0) {
+        kissat_eliminate_binary (solver, lit, other);
+        q--;
+      } else
+        res++;
+    } else {
+      const reference ref = head.large.ref;
+      KISSAT_assert (ref < SIZE_STACK (solver->arena));
+      clause *const c = (struct clause *) (arena + ref);
+      if (c->garbage)
+        q--;
+      else if (c->size > clslim) {
+        LOG ("literal %s watches too long clause of size %u", LOGLIT (lit),
+             c->size);
+        failed = true;
+        break;
+      } else
+        res++;
+    }
+  }
+  while (p != end)
+    *q++ = *p++;
+  SET_END_OF_WATCHES (*watches, q);
+  if (failed)
+    return UINT_MAX;
+  if (q != end) {
+    *update = true;
+    LOG ("literal %s actually occurs only %u times", LOGLIT (lit), res);
+  }
+  return res;
+}
+
+static inline clause *watch_to_clause (kissat *solver, ward *const arena,
+                                       clause *const tmp, unsigned lit,
+                                       watch watch) {
+  clause *res;
+  if (watch.type.binary) {
+    const unsigned other = watch.binary.lit;
+    tmp->lits[0] = lit;
+    tmp->lits[1] = other;
+    res = tmp;
+  } else {
+    const reference ref = watch.large.ref;
+    KISSAT_assert (ref < SIZE_STACK (solver->arena));
+    res = (struct clause *) (arena + ref);
+  }
+#ifdef KISSAT_NDEBUG
+  (void) solver;
+#endif
+  return res;
+}
+
+static bool generate_resolvents (kissat *solver, unsigned lit,
+                                 statches *const watches0,
+                                 statches *const watches1,
+                                 uint64_t *const resolved_ptr,
+                                 uint64_t limit) {
+  const unsigned not_lit = NOT (lit);
+  unsigned resolved = *resolved_ptr;
+  bool failed = false;
+
+  clause tmp0, tmp1;
+  memset (&tmp0, 0, sizeof tmp0);
+  memset (&tmp1, 0, sizeof tmp1);
+  tmp0.size = tmp1.size = 2;
+
+  ward *const arena = BEGIN_STACK (solver->arena);
+  const value *const values = solver->values;
+  value *const marks = solver->marks;
+
+  const unsigned clslim = GET_OPTION (eliminateclslim);
+
+  for (all_stack (watch, watch0, *watches0)) {
+    clause *const c = watch_to_clause (solver, arena, &tmp0, lit, watch0);
+
+    if (c->garbage) {
+      KISSAT_assert (c != &tmp0);
+      continue;
+    }
+
+    bool first_antecedent_satisfied = false;
+
+    for (all_literals_in_clause (other, c)) {
+      if (other == lit)
+        continue;
+      const value value = values[other];
+      if (value < 0)
+        continue;
+      if (value > 0) {
+        first_antecedent_satisfied = true;
+        if (c != &tmp0)
+          kissat_eliminate_clause (solver, c, other);
+        break;
+      }
+    }
+
+    if (first_antecedent_satisfied)
+      continue;
+
+    for (all_literals_in_clause (other, c)) {
+      if (other == lit)
+        continue;
+      KISSAT_assert (!marks[other]);
+      marks[other] = 1;
+    }
+
+    for (all_stack (watch, watch1, *watches1)) {
+      clause *const d =
+          watch_to_clause (solver, arena, &tmp1, not_lit, watch1);
+
+      if (d->garbage) {
+        KISSAT_assert (d != &tmp1);
+        continue;
+      }
+
+      LOGCLS (c, "first %s antecedent", LOGLIT (lit));
+      LOGCLS (d, "second %s antecedent", LOGLIT (not_lit));
+
+      bool resolvent_satisfied_or_tautological = false;
+      const size_t saved = SIZE_STACK (solver->resolvents);
+
+      INC (eliminate_resolutions);
+
+      for (all_literals_in_clause (other, d)) {
+        if (other == not_lit)
+          continue;
+        const value value = values[other];
+        if (value < 0) {
+          LOG2 ("dropping falsified literal %s", LOGLIT (other));
+          continue;
+        }
+        if (value > 0) {
+          if (d != &tmp1)
+            kissat_eliminate_clause (solver, d, other);
+          resolvent_satisfied_or_tautological = true;
+          break;
+        }
+        if (marks[other]) {
+          LOG2 ("dropping repeated %s literal", LOGLIT (other));
+          continue;
+        }
+        const unsigned not_other = NOT (other);
+        if (marks[not_other]) {
+          LOG ("resolvent tautological on %s and %s "
+               "with second %s antecedent",
+               LOGLIT (NOT (other)), LOGLIT (other), LOGLIT (not_lit));
+          resolvent_satisfied_or_tautological = true;
+          break;
+        }
+        LOG2 ("including unassigned literal %s", LOGLIT (other));
+        PUSH_STACK (solver->resolvents, other);
+      }
+
+      if (resolvent_satisfied_or_tautological) {
+        RESIZE_STACK (solver->resolvents, saved);
+        continue;
+      }
+
+      if (++resolved > limit) {
+        LOG ("limit of %" PRIu64 " resolvent exceeded", limit);
+        failed = true;
+        break;
+      }
+
+      for (all_literals_in_clause (other, c)) {
+        if (other == lit)
+          continue;
+        const value value = values[other];
+        KISSAT_assert (value <= 0);
+        if (value < 0) {
+          LOG2 ("dropping falsified literal %s", LOGLIT (other));
+          continue;
+        }
+        PUSH_STACK (solver->resolvents, other);
+      }
+
+      size_t size_resolvent = SIZE_STACK (solver->resolvents) - saved;
+      LOGLITS (size_resolvent, BEGIN_STACK (solver->resolvents) + saved,
+               "resolvent");
+
+      if (!size_resolvent) {
+        KISSAT_assert (!solver->inconsistent);
+        solver->inconsistent = true;
+        LOG ("resolved empty clause");
+        CHECK_AND_ADD_EMPTY ();
+        ADD_EMPTY_TO_PROOF ();
+        failed = true;
+        break;
+      }
+
+      if (size_resolvent == 1) {
+        const unsigned unit = PEEK_STACK (solver->resolvents, saved);
+        INC (eliminate_units);
+        kissat_learned_unit (solver, unit);
+        RESIZE_STACK (solver->resolvents, saved);
+        if (marks[unit] <= 0)
+          continue;
+        LOGCLS (c, "first antecedent becomes satisfied");
+        first_antecedent_satisfied = true;
+        (void) first_antecedent_satisfied;
+        break;
+      }
+
+      if (size_resolvent > clslim) {
+        LOG ("resolvent size limit exceeded");
+        failed = true;
+        break;
+      }
+
+      PUSH_STACK (solver->resolvents, INVALID_LIT);
+    }
+
+    for (all_literals_in_clause (other, c)) {
+      if (other == lit)
+        continue;
+      KISSAT_assert (marks[other] == 1);
+      marks[other] = 0;
+    }
+
+    if (failed)
+      break;
+  }
+
+  *resolved_ptr = resolved;
+
+  return !failed;
+}
+
+bool kissat_generate_resolvents (kissat *solver, unsigned idx,
+                                 unsigned *lit_ptr) {
+  unsigned lit = LIT (idx);
+  unsigned not_lit = NOT (lit);
+
+  bool update = false;
+  bool pure = false;
+  uint64_t limit;
+
+  {
+    unsigned pos_count = occurrences_literal (solver, lit, &update);
+    unsigned neg_count = occurrences_literal (solver, not_lit, &update);
+
+    if (pos_count > neg_count) {
+      SWAP (unsigned, lit, not_lit);
+      SWAP (size_t, pos_count, neg_count);
+    }
+
+    const unsigned occlim = GET_OPTION (eliminateocclim);
+    limit = pos_count + (uint64_t) neg_count;
+
+    if (pos_count && limit > occlim) {
+      LOG ("no elimination of variable %u "
+           "since it has %" PRIu64 " > %u occurrences",
+           idx, limit, occlim);
+      return false;
+    }
+
+    if (pos_count) {
+      const uint64_t bound = solver->bounds.eliminate.additional_clauses;
+      limit += bound;
+      LOG ("trying to eliminate %s "
+           "limit %" PRIu64 " bound %" PRIu64,
+           LOGVAR (idx), limit, bound);
+    } else {
+      LOG ("eliminating pure literal %s thus its variable %u", LOGLIT (lit),
+           idx);
+      pure = true;
+    }
+  }
+
+  *lit_ptr = lit;
+
+  INC (eliminate_attempted);
+  if (pure)
+    return true;
+
+  const bool gates = !pure && kissat_find_gates (solver, lit);
+
+  statches *const gates0 = &solver->gates[0];
+  statches *const gates1 = &solver->gates[1];
+
+  if (solver->values[lit]) {
+    kissat_extremely_verbose (solver, "definition produced unit");
+    CLEAR_STACK (*gates0);
+    CLEAR_STACK (*gates1);
+    return false;
+  }
+
+  bool failed = false;
+  uint64_t resolved = 0;
+
+  kissat_get_antecedents (solver, lit);
+  statches *const antecedents0 = &solver->antecedents[0];
+  statches *const antecedents1 = &solver->antecedents[1];
+
+  if (gates) {
+    LOG ("resolving gates[0] against antecedents[1] clauses");
+    if (!generate_resolvents (solver, lit, gates0, antecedents1, &resolved,
+                              limit))
+      failed = true;
+    else {
+      LOG ("resolving gates[1] against antecedents[0] clauses");
+      if (!generate_resolvents (solver, not_lit, gates1, antecedents0,
+                                &resolved, limit)) {
+        failed = true;
+      } else if (solver->resolve_gate) {
+        LOG ("need to resolved gates[0] against gates[1] too");
+        if (!generate_resolvents (solver, lit, gates0, gates1, &resolved,
+                                  limit))
+          failed = true;
+      }
+    }
+  } else {
+    LOG ("no gate extracted thus resolving all clauses");
+    if (!generate_resolvents (solver, lit, antecedents0, antecedents1,
+                              &resolved, limit))
+      failed = true;
+  }
+
+  CLEAR_STACK (*antecedents0);
+  CLEAR_STACK (*antecedents1);
+
+  if (failed) {
+    LOG ("elimination of %s failed", LOGVAR (IDX (lit)));
+    CLEAR_STACK (solver->resolvents);
+    if (update)
+      kissat_update_variable_score (solver, idx);
+  }
+
+  LOG ("resolved %" PRIu64 " resolvents", resolved);
+
+  CLEAR_STACK (*gates0);
+  CLEAR_STACK (*gates1);
+
+  return !failed;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/resolve.h b/src/sat/kissat/resolve.h
new file mode 100644
index 000000000..dfa594ecc
--- /dev/null
+++ b/src/sat/kissat/resolve.h
@@ -0,0 +1,16 @@
+#ifndef _resolve_h_INCLUDED
+#define _resolve_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_generate_resolvents (struct kissat *, unsigned idx,
+                                 unsigned *lit_ptr);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/resources.c b/src/sat/kissat/resources.c
new file mode 100644
index 000000000..82d398a90
--- /dev/null
+++ b/src/sat/kissat/resources.c
@@ -0,0 +1,108 @@
+#include "resources.h"
+
+//#include <sys/time.h>
+
+ABC_NAMESPACE_IMPL_START
+
+/* double kissat_wall_clock_time (void) { */
+/*   struct timeval tv; */
+/*   if (gettimeofday (&tv, 0)) */
+/*     return 0; */
+/*   return 1e-6 * tv.tv_usec + tv.tv_sec; */
+/* } */
+
+#ifndef KISSAT_QUIET
+
+#include "internal.h"
+#include "statistics.h"
+#include "utilities.h"
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+double kissat_process_time (void) {
+  struct rusage u;
+  double res;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  res = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;
+  res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
+  return res;
+}
+
+uint64_t kissat_maximum_resident_set_size (void) {
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  return ((uint64_t) u.ru_maxrss) << 10;
+}
+
+#ifdef __APPLE__
+
+#include <mach/task.h>
+mach_port_t mach_task_self (void);
+
+uint64_t kissat_current_resident_set_size (void) {
+  struct task_basic_info info;
+  mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT;
+  if (KERN_SUCCESS != task_info (mach_task_self (), TASK_BASIC_INFO,
+                                 (task_info_t) &info, &count))
+    return 0;
+  return info.resident_size;
+}
+
+#else
+
+uint64_t kissat_current_resident_set_size (void) {
+  char path[48];
+  sprintf (path, "/proc/%" PRIu64 "/statm", (uint64_t) getpid ());
+  FILE *file = fopen (path, "r");
+  if (!file)
+    return 0;
+  uint64_t dummy, rss;
+  int scanned = fscanf (file, "%" PRIu64 " %" PRIu64 "", &dummy, &rss);
+  fclose (file);
+  return scanned == 2 ? rss * sysconf (_SC_PAGESIZE) : 0;
+}
+
+#endif
+
+void kissat_print_resources (kissat *solver) {
+  uint64_t rss = kissat_maximum_resident_set_size ();
+  double t = kissat_time (solver);
+  printf ("%s"
+          "%-" SFW1 "s "
+          "%" SFW2 PRIu64 " "
+          "%-" SFW3 "s "
+          "%" SFW4 ".0f "
+          "MB\n",
+          solver->prefix, "maximum-resident-set-size:", rss, "bytes",
+          rss / (double) (1 << 20));
+#ifdef METRICS
+  statistics *statistics = &solver->statistics;
+  uint64_t max_allocated = statistics->allocated_max + sizeof (kissat);
+  printf ("%s"
+          "%-" SFW1 "s "
+          "%" SFW2 PRIu64 " "
+          "%-" SFW3 "s "
+          "%" SFW4 ".0f "
+          "%%\n",
+          solver->prefix, "max-allocated:", max_allocated, "bytes",
+          kissat_percent (max_allocated, rss));
+#endif
+  {
+    format buffer;
+    memset (&buffer, 0, sizeof buffer);
+    printf ("%sprocess-time: %30s %18.2f seconds\n", solver->prefix,
+            kissat_format_time (&buffer, t), t);
+  }
+  fflush (stdout);
+}
+
+#endif
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/resources.h b/src/sat/kissat/resources.h
new file mode 100644
index 000000000..e12635c52
--- /dev/null
+++ b/src/sat/kissat/resources.h
@@ -0,0 +1,28 @@
+#ifndef _resources_h_INCLUDED
+#define _resources_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+double kissat_wall_clock_time (void);
+
+#ifndef KISSAT_QUIET
+
+#ifndef _resources_h_INLCUDED
+#define _resources_h_INLCUDED
+
+#include <stdint.h>
+
+struct kissat;
+
+double kissat_process_time (void);
+uint64_t kissat_current_resident_set_size (void);
+uint64_t kissat_maximum_resident_set_size (void);
+void kissat_print_resources (struct kissat *);
+
+#endif
+
+#endif
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/restart.c b/src/sat/kissat/restart.c
new file mode 100644
index 000000000..12ce99bf7
--- /dev/null
+++ b/src/sat/kissat/restart.c
@@ -0,0 +1,135 @@
+#include "restart.h"
+#include "backtrack.h"
+#include "bump.h"
+#include "decide.h"
+#include "internal.h"
+#include "kimits.h"
+#include "logging.h"
+#include "print.h"
+#include "reluctant.h"
+#include "report.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_restarting (kissat *solver) {
+  KISSAT_assert (solver->unassigned);
+  if (!GET_OPTION (restart))
+    return false;
+  if (!solver->level)
+    return false;
+  if (CONFLICTS < solver->limits.restart.conflicts)
+    return false;
+  if (solver->stable)
+    return kissat_reluctant_triggered (&solver->reluctant);
+  const double fast = AVERAGE (fast_glue);
+  const double slow = AVERAGE (slow_glue);
+  const double margin = (100.0 + GET_OPTION (restartmargin)) / 100.0;
+  const double limit = margin * slow;
+  kissat_extremely_verbose (solver,
+                            "restart glue limit %g = "
+                            "%.02f * %g (slow glue) %c %g (fast glue)",
+                            limit, margin, slow,
+                            (limit > fast    ? '>'
+                             : limit == fast ? '='
+                                             : '<'),
+                            fast);
+  return (limit <= fast);
+}
+
+void kissat_update_focused_restart_limit (kissat *solver) {
+  KISSAT_assert (!solver->stable);
+  limits *limits = &solver->limits;
+  uint64_t restarts = solver->statistics_.restarts;
+  uint64_t delta = GET_OPTION (restartint);
+  if (restarts)
+    delta += kissat_logn (restarts) - 1;
+  limits->restart.conflicts = CONFLICTS + delta;
+  kissat_extremely_verbose (solver,
+                            "focused restart limit at %" PRIu64
+                            " after %" PRIu64 " conflicts ",
+                            limits->restart.conflicts, delta);
+}
+
+static unsigned reuse_stable_trail (kissat *solver) {
+  const heap *const scores = SCORES;
+  const unsigned next_idx = kissat_next_decision_variable (solver);
+  const double limit = kissat_get_heap_score (scores, next_idx);
+  unsigned level = solver->level, res = 0;
+  while (res < level) {
+    frame *f = &FRAME (res + 1);
+    const unsigned idx = IDX (f->decision);
+    const double score = kissat_get_heap_score (scores, idx);
+    if (score <= limit)
+      break;
+    res++;
+  }
+  return res;
+}
+
+static unsigned reuse_focused_trail (kissat *solver) {
+  const links *const links = solver->links;
+  const unsigned next_idx = kissat_next_decision_variable (solver);
+  const unsigned limit = links[next_idx].stamp;
+  LOG ("next decision variable stamp %u", limit);
+  unsigned level = solver->level, res = 0;
+  while (res < level) {
+    frame *f = &FRAME (res + 1);
+    const unsigned idx = IDX (f->decision);
+    const unsigned score = links[idx].stamp;
+    if (score <= limit)
+      break;
+    res++;
+  }
+  return res;
+}
+
+static unsigned reuse_trail (kissat *solver) {
+  KISSAT_assert (solver->level);
+  KISSAT_assert (!EMPTY_STACK (solver->trail));
+
+  if (!GET_OPTION (restartreusetrail))
+    return 0;
+
+  unsigned res;
+
+  if (solver->stable)
+    res = reuse_stable_trail (solver);
+  else
+    res = reuse_focused_trail (solver);
+
+  LOG ("matching trail level %u", res);
+
+  if (res) {
+    INC (restarts_reused_trails);
+    ADD (restarts_reused_levels, res);
+    LOG ("restart reuses trail at decision level %u", res);
+  } else
+    LOG ("restarts does not reuse the trail");
+
+  return res;
+}
+
+void kissat_restart (kissat *solver) {
+  START (restart);
+  INC (restarts);
+  ADD (restarts_levels, solver->level);
+  if (solver->stable)
+    INC (stable_restarts);
+  else
+    INC (focused_restarts);
+  unsigned level = reuse_trail (solver);
+  kissat_extremely_verbose (solver,
+                            "restarting after %" PRIu64 " conflicts"
+                            " (limit %" PRIu64 ")",
+                            CONFLICTS, solver->limits.restart.conflicts);
+  LOG ("restarting to level %u", level);
+  kissat_backtrack_in_consistent_state (solver, level);
+  if (!solver->stable)
+    kissat_update_focused_restart_limit (solver);
+  REPORT (1, 'R');
+  STOP (restart);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/restart.h b/src/sat/kissat/restart.h
new file mode 100644
index 000000000..7df4d64b5
--- /dev/null
+++ b/src/sat/kissat/restart.h
@@ -0,0 +1,18 @@
+#ifndef _restart_h_INCLUDED
+#define _restart_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#include <stdbool.h>
+
+struct kissat;
+
+bool kissat_restarting (struct kissat *);
+void kissat_restart (struct kissat *);
+
+void kissat_update_focused_restart_limit (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/search.c b/src/sat/kissat/search.c
new file mode 100644
index 000000000..ed283f50a
--- /dev/null
+++ b/src/sat/kissat/search.c
@@ -0,0 +1,233 @@
+#include "search.h"
+#include "analyze.h"
+#include "bump.h"
+#include "classify.h"
+#include "decide.h"
+#include "eliminate.h"
+#include "inline.h"
+#include "internal.h"
+#include "logging.h"
+#include "lucky.h"
+#include "preprocess.h"
+#include "print.h"
+#include "probe.h"
+#include "propsearch.h"
+#include "reduce.h"
+#include "reluctant.h"
+#include "reorder.h"
+#include "rephase.h"
+#include "report.h"
+#include "restart.h"
+#include "terminate.h"
+#include "trail.h"
+#include "walk.h"
+
+#include <inttypes.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void init_tiers (kissat *solver) {
+  for (unsigned stable = 0; stable != 2; stable++) {
+    if (!solver->tier1[stable]) {
+      KISSAT_assert (!solver->tier2[stable]);
+      solver->tier1[stable] = GET_OPTION (tier1);
+      solver->tier2[stable] = GET_OPTION (tier2);
+      if (solver->tier2[stable] <= solver->tier1[stable])
+        solver->tier2[stable] = solver->tier1[stable];
+      LOG ("initialized tier1[%u] glue to %u", stable,
+           solver->tier1[stable]);
+      LOG ("initialized tier2[%u] glue to %u", stable,
+           solver->tier2[stable]);
+      if (!solver->limits.glue.interval)
+        solver->limits.glue.interval = 2;
+    }
+  }
+}
+
+static void start_search (kissat *solver) {
+  START (search);
+  INC (searches);
+
+  bool stable = (GET_OPTION (stable) == 2);
+
+  solver->stable = stable;
+  kissat_phase (solver, "search", GET (searches),
+                "initializing %s search after %" PRIu64 " conflicts",
+                (stable ? "stable" : "focus"), CONFLICTS);
+
+  kissat_init_averages (solver, &AVERAGES);
+
+  kissat_classify (solver);
+
+  if (solver->stable) {
+    kissat_init_reluctant (solver);
+    kissat_update_scores (solver);
+  }
+
+  init_tiers (solver);
+
+  kissat_init_limits (solver);
+
+  unsigned seed = GET_OPTION (seed);
+  solver->random = seed;
+  LOG ("initialized random number generator with seed %u", seed);
+
+#ifndef KISSAT_QUIET
+  limits *limits = &solver->limits;
+  limited *limited = &solver->limited;
+  if (!limited->conflicts && !limited->decisions)
+    kissat_very_verbose (solver, "starting unlimited search");
+  else if (limited->conflicts && !limited->decisions)
+    kissat_very_verbose (
+        solver, "starting search with conflicts limited to %" PRIu64,
+        limits->conflicts);
+  else if (!limited->conflicts && limited->decisions)
+    kissat_very_verbose (
+        solver, "starting search with decisions limited to %" PRIu64,
+        limits->decisions);
+  else
+    kissat_very_verbose (
+        solver,
+        "starting search with decisions limited to %" PRIu64
+        " and conflicts limited to %" PRIu64,
+        limits->decisions, limits->conflicts);
+  if (stable) {
+    START (stable);
+    REPORT (0, '[');
+  } else {
+    START (focused);
+    REPORT (0, '{');
+  }
+#endif
+}
+
+static void stop_search (kissat *solver) {
+  if (solver->limited.conflicts) {
+    LOG ("reset conflict limit");
+    solver->limited.conflicts = false;
+  }
+
+  if (solver->limited.decisions) {
+    LOG ("reset decision limit");
+    solver->limited.decisions = false;
+  }
+
+  if (solver->termination.flagged) {
+    kissat_very_verbose (solver, "termination forced externally");
+    solver->termination.flagged = 0;
+  }
+
+  if (solver->stable) {
+    REPORT (0, ']');
+    STOP (stable);
+    solver->stable = false;
+  } else {
+    REPORT (0, '}');
+    STOP (focused);
+  }
+  STOP (search);
+}
+
+static void report_search_result (kissat *solver, int res) {
+#ifndef KISSAT_QUIET
+  LOG ("search result %d", res);
+  char type = (res == 10 ? '1' : res == 20 ? '0' : '?');
+  REPORT (0, type);
+#else
+  (void) solver, (void) res;
+#endif
+}
+
+static void iterate (kissat *solver) {
+  KISSAT_assert (solver->iterating);
+  solver->iterating = false;
+  REPORT (0, 'i');
+}
+
+static bool conflict_limit_hit (kissat *solver) {
+  if (!solver->limited.conflicts)
+    return false;
+  if (solver->limits.conflicts > solver->statistics_.conflicts)
+    return false;
+  kissat_very_verbose (
+      solver, "conflict limit %" PRIu64 " hit after %" PRIu64 " conflicts",
+      solver->limits.conflicts, solver->statistics_.conflicts);
+  return true;
+}
+
+static bool decision_limit_hit (kissat *solver) {
+  if (!solver->limited.decisions)
+    return false;
+  if (solver->limits.decisions > solver->statistics_.decisions)
+    return false;
+  kissat_very_verbose (
+      solver, "decision limit %" PRIu64 " hit after %" PRIu64 " decisions",
+      solver->limits.decisions, solver->statistics_.decisions);
+  return true;
+}
+
+static bool searching (kissat *solver) {
+  if (!kissat_propagated (solver))
+    return true;
+  if (!GET_OPTION (probeinit))
+    return true;
+  if (!GET_OPTION (eliminateinit))
+    return true;
+  if (conflict_limit_hit (solver))
+    return false;
+  return true;
+}
+
+int kissat_search (kissat *solver) {
+  REPORT (0, '*');
+  int res = 0;
+  if (solver->inconsistent)
+    res = 20;
+  if (!res && GET_OPTION (luckyearly))
+    res = kissat_lucky (solver);
+  if (!res && kissat_preprocessing (solver))
+    res = kissat_preprocess (solver);
+  if (!res && GET_OPTION (luckylate))
+    res = kissat_lucky (solver);
+  if (!res)
+    kissat_classify (solver);
+  if (!res && searching (solver)) {
+    start_search (solver);
+    while (!res) {
+      clause *conflict = kissat_search_propagate (solver);
+      if (conflict)
+        res = kissat_analyze (solver, conflict);
+      else if (solver->iterating)
+        iterate (solver);
+      else if (!solver->unassigned)
+        res = 10;
+      else if (TERMINATED (search_terminated_1))
+        break;
+      else if (kissat_reducing (solver))
+        res = kissat_reduce (solver);
+      else if (kissat_switching_search_mode (solver))
+        kissat_switch_search_mode (solver);
+      else if (kissat_restarting (solver))
+        kissat_restart (solver);
+      else if (kissat_reordering (solver))
+        kissat_reorder (solver);
+      else if (kissat_rephasing (solver))
+        kissat_rephase (solver);
+      else if (kissat_probing (solver))
+        res = kissat_probe (solver);
+      else if (kissat_eliminating (solver))
+        res = kissat_eliminate (solver);
+      else if (conflict_limit_hit (solver))
+        break;
+      else if (decision_limit_hit (solver))
+        break;
+      else
+        kissat_decide (solver);
+    }
+    stop_search (solver);
+  }
+  report_search_result (solver, res);
+  return res;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/search.h b/src/sat/kissat/search.h
new file mode 100644
index 000000000..33645269e
--- /dev/null
+++ b/src/sat/kissat/search.h
@@ -0,0 +1,13 @@
+#ifndef _search_h_INCLUDED
+#define _search_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+int kissat_search (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/shrink.c b/src/sat/kissat/shrink.c
new file mode 100644
index 000000000..e368cc8bc
--- /dev/null
+++ b/src/sat/kissat/shrink.c
@@ -0,0 +1,399 @@
+#include "shrink.h"
+#include "allocate.h"
+#include "inline.h"
+#include "minimize.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static void reset_shrinkable (kissat *solver) {
+#ifdef LOGGING
+  size_t reset = 0;
+#endif
+  while (!EMPTY_STACK (solver->shrinkable)) {
+    const unsigned idx = POP_STACK (solver->shrinkable);
+    assigned *a = solver->assigned + idx;
+    KISSAT_assert (a->shrinkable);
+    a->shrinkable = false;
+#ifdef LOGGING
+    reset++;
+#endif
+  }
+  LOG ("resetting %zu shrinkable variables", reset);
+}
+
+static void mark_shrinkable_as_removable (kissat *solver) {
+#ifdef LOGGING
+  size_t marked = 0, reset = 0;
+#endif
+  struct assigned *assigned = solver->assigned;
+  while (!EMPTY_STACK (solver->shrinkable)) {
+    const unsigned idx = POP_STACK (solver->shrinkable);
+    struct assigned *a = assigned + idx;
+    KISSAT_assert (a->shrinkable);
+    a->shrinkable = false;
+    KISSAT_assert (!a->poisoned);
+#ifdef LOGGING
+    reset++;
+#endif
+    if (a->removable)
+      continue;
+    kissat_push_removable (solver, assigned, idx);
+#ifdef LOGGING
+    marked++;
+#endif
+  }
+  LOG ("resetting %zu shrinkable variables", reset);
+  LOG ("marked %zu removable variables", marked);
+}
+
+static inline int shrink_literal (kissat *solver, assigned *assigned,
+                                  unsigned level, unsigned lit) {
+  KISSAT_assert (solver->assigned == assigned);
+  KISSAT_assert (VALUE (lit) < 0);
+
+  const unsigned idx = IDX (lit);
+  struct assigned *a = assigned + idx;
+  KISSAT_assert (a->level <= level);
+  if (!a->level) {
+    LOG2 ("skipping root level assigned %s", LOGLIT (lit));
+    return 0;
+  }
+  if (a->shrinkable) {
+    LOG2 ("skipping already shrinkable literal %s", LOGLIT (lit));
+    return 0;
+  }
+  if (a->level < level) {
+    if (a->removable) {
+      LOG2 ("skipping removable thus shrinkable %s", LOGLIT (lit));
+      return 0;
+    }
+    const bool always_minimize_on_lower_level = (GET_OPTION (shrink) > 2);
+    if (always_minimize_on_lower_level &&
+        kissat_minimize_literal (solver, lit, false)) {
+      LOG2 ("minimized thus shrinkable %s", LOGLIT (lit));
+      return 0;
+    }
+    LOG ("literal %s on lower level %u < %u not removable/shrinkable",
+         LOGLIT (lit), a->level, level);
+    return -1;
+  }
+  LOG2 ("marking %s as shrinkable", LOGLIT (lit));
+  a->shrinkable = true;
+  PUSH_STACK (solver->shrinkable, idx);
+  return 1;
+}
+
+static inline unsigned shrunken_block (kissat *solver, unsigned level,
+                                       unsigned *begin_block,
+                                       unsigned *end_block, unsigned uip) {
+  KISSAT_assert (uip != INVALID_LIT);
+  const unsigned not_uip = NOT (uip);
+  LOG ("found unique implication point %s on level %u", LOGLIT (uip),
+       level);
+
+  KISSAT_assert (begin_block < end_block);
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  const size_t tmp = end_block - begin_block;
+  LOG ("shrinking %zu literals on level %u to single literal %s", tmp,
+       level, LOGLIT (not_uip));
+  KISSAT_assert (tmp > 1);
+#endif
+
+#ifdef LOGGING
+  bool not_uip_was_in_clause = false;
+#endif
+  unsigned block_shrunken = 0;
+
+  for (unsigned *p = begin_block; p != end_block; p++) {
+    const unsigned lit = *p;
+    if (lit == INVALID_LIT)
+      continue;
+#ifdef LOGGING
+    if (lit == not_uip)
+      not_uip_was_in_clause = true;
+    else
+      LOG ("shrunken literal %s", LOGLIT (lit));
+#endif
+    *p = INVALID_LIT;
+    block_shrunken++;
+  }
+  *begin_block = not_uip;
+  KISSAT_assert (block_shrunken);
+  block_shrunken--;
+#ifdef LOGGING
+  if (not_uip_was_in_clause)
+    LOG ("keeping single literal %s on level %u", LOGLIT (not_uip), level);
+  else
+    LOG ("shrunken all literals on level %u and added %s instead", level,
+         LOGLIT (not_uip));
+#endif
+  const unsigned uip_idx = IDX (uip);
+  assigned *assigned = solver->assigned;
+  struct assigned *a = assigned + uip_idx;
+  if (!a->analyzed)
+    kissat_push_analyzed (solver, assigned, uip_idx);
+
+  mark_shrinkable_as_removable (solver);
+#ifndef LOGGING
+  (void) level;
+#endif
+  return block_shrunken;
+}
+
+static inline void push_literals_of_block (kissat *solver,
+                                           assigned *assigned,
+                                           unsigned *begin_block,
+                                           unsigned *end_block,
+                                           unsigned level) {
+  KISSAT_assert (assigned == solver->assigned);
+
+  for (const unsigned *p = begin_block; p != end_block; p++) {
+    const unsigned lit = *p;
+    if (lit == INVALID_LIT)
+      continue;
+#ifndef KISSAT_NDEBUG
+    int tmp =
+#endif
+        shrink_literal (solver, assigned, level, lit);
+    KISSAT_assert (tmp > 0);
+  }
+}
+
+static inline unsigned shrink_along_binary (kissat *solver,
+                                            assigned *assigned,
+                                            unsigned level, unsigned uip,
+                                            unsigned other) {
+  KISSAT_assert (VALUE (other) < 0);
+  LOGBINARY2 (uip, other, "shrinking along %s reason", LOGLIT (uip));
+  int tmp = shrink_literal (solver, assigned, level, other);
+#ifndef LOGGING
+  (void) uip;
+#endif
+  return tmp > 0;
+}
+
+static inline unsigned
+shrink_along_large (kissat *solver, assigned *assigned, unsigned level,
+                    unsigned uip, reference ref, bool *failed_ptr) {
+  unsigned open = 0;
+  LOGREF2 (ref, "shrinking along %s reason", LOGLIT (uip));
+  clause *c = kissat_dereference_clause (solver, ref);
+  if (GET_OPTION (minimizeticks))
+    INC (search_ticks);
+  for (all_literals_in_clause (other, c)) {
+    if (other == uip)
+      continue;
+    KISSAT_assert (VALUE (other) < 0);
+    int tmp = shrink_literal (solver, assigned, level, other);
+    if (tmp < 0) {
+      *failed_ptr = true;
+      break;
+    }
+    if (tmp > 0)
+      open++;
+  }
+  return open;
+}
+
+static inline unsigned shrink_along_reason (kissat *solver,
+                                            assigned *assigned,
+                                            unsigned level, unsigned uip,
+                                            bool resolve_large_clauses,
+                                            bool *failed_ptr) {
+  unsigned open = 0;
+  const unsigned uip_idx = IDX (uip);
+  struct assigned *a = assigned + uip_idx;
+  KISSAT_assert (a->shrinkable);
+  KISSAT_assert (a->level == level);
+  KISSAT_assert (a->reason != DECISION_REASON);
+  if (a->binary) {
+    const unsigned other = a->reason;
+    open = shrink_along_binary (solver, assigned, level, uip, other);
+  } else {
+    reference ref = a->reason;
+    if (resolve_large_clauses)
+      open = shrink_along_large (solver, assigned, level, uip, ref,
+                                 failed_ptr);
+    else {
+      LOGREF (ref, "not shrinking %s reason", LOGLIT (uip));
+      *failed_ptr = true;
+    }
+  }
+  return open;
+}
+
+static inline unsigned shrink_block (kissat *solver, unsigned *begin_block,
+                                     unsigned *end_block, unsigned level,
+                                     unsigned max_trail) {
+  KISSAT_assert (level < solver->level);
+
+  unsigned open = end_block - begin_block;
+
+  LOG ("trying to shrink %u literals on level %u", open, level);
+  LOG ("maximum trail position %u on level %u", max_trail, level);
+
+  assigned *assigned = solver->assigned;
+
+  push_literals_of_block (solver, assigned, begin_block, end_block, level);
+
+  KISSAT_assert (SIZE_STACK (solver->shrinkable) == open);
+
+  const unsigned *const begin_trail = BEGIN_ARRAY (solver->trail);
+
+  const bool resolve_large_clauses = (GET_OPTION (shrink) > 1);
+  unsigned uip = INVALID_LIT;
+  bool failed = false;
+
+  const unsigned *t = begin_trail + max_trail;
+
+  while (!failed) {
+    {
+      do
+        KISSAT_assert (begin_trail <= t), uip = *t--;
+      while (!assigned[IDX (uip)].shrinkable);
+    }
+    if (open == 1)
+      break;
+    open += shrink_along_reason (solver, assigned, level, uip,
+                                 resolve_large_clauses, &failed);
+    KISSAT_assert (open > 1);
+    open--;
+  }
+
+  unsigned block_shrunken = 0;
+  if (failed)
+    reset_shrinkable (solver);
+  else
+    block_shrunken =
+        shrunken_block (solver, level, begin_block, end_block, uip);
+
+  return block_shrunken;
+}
+
+static unsigned *next_block (kissat *solver, unsigned *begin_lits,
+                             unsigned *end_block, unsigned *level_ptr,
+                             unsigned *max_trail_ptr) {
+  assigned *assigned = solver->assigned;
+
+  unsigned level = INVALID_LEVEL;
+  unsigned max_trail = 0;
+
+  unsigned *begin_block = end_block;
+
+  while (begin_lits < begin_block) {
+    const unsigned lit = begin_block[-1];
+    KISSAT_assert (lit != INVALID_LIT);
+    const unsigned idx = IDX (lit);
+    struct assigned *a = assigned + idx;
+    unsigned lit_level = a->level;
+    if (level == INVALID_LEVEL) {
+      level = lit_level;
+      LOG ("starting to shrink level %u", level);
+    } else {
+      KISSAT_assert (lit_level >= level);
+      if (lit_level > level)
+        break;
+    }
+    begin_block--;
+    const unsigned trail = a->trail;
+    if (trail > max_trail)
+      max_trail = trail;
+  }
+
+  *level_ptr = level;
+  *max_trail_ptr = max_trail;
+
+  return begin_block;
+}
+
+static unsigned minimize_block (kissat *solver, unsigned *begin_block,
+                                unsigned *end_block) {
+  unsigned minimized = 0;
+
+  for (unsigned *p = begin_block; p != end_block; p++) {
+    const unsigned lit = *p;
+    KISSAT_assert (lit != INVALID_LIT);
+    if (!kissat_minimize_literal (solver, lit, true))
+      continue;
+    LOG ("minimize-shrunken literal %s", LOGLIT (lit));
+    *p = INVALID_LIT;
+    minimized++;
+  }
+
+  return minimized;
+}
+
+static inline unsigned *
+minimize_and_shrink_block (kissat *solver, unsigned *begin_lits,
+                           unsigned *end_block, unsigned *total_shrunken,
+                           unsigned *total_minimized) {
+  KISSAT_assert (EMPTY_STACK (solver->shrinkable));
+
+  unsigned level, max_trail;
+
+  unsigned *begin_block =
+      next_block (solver, begin_lits, end_block, &level, &max_trail);
+
+  unsigned open = end_block - begin_block;
+  KISSAT_assert (open > 0);
+
+  unsigned block_shrunken = 0;
+  unsigned block_minimized = 0;
+
+  if (open < 2)
+    LOG ("only one literal on level %u", level);
+  else {
+    block_shrunken =
+        shrink_block (solver, begin_block, end_block, level, max_trail);
+    if (!block_shrunken)
+      block_minimized = minimize_block (solver, begin_block, end_block);
+  }
+
+  block_shrunken += block_minimized;
+  LOG ("shrunken %u literals on level %u (including %u minimized)",
+       block_shrunken, level, block_minimized);
+
+  *total_minimized += block_minimized;
+  *total_shrunken += block_shrunken;
+
+  return begin_block;
+}
+
+void kissat_shrink_clause (kissat *solver) {
+  KISSAT_assert (GET_OPTION (minimize) > 0);
+  KISSAT_assert (GET_OPTION (shrink) > 0);
+  KISSAT_assert (!EMPTY_STACK (solver->clause));
+
+  START (shrink);
+
+  unsigned total_shrunken = 0;
+  unsigned total_minimized = 0;
+
+  unsigned *begin_lits = BEGIN_STACK (solver->clause);
+  unsigned *end_lits = END_STACK (solver->clause);
+
+  unsigned *end_block = END_STACK (solver->clause);
+
+  while (end_block != begin_lits)
+    end_block = minimize_and_shrink_block (
+        solver, begin_lits, end_block, &total_shrunken, &total_minimized);
+  unsigned *q = begin_lits;
+  for (const unsigned *p = q; p != end_lits; p++) {
+    const unsigned lit = *p;
+    if (lit != INVALID_LIT)
+      *q++ = lit;
+  }
+  LOG ("clause shrunken by %u literals (including %u minimized)",
+       total_shrunken, total_minimized);
+  KISSAT_assert (q + total_shrunken == end_lits);
+  SET_END_OF_STACK (solver->clause, q);
+  ADD (literals_shrunken, total_shrunken);
+  ADD (literals_minshrunken, total_minimized);
+
+  LOGTMP ("shrunken learned");
+  kissat_reset_poisoned (solver);
+
+  STOP (shrink);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/shrink.h b/src/sat/kissat/shrink.h
new file mode 100644
index 000000000..f50fc911c
--- /dev/null
+++ b/src/sat/kissat/shrink.h
@@ -0,0 +1,13 @@
+#ifndef _shrink_h_INCLUDED
+#define _shrink_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_shrink_clause (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/smooth.c b/src/sat/kissat/smooth.c
new file mode 100644
index 000000000..6129a7b83
--- /dev/null
+++ b/src/sat/kissat/smooth.c
@@ -0,0 +1,77 @@
+#include "allocate.h"
+#include "internal.h"
+#include "logging.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_init_smooth (kissat *solver, smooth *smooth, int window,
+                         const char *name) {
+  KISSAT_assert (window > 0);
+  const double alpha = 1.0 / window;
+  LOG ("initialized %s EMA alpha %g window %d", name, alpha, window);
+  smooth->value = 0;
+  smooth->biased = 0;
+  smooth->alpha = alpha;
+  smooth->beta = 1.0 - alpha;
+  KISSAT_assert (smooth->beta > 0);
+  smooth->exp = 1.0;
+#ifdef LOGGING
+  smooth->name = name;
+  smooth->updated = 0;
+#else
+  (void) solver;
+  (void) name;
+#endif
+}
+
+void kissat_update_smooth (kissat *solver, smooth *smooth, double y) {
+#ifdef LOGGING
+  smooth->updated++;
+  const double old_value = smooth->value;
+#endif
+  const double old_biased = smooth->biased;
+  const double alpha = smooth->alpha;
+  const double beta = smooth->beta;
+  const double delta = y - old_biased;
+  const double scaled_delta = alpha * delta;
+  const double new_biased = old_biased + scaled_delta;
+  LOG ("update %" PRIu64 " of biased %s EMA %g with %g (delta %g) "
+       "yields %g (scaled delta %g)",
+       smooth->updated, smooth->name, old_biased, y, delta, new_biased,
+       scaled_delta);
+  smooth->biased = new_biased;
+  double old_exp = smooth->exp;
+  double new_exp, div, new_value;
+  if (old_exp) {
+    new_exp = old_exp * beta;
+    KISSAT_assert (new_exp < 1);
+    if (new_exp == old_exp) {
+      new_exp = 0;
+      new_value = new_biased;
+#ifdef LOGGING
+      div = 1;
+#endif
+    } else {
+      div = 1 - new_exp;
+      KISSAT_assert (div > 0);
+      new_value = new_biased / div;
+    }
+    smooth->exp = new_exp;
+  } else {
+    new_value = new_biased;
+#ifdef LOGGING
+    new_exp = 0;
+    div = 1;
+#endif
+  }
+  smooth->value = new_value;
+  LOG ("update %" PRIu64 " of corrected %s EMA %g "
+       "with %g (delta %g) yields %g (exponent %g, div %g)",
+       smooth->updated, smooth->name, old_value, y, delta, new_value,
+       new_exp, div);
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/smooth.h b/src/sat/kissat/smooth.h
new file mode 100644
index 000000000..2fe4f1464
--- /dev/null
+++ b/src/sat/kissat/smooth.h
@@ -0,0 +1,27 @@
+#ifndef _smooth_h_INCLUDED
+#define _smooth_h_INCLUDED
+
+#include <stdint.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef struct smooth smooth;
+
+struct smooth {
+  double value, biased, alpha, beta, exp;
+#ifdef LOGGING
+  const char *name;
+  uint64_t updated;
+#endif
+};
+
+struct kissat;
+
+void kissat_init_smooth (struct kissat *, smooth *, int window,
+                         const char *);
+void kissat_update_smooth (struct kissat *, smooth *, double);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/sort.c b/src/sat/kissat/sort.c
new file mode 100644
index 000000000..943a67ee4
--- /dev/null
+++ b/src/sat/kissat/sort.c
@@ -0,0 +1,102 @@
+#include "internal.h"
+#include "logging.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static inline value
+move_smallest_literal_to_front (kissat *solver, const value *const values,
+                                const assigned *const assigned,
+                                bool satisfied_is_enough, unsigned start,
+                                unsigned size, unsigned *lits) {
+  KISSAT_assert (1 < size);
+  KISSAT_assert (start < size);
+
+  unsigned a = lits[start];
+
+  value u = values[a];
+  if (!u || (u > 0 && satisfied_is_enough))
+    return u;
+
+  unsigned pos = 0, best = a;
+
+  {
+    const unsigned i = IDX (a);
+    unsigned k = (u ? assigned[i].level : UINT_MAX);
+
+    KISSAT_assert (start < UINT_MAX);
+    for (unsigned i = start + 1; i < size; i++) {
+      const unsigned b = lits[i];
+      const value v = values[b];
+
+      if (!v || (v > 0 && satisfied_is_enough)) {
+        best = b;
+        pos = i;
+        u = v;
+        break;
+      }
+
+      const unsigned j = IDX (b);
+      const unsigned l = (v ? assigned[j].level : UINT_MAX);
+
+      bool better;
+
+      if (u < 0 && v > 0)
+        better = true;
+      else if (u > 0 && v < 0)
+        better = false;
+      else if (u < 0) {
+        KISSAT_assert (v < 0);
+        better = (k < l);
+      } else {
+        KISSAT_assert (u > 0);
+        KISSAT_assert (v > 0);
+        KISSAT_assert (!satisfied_is_enough);
+        better = (k > l);
+      }
+
+      if (!better)
+        continue;
+
+      best = b;
+      pos = i;
+      u = v;
+      k = l;
+    }
+  }
+
+  if (!pos)
+    return u;
+
+  lits[start] = best;
+  lits[pos] = a;
+
+  LOG ("new smallest literal %s at %u swapped with %s at %u", LOGLIT (best),
+       pos, LOGLIT (a), start);
+#ifndef LOGGING
+  (void) solver;
+#endif
+  return u;
+}
+
+#ifdef INLINE_SORT
+static inline
+#endif
+    void
+    kissat_sort_literals (kissat *solver,
+#ifdef INLINE_SORT
+                          const value *const values,
+                          const assigned *assigned,
+#endif
+                          unsigned size, unsigned *lits) {
+#ifndef INLINE_SORT
+  const value *const values = solver->values;
+  const assigned *const assigned = solver->assigned;
+#endif
+  value u = move_smallest_literal_to_front (solver, values, assigned, false,
+                                            0, size, lits);
+  if (size > 2)
+    move_smallest_literal_to_front (solver, values, assigned, (u >= 0), 1,
+                                    size, lits);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/sort.h b/src/sat/kissat/sort.h
new file mode 100644
index 000000000..a21aa4bba
--- /dev/null
+++ b/src/sat/kissat/sort.h
@@ -0,0 +1,159 @@
+#ifndef _sort_h_INCLUDED
+#define _sort_h_INCLUDED
+
+#include "utilities.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define GREATER_SWAP(TYPE, P, Q, LESS) \
+  do { \
+    if (LESS (Q, P)) \
+      SWAP (TYPE, P, Q); \
+  } while (0)
+
+#define SORTER (solver->sorter)
+
+#define PARTITION(TYPE, L, R, A, LESS) \
+  do { \
+    const size_t L_PARTITION = (L); \
+    I_QUICK_SORT = L_PARTITION - 1; \
+\
+    size_t J_PARTITION = (R); \
+\
+    TYPE PIVOT_PARTITION = A[J_PARTITION]; \
+\
+    for (;;) { \
+      while (LESS (A[++I_QUICK_SORT], PIVOT_PARTITION)) \
+        ; \
+      while (LESS (PIVOT_PARTITION, A[--J_PARTITION])) \
+        if (J_PARTITION == L_PARTITION) \
+          break; \
+\
+      if (I_QUICK_SORT >= J_PARTITION) \
+        break; \
+\
+      SWAP (TYPE, A[I_QUICK_SORT], A[J_PARTITION]); \
+    } \
+\
+    SWAP (TYPE, A[I_QUICK_SORT], A[R]); \
+  } while (0)
+
+#define QUICK_SORT_LIMIT 10
+
+#define QUICK_SORT(TYPE, N, A, LESS) \
+  do { \
+    KISSAT_assert (N); \
+    KISSAT_assert (EMPTY_STACK (SORTER)); \
+\
+    size_t L_QUICK_SORT = 0; \
+    size_t R_QUICK_SORT = N - 1; \
+\
+    if (R_QUICK_SORT - L_QUICK_SORT <= QUICK_SORT_LIMIT) \
+      break; \
+\
+    for (;;) { \
+      const size_t M = L_QUICK_SORT + (R_QUICK_SORT - L_QUICK_SORT) / 2; \
+\
+      SWAP (TYPE, A[M], A[R_QUICK_SORT - 1]); \
+\
+      GREATER_SWAP (TYPE, A[L_QUICK_SORT], A[R_QUICK_SORT - 1], LESS); \
+      GREATER_SWAP (TYPE, A[L_QUICK_SORT], A[R_QUICK_SORT], LESS); \
+      GREATER_SWAP (TYPE, A[R_QUICK_SORT - 1], A[R_QUICK_SORT], LESS); \
+\
+      size_t I_QUICK_SORT; \
+\
+      PARTITION (TYPE, L_QUICK_SORT + 1, R_QUICK_SORT - 1, A, LESS); \
+      KISSAT_assert (L_QUICK_SORT < I_QUICK_SORT); \
+      KISSAT_assert (I_QUICK_SORT <= R_QUICK_SORT); \
+\
+      size_t LL_QUICK_SORT; \
+      size_t RR_QUICK_SORT; \
+\
+      if (I_QUICK_SORT - L_QUICK_SORT < R_QUICK_SORT - I_QUICK_SORT) { \
+        LL_QUICK_SORT = I_QUICK_SORT + 1; \
+        RR_QUICK_SORT = R_QUICK_SORT; \
+        R_QUICK_SORT = I_QUICK_SORT - 1; \
+      } else { \
+        LL_QUICK_SORT = L_QUICK_SORT; \
+        RR_QUICK_SORT = I_QUICK_SORT - 1; \
+        L_QUICK_SORT = I_QUICK_SORT + 1; \
+      } \
+      if (R_QUICK_SORT - L_QUICK_SORT > QUICK_SORT_LIMIT) { \
+        KISSAT_assert (RR_QUICK_SORT - LL_QUICK_SORT > QUICK_SORT_LIMIT); \
+        PUSH_STACK (SORTER, LL_QUICK_SORT); \
+        PUSH_STACK (SORTER, RR_QUICK_SORT); \
+      } else if (RR_QUICK_SORT - LL_QUICK_SORT > QUICK_SORT_LIMIT) { \
+        L_QUICK_SORT = LL_QUICK_SORT; \
+        R_QUICK_SORT = RR_QUICK_SORT; \
+      } else if (!EMPTY_STACK (SORTER)) { \
+        R_QUICK_SORT = POP_STACK (SORTER); \
+        L_QUICK_SORT = POP_STACK (SORTER); \
+      } else \
+        break; \
+    } \
+  } while (0)
+
+#define INSERTION_SORT(TYPE, N, A, LESS) \
+  do { \
+    size_t L_INSERTION_SORT = 0; \
+    size_t R_INSERTION_SORT = N - 1; \
+\
+    for (size_t I_INSERTION_SORT = R_INSERTION_SORT; \
+         I_INSERTION_SORT > L_INSERTION_SORT; I_INSERTION_SORT--) \
+      GREATER_SWAP (TYPE, A[I_INSERTION_SORT - 1], A[I_INSERTION_SORT], \
+                    LESS); \
+\
+    for (size_t I_INSERTION_SORT = L_INSERTION_SORT + 2; \
+         I_INSERTION_SORT <= R_INSERTION_SORT; I_INSERTION_SORT++) { \
+      TYPE PIVOT_INSERTION_SORT = A[I_INSERTION_SORT]; \
+\
+      size_t J_INSERTION_SORT = I_INSERTION_SORT; \
+\
+      while (LESS (PIVOT_INSERTION_SORT, A[J_INSERTION_SORT - 1])) { \
+        A[J_INSERTION_SORT] = A[J_INSERTION_SORT - 1]; \
+        J_INSERTION_SORT--; \
+      } \
+\
+      A[J_INSERTION_SORT] = PIVOT_INSERTION_SORT; \
+    } \
+  } while (0)
+
+#ifdef KISSAT_NDEBUG
+#define CHECK_SORTED(...) \
+  do { \
+  } while (0)
+#else
+#define CHECK_SORTED(N, A, LESS) \
+  do { \
+    for (size_t I_CHECK_SORTED = 0; I_CHECK_SORTED < N - 1; \
+         I_CHECK_SORTED++) \
+      KISSAT_assert (!LESS (A[I_CHECK_SORTED + 1], A[I_CHECK_SORTED])); \
+  } while (0)
+#endif
+
+#define SORT(TYPE, N, A, LESS) \
+  do { \
+    const size_t N_SORT = (N); \
+    if (!N_SORT) \
+      break; \
+    START (sort); \
+    TYPE *A_SORT = (A); \
+    QUICK_SORT (TYPE, N_SORT, A_SORT, LESS); \
+    INSERTION_SORT (TYPE, N_SORT, A_SORT, LESS); \
+    CHECK_SORTED (N_SORT, A_SORT, LESS); \
+    STOP (sort); \
+  } while (0)
+
+#define SORT_STACK(TYPE, S, LESS) \
+  do { \
+    const size_t N_SORT_STACK = SIZE_STACK (S); \
+    if (N_SORT_STACK <= 1) \
+      break; \
+    TYPE *A_SORT_STACK = BEGIN_STACK (S); \
+    SORT (TYPE, N_SORT_STACK, A_SORT_STACK, LESS); \
+  } while (0)
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/stack.c b/src/sat/kissat/stack.c
new file mode 100644
index 000000000..30689adc8
--- /dev/null
+++ b/src/sat/kissat/stack.c
@@ -0,0 +1,55 @@
+#include "stack.h"
+#include "allocate.h"
+#include "utilities.h"
+
+#include <assert.h>
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_stack_enlarge (struct kissat *solver, chars *s, size_t bytes) {
+  const size_t size = SIZE_STACK (*s);
+  const size_t old_bytes = CAPACITY_STACK (*s);
+  KISSAT_assert (MAX_SIZE_T / 2 >= old_bytes);
+  size_t new_bytes;
+  if (old_bytes)
+    new_bytes = 2 * old_bytes;
+  else {
+    new_bytes = bytes;
+    while (!kissat_aligned_word (new_bytes))
+      new_bytes <<= 1;
+  }
+  s->begin = (char*)kissat_realloc (solver, s->begin, old_bytes, new_bytes);
+  s->allocated = s->begin + new_bytes;
+  s->end = s->begin + size;
+}
+
+void kissat_shrink_stack (struct kissat *solver, chars *s, size_t bytes) {
+  KISSAT_assert (bytes > 0);
+  const size_t old_bytes_capacity = CAPACITY_STACK (*s);
+  KISSAT_assert (kissat_aligned_word (old_bytes_capacity));
+  KISSAT_assert (!(old_bytes_capacity % bytes));
+  KISSAT_assert (kissat_is_zero_or_power_of_two (old_bytes_capacity / bytes));
+  const size_t old_bytes_size = SIZE_STACK (*s);
+  KISSAT_assert (!(old_bytes_size % bytes));
+  const size_t old_size = old_bytes_size / bytes;
+  size_t new_capacity;
+  if (old_size) {
+    const unsigned ld_old_size = kissat_log2_ceiling_of_word (old_size);
+    new_capacity = ((size_t) 1) << ld_old_size;
+  } else
+    new_capacity = 0;
+  KISSAT_assert (kissat_is_zero_or_power_of_two (new_capacity));
+  size_t new_bytes_capacity = new_capacity * bytes;
+  while (!kissat_aligned_word (new_bytes_capacity))
+    new_bytes_capacity <<= 1;
+  if (new_bytes_capacity == old_bytes_capacity)
+    return;
+  KISSAT_assert (new_bytes_capacity < old_bytes_capacity);
+  s->begin = (char*)kissat_realloc (solver, s->begin, old_bytes_capacity,
+                             new_bytes_capacity);
+  s->allocated = s->begin + new_bytes_capacity;
+  s->end = s->begin + old_bytes_size;
+  KISSAT_assert (s->end <= s->allocated);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/stack.h b/src/sat/kissat/stack.h
new file mode 100644
index 000000000..2024f5f3e
--- /dev/null
+++ b/src/sat/kissat/stack.h
@@ -0,0 +1,145 @@
+#ifndef _stack_h_INCLUDED
+#define _stack_h_INCLUDED
+
+#include <stdlib.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#define STACK(TYPE) \
+  struct { \
+    TYPE *begin; \
+    TYPE *end; \
+    TYPE *allocated; \
+  }
+
+#define FULL_STACK(S) ((S).end == (S).allocated)
+#define EMPTY_STACK(S) ((S).begin == (S).end)
+#define SIZE_STACK(S) ((size_t) ((S).end - (S).begin))
+#define CAPACITY_STACK(S) ((size_t) ((S).allocated - (S).begin))
+
+#define INIT_STACK(S) \
+  do { \
+    (S).begin = (S).end = (S).allocated = 0; \
+  } while (0)
+
+#define TOP_STACK(S) (END_STACK (S)[KISSAT_assert (!EMPTY_STACK (S)), -1])
+
+#define PEEK_STACK(S, N) \
+  (BEGIN_STACK (S)[KISSAT_assert ((N) < SIZE_STACK (S)), (N)])
+
+#define POKE_STACK(S, N, E) \
+  do { \
+    PEEK_STACK (S, N) = (E); \
+  } while (0)
+
+#define POP_STACK(S) (KISSAT_assert (!EMPTY_STACK (S)), *--(S).end)
+
+#define ENLARGE_STACK(S) \
+  do { \
+    KISSAT_assert (FULL_STACK (S)); \
+    kissat_stack_enlarge (solver, (chars *) &(S), sizeof *(S).begin); \
+  } while (0)
+
+#define SHRINK_STACK(S) \
+  do { \
+    if (!FULL_STACK (S)) \
+      kissat_shrink_stack (solver, (chars *) &(S), sizeof *(S).begin); \
+  } while (0)
+
+#define PUSH_STACK(S, E) \
+  do { \
+    if (FULL_STACK (S)) \
+      ENLARGE_STACK (S); \
+    *(S).end++ = (E); \
+  } while (0)
+
+#define BEGIN_STACK(S) (S).begin
+
+#define END_STACK(S) (S).end
+
+#define CLEAR_STACK(S) \
+  do { \
+    (S).end = (S).begin; \
+  } while (0)
+
+#define RESIZE_STACK(S, NEW_SIZE) \
+  do { \
+    const size_t TMP_NEW_SIZE = (NEW_SIZE); \
+    KISSAT_assert (TMP_NEW_SIZE <= SIZE_STACK (S)); \
+    (S).end = (S).begin + TMP_NEW_SIZE; \
+  } while (0)
+
+#define SET_END_OF_STACK(S, P) \
+  do { \
+    KISSAT_assert (BEGIN_STACK (S) <= (P)); \
+    KISSAT_assert ((P) <= END_STACK (S)); \
+    if ((P) == END_STACK (S)) \
+      break; \
+    (S).end = (P); \
+  } while (0)
+
+#define RELEASE_STACK(S) \
+  do { \
+    DEALLOC ((S).begin, CAPACITY_STACK (S)); \
+    INIT_STACK (S); \
+  } while (0)
+
+#define REMOVE_STACK(T, S, E) \
+  do { \
+    KISSAT_assert (!EMPTY_STACK (S)); \
+    T *END_REMOVE_STACK = END_STACK (S); \
+    T *P_REMOVE_STACK = BEGIN_STACK (S); \
+    while (*P_REMOVE_STACK != (E)) { \
+      P_REMOVE_STACK++; \
+      KISSAT_assert (P_REMOVE_STACK != END_REMOVE_STACK); \
+    } \
+    P_REMOVE_STACK++; \
+    while (P_REMOVE_STACK != END_REMOVE_STACK) { \
+      P_REMOVE_STACK[-1] = *P_REMOVE_STACK; \
+      P_REMOVE_STACK++; \
+    } \
+    (S).end--; \
+  } while (0)
+
+#define REVERSE_STACK(T, S) \
+  do { \
+    if (SIZE_STACK (S) < 2) \
+      break; \
+    T *HEAD = (S).begin, *TAIL = (S).end - 1; \
+    while (HEAD < TAIL) { \
+      T TMP = *HEAD; \
+      *HEAD++ = *TAIL; \
+      *TAIL-- = TMP; \
+    } \
+  } while (0)
+
+#define all_stack(T, E, S) \
+  T E, *E##_PTR = BEGIN_STACK (S), *const E##_END = END_STACK (S); \
+  E##_PTR != E##_END && (E = *E##_PTR, true); \
+  ++E##_PTR
+
+#define all_pointers(T, E, S) \
+  T *E, *const *E##_PTR = BEGIN_STACK (S), \
+               *const *const E##_END = END_STACK (S); \
+  E##_PTR != E##_END && (E = *E##_PTR, true); \
+  ++E##_PTR
+
+// clang-format off
+
+typedef STACK (char) chars;
+typedef STACK (int) ints;
+typedef STACK (size_t) sizes;
+typedef STACK (unsigned) unsigneds;
+
+// clang-format on
+
+struct kissat;
+
+void kissat_stack_enlarge (struct kissat *, chars *,
+                           size_t size_of_element);
+void kissat_shrink_stack (struct kissat *, chars *, size_t size_of_element);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/statistics.c b/src/sat/kissat/statistics.c
new file mode 100644
index 000000000..e767638ca
--- /dev/null
+++ b/src/sat/kissat/statistics.c
@@ -0,0 +1,430 @@
+#include "global.h"
+
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_NDEBUG)
+#include "internal.h"
+#endif
+
+#ifndef KISSAT_QUIET
+
+#include "resources.h"
+#include "tiers.h"
+#include "utilities.h"
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_print_glue_usage (kissat *solver) {
+  const int64_t stable = solver->statistics.clauses_used_stable;
+  const int64_t focused = solver->statistics.clauses_used_focused;
+  if (!stable && !focused)
+    printf ("%sno clauses used at all\n", solver->prefix);
+  else {
+    if (focused)
+      kissat_print_tier_usage_statistics (solver, false);
+    if (focused && stable)
+      printf ("c\n");
+    if (stable)
+      kissat_print_tier_usage_statistics (solver, true);
+  }
+  fflush (stdout);
+}
+
+// clang-format off
+
+void
+kissat_statistics_print (kissat * solver, bool verbose)
+{
+  statistics *statistics = &solver->statistics;
+
+  const double time = kissat_process_time ();
+  size_t variables = solver->statistics.variables_original;
+#ifdef METRICS
+  const double rss = kissat_maximum_resident_set_size ();
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#define RELATIVE(FIRST,SECOND) \
+  kissat_average (statistics->FIRST, statistics->SECOND)
+
+/*------------------------------------------------------------------------*/
+
+#define CONF_INT(NAME) \
+  RELATIVE (conflicts, NAME)
+
+#define SWEEPS_PER_COMPLETED(NAME) \
+  RELATIVE (sweep, NAME)
+
+#define NO_SECONDARY(NAME) \
+  0
+
+/*------------------------------------------------------------------------*/
+
+#define PER_BACKBONE(NAME) \
+  RELATIVE (NAME, backbone_computations)
+
+#define PER_BACKBONE_UNIT(NAME) \
+  RELATIVE (NAME, backbone_units)
+
+#define PER_CLOSURE(NAME) \
+  RELATIVE(NAME, closures)
+
+#define PER_CLS_ADDED(NAME) \
+  RELATIVE (NAME, clauses_added)
+
+#define PER_CLS_FACTORED(NAME) \
+  RELATIVE (NAME, clauses_factored)
+
+#define PER_CLS_LEARNED(NAME) \
+  RELATIVE (NAME, clauses_learned)
+
+#define PER_CLS_UNFACTORED(NAME) \
+  RELATIVE (NAME, clauses_unfactored)
+
+#define PER_CONFLICT(NAME) \
+  RELATIVE (NAME, conflicts)
+
+#define PER_CONGRANDS(NAME) \
+  RELATIVE (NAME, congruent_gates_ands)
+
+#define PER_CONGRGATES(NAME) \
+  RELATIVE (NAME, congruent_gates)
+
+#define PER_CONGRITES(NAME) \
+  RELATIVE (NAME, congruent_gates_ites)
+
+#define PER_CONGRLOOKUP(NAME) \
+  RELATIVE (NAME, congruent_lookups)
+
+#define PER_CONGRXORS(NAME) \
+  RELATIVE (NAME, congruent_gates_xors)
+
+#define PER_FIXED(NAME) \
+  RELATIVE (NAME, units)
+
+#ifndef STATISTICS
+#define PER_FLIPPED(NAME) \
+  -1
+#else
+#define PER_FLIPPED(NAME) \
+  RELATIVE (NAME, flipped)
+#endif
+
+#define PER_FORWARD_CHECK(NAME) \
+  RELATIVE (NAME, forward_checks)
+
+#define PER_KITTEN_PROP(NAME) \
+  RELATIVE (NAME, kitten_propagations)
+
+#define PER_KITTEN_SOLVED(NAME) \
+  RELATIVE (NAME, kitten_solved)
+
+#define PER_PROPAGATION(NAME) \
+  RELATIVE (NAME, propagations)
+
+#define PER_RESTART(NAME) \
+  RELATIVE (NAME, restarts)
+
+#define PER_SECOND(NAME) \
+  kissat_average (statistics->NAME, time)
+
+#define PER_SWEEP_VARIABLES(NAME) \
+  kissat_average (statistics->NAME, statistics->sweep_variables)
+
+#define PER_VARIABLE(NAME) \
+  kissat_average (statistics->NAME, variables)
+
+#define PER_VIVIFICATION(NAME) \
+  RELATIVE (NAME, vivifications)
+
+#define PER_VIVIFY_CHECK(NAME) \
+  RELATIVE (NAME, vivify_checks)
+
+#if 0 //ndef STATISTICS
+#define PER_WALKS(NAME) \
+  -1
+#else
+#define PER_WALKS(NAME) \
+  RELATIVE (NAME, walks)
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#define PERCENT(FIRST,SECOND) \
+  kissat_percent (statistics->FIRST, statistics->SECOND)
+
+/*------------------------------------------------------------------------*/
+
+#define PCNT_ARENA_RESIZED(NAME) \
+  PERCENT (NAME, arena_resized)
+
+#define PCNT_CLS_ADDED(NAME) \
+  PERCENT (NAME, clauses_added)
+
+#define PCNT_CLS_IMPROVED(NAME) \
+  PERCENT (NAME, clauses_improved)
+
+#define PCNT_CLS_IMPROVED(NAME) \
+  PERCENT (NAME, clauses_improved)
+
+#define PCNT_CLS_FACTORED(NAME) \
+  PERCENT (NAME, clauses_factored)
+
+#define PCNT_CLS_LEARNED(NAME) \
+  PERCENT (NAME, clauses_learned)
+
+#define PCNT_CLS_ORIGINAL(NAME) \
+  PERCENT (NAME, clauses_original)
+
+#define PCNT_CLS_REDUCED(NAME) \
+  PERCENT (NAME, clauses_reduced)
+
+#define PCNT_CLS_USED(NAME) \
+  PERCENT (NAME, clauses_used)
+
+#define PCNT_COLLECTIONS(NAME) \
+  PERCENT (NAME, garbage_collections)
+
+#define PCNT_CONFLICTS(NAME) \
+  PERCENT (NAME, conflicts)
+
+#define PCNT_CONGRCOLS(NAME) \
+  PERCENT (NAME, congruent_collisions)
+
+#define PCNT_CONGRGATES(NAME) \
+  PERCENT (NAME, congruent_gates)
+
+#define PCNT_CONGRLOOKUP(NAME) \
+  PERCENT (NAME, congruent_lookups)
+
+#define PCNT_CONGRMATCHED(NAME) \
+  PERCENT (NAME, congruent_matched)
+
+#define PCNT_CONGREWR(NAME) \
+  PERCENT (NAME, congruent_rewritten)
+
+#define PCNT_CONGRSIMPS(NAME) \
+  PERCENT (NAME, congruent_simplified)
+
+#define PCNT_CONGRUENT(NAME) \
+  PERCENT (NAME, congruent)
+
+#define PCNT_CONGRUNARY(NAME) \
+  PERCENT (NAME, congruent_unary)
+
+#define PCNT_DECISIONS(NAME) \
+  PERCENT (NAME, decisions)
+
+#define PCNT_DEFRAGS(NAME) \
+  PERCENT (NAME, defragmentations)
+
+#define PCNT_ELIM_ATTEMPTS(NAME) \
+  PERCENT (NAME, eliminate_attempted)
+
+#define PCNT_ELIMINATED(NAME) \
+  PERCENT (NAME, eliminated)
+
+#define PCNT_EXTRACTED(NAME) \
+  PERCENT (NAME, gates_extracted)
+
+#define PCNT_IRREDUNDANT(NAME) \
+  PERCENT (NAME, clauses_irredundant)
+
+#define PCNT_KITTEN_FLIP(NAME) \
+  PERCENT (NAME, kitten_flip)
+
+#define PCNT_KITTEN_SOLVED(NAME) \
+  PERCENT (NAME, kitten_solved)
+
+#define PCNT_LITS_DEDUCED(NAME) \
+  PERCENT (NAME, literals_deduced)
+
+#define PCNT_LITS_SHRUNKEN(NAME) \
+  PERCENT (NAME, literals_shrunken)
+
+#define PCNT_PROPS(NAME) \
+  PERCENT (NAME, propagations)
+
+#define PCNT_REDUCTIONS(NAME) \
+  PERCENT (NAME, reductions)
+
+#define PCNT_REDUNDANT_CLAUSES(NAME) \
+  PERCENT (NAME, clauses_redundant)
+
+#define PCNT_REORDERED(NAME) \
+  PERCENT (NAME, reordered)
+
+#define PCNT_REPHASED(NAME) \
+  PERCENT (NAME, rephased)
+
+#define PCNT_RESIDENT_SET(NAME) \
+  kissat_percent (statistics->NAME, rss)
+
+#define PCNT_RESTARTS(NAME) \
+  PERCENT (NAME, restarts)
+
+#define PCNT_RESTARTS_LEVELS(NAME) \
+  PERCENT (NAME, restarts_levels)
+
+#define PCNT_SEARCHES(NAME) \
+  PERCENT (NAME, searches)
+
+#define PCNT_STRENGTHENED(NAME) \
+  PERCENT (NAME, strengthened)
+
+#define PCNT_SUBSUMED(NAME) \
+  PERCENT (NAME, subsumed)
+
+#define PCNT_SUBSUMPTION_CHECK(NAME) \
+  PERCENT (NAME, subsumption_checks)
+
+#define PCNT_SWEEP_FLIP_BACKBONE(NAME) \
+  PERCENT (NAME, sweep_flip_backbone)
+
+#define PCNT_SWEEP_FLIP_EQUIVALENCES(NAME) \
+  PERCENT (NAME, sweep_flip_equivalences)
+
+#define PCNT_SWEEP_SOLVED_BACKBONE(NAME) \
+  PERCENT (NAME, sweep_solved_backbone)
+
+#define PCNT_SWEEP_SOLVED_EQUIVALENCES(NAME) \
+  PERCENT (NAME, sweep_solved_equivalences)
+
+#define PCNT_SWEEP_SOLVED(NAME) \
+  PERCENT (NAME, sweep_solved)
+
+#ifndef STATISTICS
+#define PCNT_TICKS(NAME) \
+  -1
+#else
+#define PCNT_TICKS(NAME) \
+  PERCENT (NAME, ticks)
+#endif
+
+#define PCNT_VARIABLES(NAME) \
+  kissat_percent (statistics->NAME, variables)
+
+#define PCNT_VIVIFIED(NAME) \
+  PERCENT (NAME, vivified)
+
+#define PCNT_VIVIFY_IMP(NAME) \
+  PERCENT (NAME, vivified_implied)
+
+#define PCNT_VIVIFY_INST(NAME) \
+  PERCENT (NAME, vivified_instantiated)
+
+#define PCNT_VIVIFY_CHECK(NAME) \
+  PERCENT (NAME, vivify_checks)
+
+#define PCNT_VIVIFY_PROBES(NAME) \
+  PERCENT (NAME, vivify_probes)
+
+#define PCNT_VIVIFY_SHRUNKEN(NAME) \
+  PERCENT (NAME, vivified_shrunken)
+
+#define PCNT_VIVIFY_SUB(NAME) \
+  PERCENT (NAME, vivified_subsumed)
+
+#define PCNT_WALKS(NAME) \
+  PERCENT (NAME, walks)
+
+#define COUNTER(NAME,VERBOSE,OTHER,UNITS,TYPE) \
+  if (verbose || !VERBOSE || (VERBOSE == 1 && statistics->NAME)) \
+    PRINT_STAT (#NAME, statistics->NAME, OTHER(NAME), UNITS, TYPE);
+#define IGNORE(...)
+
+  METRICS_COUNTERS_AND_STATISTICS
+
+#undef COUNTER
+#undef METRIC
+#undef STATISTIC
+
+  fflush (stdout);
+}
+
+// clang-format on
+
+ABC_NAMESPACE_IMPL_END
+
+#elif defined(KISSAT_NDEBUG)
+
+ABC_NAMESPACE_IMPL_START
+
+int kissat_statistics_dummy_to_avoid_warning;
+
+ABC_NAMESPACE_IMPL_END
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#ifndef KISSAT_NDEBUG
+
+#include "inlinevector.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_check_statistics (kissat *solver) {
+  if (solver->inconsistent)
+    return;
+
+  size_t redundant = 0;
+  size_t irredundant = 0;
+  size_t arena_garbage = 0;
+
+  for (all_clauses (c)) {
+    if (c->garbage) {
+      arena_garbage += kissat_actual_bytes_of_clause (c);
+      continue;
+    }
+    if (c->redundant)
+      redundant++;
+    else
+      irredundant++;
+  }
+
+  size_t binary = 0;
+
+  if (solver->watching) {
+    for (all_literals (lit)) {
+      watches *watches = &WATCHES (lit);
+
+      for (all_binary_blocking_watches (watch, *watches)) {
+        if (watch.type.binary) {
+          binary++;
+        }
+      }
+    }
+  } else {
+    for (all_literals (lit)) {
+      watches *watches = &WATCHES (lit);
+
+      for (all_binary_large_watches (watch, *watches)) {
+        if (watch.type.binary) {
+          binary++;
+        }
+      }
+    }
+  }
+
+  KISSAT_assert (!(binary & 1));
+  binary /= 2;
+
+  statistics *statistics = &solver->statistics_;
+  KISSAT_assert (statistics->clauses_binary == binary);
+  KISSAT_assert (statistics->clauses_redundant == redundant);
+  KISSAT_assert (statistics->clauses_irredundant == irredundant);
+#ifdef METRICS
+  KISSAT_assert (statistics->arena_garbage == arena_garbage);
+#else
+  (void) arena_garbage;
+#endif
+}
+
+ABC_NAMESPACE_IMPL_END
+
+#endif
diff --git a/src/sat/kissat/statistics.h b/src/sat/kissat/statistics.h
new file mode 100644
index 000000000..b0f4e6faf
--- /dev/null
+++ b/src/sat/kissat/statistics.h
@@ -0,0 +1,472 @@
+#ifndef _statistics_h_INCLUDED
+#define _statistics_h_INCLUDED
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+// clang-format off
+
+#define METRICS_COUNTERS_AND_STATISTICS \
+\
+  METRIC (allocated_collected, 2, PCNT_RESIDENT_SET, "%", "resident set") \
+  METRIC (allocated_current, 2, PCNT_RESIDENT_SET, "%", "resident set") \
+  METRIC (allocated_max, 2, PCNT_RESIDENT_SET, "%", "resident set") \
+  STATISTIC (ands_eliminated, 1, PCNT_ELIMINATED, "%", "eliminated") \
+  METRIC (ands_extracted, 1, PCNT_EXTRACTED, "%", "extracted") \
+  METRIC (arena_enlarged, 1, PCNT_ARENA_RESIZED, "%", "resize") \
+  METRIC (arena_garbage, 1, PCNT_RESIDENT_SET, "%", "resident set") \
+  METRIC (arena_resized, 1, CONF_INT, "", "interval") \
+  METRIC (arena_shrunken, 1, PCNT_ARENA_RESIZED, "%", "resize") \
+  COUNTER (backbone_computations, 2, CONF_INT, "", "interval") \
+  METRIC (backbone_implied, 1, PER_BACKBONE_UNIT, 0, "per unit") \
+  METRIC (backbone_probes, 2, PER_VARIABLE, "", "per variable") \
+  METRIC (backbone_propagations, 2, PCNT_PROPS, "%", "propagations") \
+  METRIC (backbone_rounds, 2, PER_BACKBONE, 0, "per backbone") \
+  COUNTER (backbone_ticks, 2, PCNT_TICKS, "%", "ticks") \
+  STATISTIC (backbone_units, 1, PCNT_VARIABLES, "%", "variables") \
+  METRIC (best_saved, 1, CONF_INT, "", "interval") \
+  COUNTER (chronological, 1, PCNT_CONFLICTS, "%", "conflicts") \
+  COUNTER (clauses_added, 2, PCNT_CLS_ADDED, "%", "added") \
+  COUNTER (clauses_binary, 2, PCNT_CLS_ADDED, "%", "added") \
+  STATISTIC (clauses_deleted, 1, PCNT_CLS_ADDED, "%", "added") \
+  STATISTIC (clauses_factored, 1, PCNT_CLS_ADDED, "%", "added") \
+  STATISTIC (clauses_improved, 1, PCNT_CLS_LEARNED, "%", "learned") \
+  COUNTER (clauses_irredundant, 2, PCNT_CLS_ADDED, "%", "added") \
+  STATISTIC (clauses_kept1, 1, PCNT_CLS_IMPROVED, "%", "improved") \
+  STATISTIC (clauses_kept2, 1, PCNT_CLS_IMPROVED, "%", "improved") \
+  STATISTIC (clauses_kept3, 1, PCNT_CLS_IMPROVED, "%", "improved") \
+  COUNTER (clauses_learned, 2, PCNT_CONFLICTS, "%", "conflicts") \
+  COUNTER (clauses_original, 2, PCNT_CLS_ADDED, "%", "added") \
+  STATISTIC (clauses_promoted1, 1, PCNT_CLS_IMPROVED, "%", "improved") \
+  STATISTIC (clauses_promoted2, 1, PCNT_CLS_IMPROVED, "%", "improved") \
+  STATISTIC (clauses_reduced, 1, PCNT_CLS_LEARNED, "%", "learned") \
+  STATISTIC (clauses_reduced_tier1, 1, PCNT_CLS_REDUCED, "%", "reduced") \
+  STATISTIC (clauses_reduced_tier2, 1, PCNT_CLS_REDUCED, "%", "reduced") \
+  STATISTIC (clauses_reduced_tier3, 1, PCNT_CLS_REDUCED, "%", "reduced") \
+  COUNTER (clauses_redundant, 2, NO_SECONDARY, 0, 0) \
+  STATISTIC (clauses_unfactored, 1, PCNT_CLS_FACTORED, "%", "factored") \
+  COUNTER (clauses_used, 2, PCNT_CLS_LEARNED, "%", "learned") \
+  COUNTER (clauses_used_focused, 2, PCNT_CLS_USED, "%", "used") \
+  COUNTER (clauses_used_stable, 2, PCNT_CLS_USED, "%", "used") \
+  COUNTER (closures, 2, CONF_INT, "", "interval") \
+  METRIC (compacted, 1, PCNT_REDUCTIONS, "%", "reductions") \
+  COUNTER (conflicts, 0, PER_SECOND, 0, "per second") \
+  COUNTER (congruent, 1, PCNT_VARIABLES, "%", "variables") \
+  STATISTIC (congruent_ands, 1, PCNT_CONGRUENT, "%", "congruent") \
+  STATISTIC (congruent_arity, 1, PER_CONGRGATES, 0, "per gate") \
+  STATISTIC (congruent_arity_ands, 1, PER_CONGRANDS, 0, "per AND") \
+  STATISTIC (congruent_arity_xors, 1, PER_CONGRXORS, 0, "per XOR") \
+  STATISTIC (congruent_binaries, 1, PCNT_CLS_ADDED, "%", "clauses added") \
+  STATISTIC (congruent_ites, 1, PCNT_CONGRUENT, "%", "congruent") \
+  STATISTIC (congruent_collisions, 1, PER_CONGRLOOKUP, 0, "per lookup") \
+  STATISTIC (congruent_collisions_find, 1, PCNT_CONGRCOLS, "%", "collisions") \
+  STATISTIC (congruent_collisions_index, 1, PCNT_CONGRCOLS, "%", "collisions") \
+  STATISTIC (congruent_collisions_removed, 1, PCNT_CONGRCOLS, "%", "collisions") \
+  STATISTIC (congruent_equivalences, 1, PCNT_CONGRUENT, "%", "congruent") \
+  COUNTER (congruent_gates, 2, PER_CLOSURE, 0, "per closure") \
+  COUNTER (congruent_gates_ands, 2, PCNT_CONGRGATES, "%", "gates") \
+  COUNTER (congruent_gates_ites, 2, PCNT_CONGRGATES, "%", "gates") \
+  COUNTER (congruent_gates_xors, 2, PCNT_CONGRGATES, "%", "gates") \
+  STATISTIC (congruent_indexed, 1, PER_CONGRGATES, 0, "per gate") \
+  STATISTIC (congruent_lookups, 1, PER_CONGRGATES, 0, "per gate") \
+  STATISTIC (congruent_lookups_find, 1, PCNT_CONGRLOOKUP, "%", "lookups") \
+  STATISTIC (congruent_lookups_removed, 1, PCNT_CONGRLOOKUP, "%", "lookups") \
+  COUNTER (congruent_matched, 2, PCNT_CONGRUENT, "%", "congruent") \
+  COUNTER (congruent_matched_ands, 2, PCNT_CONGRMATCHED, "%", "matched") \
+  COUNTER (congruent_matched_ites, 2, PCNT_CONGRMATCHED, "%", "matched") \
+  COUNTER (congruent_matched_xors, 2, PCNT_CONGRMATCHED, "%", "matched") \
+  STATISTIC (congruent_rewritten, 1, PCNT_CONGRGATES, "%", "gates") \
+  STATISTIC (congruent_rewritten_ands, 1, PCNT_CONGREWR, "%", "rewritten") \
+  STATISTIC (congruent_rewritten_ites, 1, PCNT_CONGREWR, "%", "rewritten") \
+  STATISTIC (congruent_rewritten_xors, 1, PCNT_CONGREWR, "%", "rewritten") \
+  STATISTIC (congruent_simplified, 1, PCNT_CONGRGATES, "%", "gates") \
+  STATISTIC (congruent_simplified_ands, 1, PCNT_CONGRSIMPS, "%", "simplified") \
+  STATISTIC (congruent_simplified_ites, 1, PCNT_CONGRSIMPS, "%", "simplified") \
+  STATISTIC (congruent_simplified_xors, 1, PCNT_CONGRSIMPS, "%", "simplified") \
+  STATISTIC (congruent_subsumed, 1, PCNT_CLS_ORIGINAL, "%", "original") \
+  STATISTIC (congruent_trivial_ite, 1, PCNT_CONGRUENT, "%", "congruent") \
+  STATISTIC (congruent_unary, 1, PCNT_CONGRUENT, "%", "congruent") \
+  STATISTIC (congruent_unary_ands, 1, PCNT_CONGRUNARY, "%", "unary") \
+  STATISTIC (congruent_unary_ites, 1, PCNT_CONGRUNARY, "%", "unary") \
+  STATISTIC (congruent_unary_xors, 1, PCNT_CONGRUNARY, "%", "unary") \
+  STATISTIC (congruent_units, 1, PCNT_VARIABLES, "%", "variables") \
+  STATISTIC (congruent_xors, 1, PCNT_CONGRUENT, "%", "congruent") \
+  COUNTER (decisions, 0, PER_CONFLICT, 0, "per conflict") \
+  METRIC (definitions_checked, 1, PCNT_ELIM_ATTEMPTS, "%", "attempts") \
+  STATISTIC (definitions_eliminated, 1, PCNT_ELIMINATED, "%", "eliminated") \
+  METRIC (definitions_extracted, 1, PCNT_EXTRACTED, "%", "extracted") \
+  STATISTIC (definition_units, 1, PCNT_VARIABLES, "%", "variables") \
+  METRIC (defragmentations, 1, CONF_INT, "", "interval") \
+  METRIC (dense_garbage_collections, 2, PCNT_COLLECTIONS, "%", "collections") \
+  METRIC (dense_propagations, 1, PCNT_PROPS, "%", "propagations") \
+  METRIC (dense_ticks, 1, PCNT_TICKS, "%", "ticks") \
+  METRIC (duplicated, 1, PCNT_CLS_ADDED, "%", "added") \
+  STATISTIC (eagerly_subsumed, 1, PCNT_CLS_LEARNED, "%", "learned") \
+  STATISTIC (eliminate_attempted, 1, PER_VARIABLE, 0, "per variable") \
+  COUNTER (eliminated, 1, PCNT_VARIABLES, "%", "variables") \
+  COUNTER (eliminate_resolutions, 2, PER_SECOND, 0, "per second") \
+  STATISTIC (eliminate_units, 1, PCNT_VARIABLES, "%", "variables") \
+  COUNTER (eliminations, 2, CONF_INT, "", "interval") \
+  STATISTIC (equivalences_eliminated, 1, PCNT_ELIMINATED, "%", "eliminated") \
+  METRIC (equivalences_extracted, 1, PCNT_EXTRACTED, "%", "extracted") \
+  METRIC (extensions, 1, PCNT_SEARCHES, "%", "searches") \
+  COUNTER (factored, 1, PCNT_VARIABLES, "%", "variables") \
+  COUNTER (factorizations, 2, CONF_INT, "", "interval") \
+  COUNTER (factor_ticks, 2, PCNT_TICKS, "%", "ticks") \
+  COUNTER (fast_eliminated, 1, PCNT_ELIMINATED, "%", "eliminated") \
+  COUNTER (fast_strengthened, 1, PCNT_STRENGTHENED, "%", "per strengthened") \
+  COUNTER (fast_subsumed, 1, PCNT_SUBSUMED, "%", "per subsumed") \
+  STATISTIC (fresh, 1, PCNT_VARIABLES, "%", "variables") \
+  STATISTIC (flipped, 1, PER_WALKS, 0, "per walk") \
+  METRIC (flushed, 2, PER_FIXED, 0, "per fixed") \
+  METRIC (focused_decisions, 1, PCNT_DECISIONS, "%", "decisions") \
+  METRIC (focused_modes, 1, CONF_INT, "", "interval") \
+  METRIC (focused_propagations, 1, PCNT_PROPS, "%", "propagations") \
+  METRIC (focused_restarts, 1, PCNT_RESTARTS, "%", "restarts") \
+  METRIC (focused_ticks, 1, PCNT_TICKS, "%", "ticks") \
+  COUNTER (forward_checks, 2, NO_SECONDARY, 0, 0) \
+  COUNTER (forward_steps, 2, PER_FORWARD_CHECK, 0, "per check") \
+  STATISTIC (forward_strengthened, 1, PCNT_STRENGTHENED, "%", "per strengthened") \
+  STATISTIC (forward_subsumed, 1, PCNT_SUBSUMED, "%", "per subsumed") \
+  METRIC (forward_subsumptions, 1, CONF_INT, "", "interval") \
+  METRIC (garbage_collections, 2, CONF_INT, "", "interval") \
+  METRIC (gates_checked, 1, PCNT_ELIM_ATTEMPTS, "%", "attempts") \
+  STATISTIC (gates_eliminated, 1, PCNT_ELIMINATED, "%", "eliminated") \
+  METRIC (gates_extracted, 1, PCNT_ELIM_ATTEMPTS, "%", "attempts") \
+  STATISTIC (if_then_else_eliminated, 1, PCNT_ELIMINATED, "%", "eliminated") \
+  METRIC (if_then_else_extracted, 1, PCNT_EXTRACTED, "%", "extracted") \
+  METRIC (initial_decisions, 1, PCNT_DECISIONS, "%", "decisions") \
+  COUNTER (iterations, 1, PCNT_VARIABLES, "%", "variables") \
+  STATISTIC (jumped_reasons, 1, PCNT_PROPS, "%", "propagations") \
+  STATISTIC (kitten_conflicts, 1, PER_KITTEN_SOLVED, 0, "per solved") \
+  STATISTIC (kitten_decisions, 1, PER_KITTEN_SOLVED, 0, "per solved") \
+  STATISTIC (kitten_flip, 1, NO_SECONDARY, 0, 0) \
+  STATISTIC (kitten_flipped, 1, PCNT_KITTEN_FLIP, "%", "flip") \
+  COUNTER (kitten_propagations, 2, PER_KITTEN_SOLVED, 0, "per solved") \
+  STATISTIC (kitten_sat, 1, PCNT_KITTEN_SOLVED, "%", "solved") \
+  COUNTER (kitten_solved, 2, NO_SECONDARY, 0, 0) \
+  COUNTER (kitten_ticks, 2, PER_KITTEN_PROP, 0, "per prop") \
+  STATISTIC (kitten_unknown, 1, PCNT_KITTEN_SOLVED, "%", "solved") \
+  STATISTIC (kitten_unsat, 1, PCNT_KITTEN_SOLVED, "%", "solved") \
+  METRIC (literals_bumped, 1, PER_CLS_LEARNED, 0, "per clause") \
+  METRIC (literals_deduced, 1, PER_CLS_LEARNED, 0, "per clause") \
+  COUNTER (literals_factor, 2, PER_VARIABLE, 0, "per variable") \
+  STATISTIC (literals_factored, 1, PER_CLS_FACTORED, 0, "per factored") \
+  METRIC (literals_learned, 1, PER_CLS_LEARNED, 0, "per clause") \
+  METRIC (literals_minimized, 1, PCNT_LITS_DEDUCED, "%", "deduced") \
+  METRIC (literals_minshrunken, 1, PCNT_LITS_SHRUNKEN, "%", "shrunken") \
+  METRIC (literals_shrunken, 1, PCNT_LITS_DEDUCED, "%", "deduced") \
+  STATISTIC (literals_unfactored, 2, PER_CLS_UNFACTORED, 0, "per unfactored") \
+  METRIC (moved, 1, PCNT_REDUCTIONS, "%", "reductions") \
+  STATISTIC (on_the_fly_strengthened, 1, PCNT_CONFLICTS, "%", "of conflicts") \
+  STATISTIC (on_the_fly_subsumed, 1, PCNT_CONFLICTS, "%", "of conflicts") \
+  METRIC (probing_propagations, 1, PCNT_PROPS, "%", "propagations") \
+  COUNTER (probings, 2, CONF_INT, "", "interval") \
+  COUNTER (probing_ticks, 2, PCNT_TICKS, "%", "ticks") \
+  COUNTER (propagations, 0, PER_SECOND, "", "per second") \
+  STATISTIC (queue_decisions, 1, PCNT_DECISIONS, "%", "decision") \
+  STATISTIC (random_decisions, 1, PCNT_DECISIONS, "%", "decision") \
+  COUNTER (random_sequences, 2, CONF_INT, "", "interval") \
+  COUNTER (reductions, 1, CONF_INT, "", "interval") \
+  COUNTER (reordered, 1, CONF_INT, "", "interval") \
+  STATISTIC (reordered_focused, 1, PCNT_REORDERED, "%", "reordered") \
+  STATISTIC (reordered_stable, 1, PCNT_REORDERED, "%", "reordered") \
+  COUNTER (rephased, 1, CONF_INT, "", "interval") \
+  METRIC (rephased_best, 1, PCNT_REPHASED, "%", "rephased") \
+  METRIC (rephased_inverted, 1, PCNT_REPHASED, "%", "rephased") \
+  METRIC (rephased_original, 1, PCNT_REPHASED, "%", "rephased") \
+  METRIC (rephased_walking, 1, PCNT_REPHASED, "%", "rephased") \
+  METRIC (rescaled, 2, CONF_INT, "", "interval") \
+  COUNTER (restarts, 1, CONF_INT, "", "interval") \
+  STATISTIC (restarts_levels, 1, PER_RESTART, 0, "per restart") \
+  STATISTIC (restarts_reused_levels, 1, PCNT_RESTARTS_LEVELS, "%", "levels") \
+  STATISTIC (restarts_reused_trails, 1, PCNT_RESTARTS, "%", "restarts") \
+  COUNTER (retiered, 2, CONF_INT, "", "interval") \
+  METRIC (saved_decisions, 1, PCNT_DECISIONS, "%", "decisions") \
+  METRIC (score_decisions, 0, PCNT_DECISIONS, "%", "decision") \
+  COUNTER (searches, 2, CONF_INT, "", "interval") \
+  METRIC (search_propagations, 2, PCNT_PROPS, "%", "propagations") \
+  COUNTER (search_ticks, 2, PCNT_TICKS, "%", "ticks") \
+  METRIC (sparse_gcs, 2, PCNT_COLLECTIONS, "%", "collections") \
+  METRIC (stable_decisions, 1, PCNT_DECISIONS, "%", "decisions") \
+  METRIC (stable_modes, 2, CONF_INT, "", "interval") \
+  METRIC (stable_propagations, 1, PCNT_PROPS, "%", "propagations") \
+  METRIC (stable_restarts, 1, PCNT_RESTARTS, "%", "restarts") \
+  METRIC (stable_ticks, 2, PCNT_TICKS, "%", "ticks") \
+  COUNTER (strengthened, 1, PCNT_SUBSUMPTION_CHECK, "%", "checks") \
+  COUNTER (substituted, 1, PCNT_VARIABLES, "%", "variables") \
+  COUNTER (substitute_ticks, 2, PCNT_TICKS, "%", "ticks") \
+  STATISTIC (substitute_units, 1, PCNT_VARIABLES, "%", "variables") \
+  STATISTIC (substitutions, 2, CONF_INT, "", "interval") \
+  COUNTER (subsumed, 1, PCNT_SUBSUMPTION_CHECK, "%", "checks") \
+  COUNTER (subsumption_checks, 2, NO_SECONDARY, 0, 0) \
+  COUNTER (sweep, 2, CONF_INT, "", "interval") \
+  STATISTIC (sweep_clauses, 1, PER_SWEEP_VARIABLES, 0, "per sweep_variables") \
+  COUNTER (sweep_completed, 2, SWEEPS_PER_COMPLETED, 0, "sweeps") \
+  STATISTIC (sweep_depth, 1, PER_SWEEP_VARIABLES, 0, "per sweep_variables") \
+  STATISTIC (sweep_environment, 1, PER_SWEEP_VARIABLES, 0, "per sweep_variables") \
+  COUNTER (sweep_equivalences, 2, PCNT_VARIABLES, "%", "variables") \
+  STATISTIC (sweep_fixed_backbone, 1, PER_SWEEP_VARIABLES, 0, "per sweep_variables") \
+  STATISTIC (sweep_flip_backbone, 1, PER_SWEEP_VARIABLES, 0, "per sweep_variables") \
+  STATISTIC (sweep_flipped_backbone, 1, PCNT_SWEEP_FLIP_BACKBONE, "%", "sweep_flip_backbone") \
+  STATISTIC (sweep_flip_equivalences, 1, PER_SWEEP_VARIABLES, 0, "per sweep_variables") \
+  STATISTIC (sweep_flipped_equivalences, 1, PCNT_SWEEP_FLIP_EQUIVALENCES, "%", "sweep_flip_equivalences") \
+  STATISTIC (sweep_sat, 1, PCNT_SWEEP_SOLVED, "%", "sweep_solved") \
+  STATISTIC (sweep_sat_backbone, 1, PCNT_SWEEP_SOLVED_BACKBONE, "%", "sweep_solved_backbone") \
+  STATISTIC (sweep_sat_equivalences, 1, PCNT_SWEEP_SOLVED_EQUIVALENCES, "%", "sweep_solved_equivalences") \
+  COUNTER (sweep_solved, 2, PCNT_KITTEN_SOLVED, "%", "kitten_solved") \
+  STATISTIC (sweep_solved_backbone, 1, PCNT_SWEEP_SOLVED, "%", "sweep_solved") \
+  STATISTIC (sweep_solved_equivalences, 1, PCNT_SWEEP_SOLVED, "%", "sweep_solved") \
+  STATISTIC (sweep_unknown_backbone, 1, PCNT_SWEEP_SOLVED_BACKBONE, "%", "sweep_solved_backbone") \
+  STATISTIC (sweep_unknown_equivalences, 1, PCNT_SWEEP_SOLVED_EQUIVALENCES, "%", "sweep_solved_equivalences") \
+  COUNTER (sweep_units, 2, PCNT_VARIABLES, "%", "variables") \
+  STATISTIC (sweep_unsat, 1, PCNT_SWEEP_SOLVED, "%", "sweep_solved") \
+  STATISTIC (sweep_unsat_backbone, 1, PCNT_SWEEP_SOLVED_BACKBONE, "%", "sweep_solve_backbone") \
+  STATISTIC (sweep_unsat_equivalences, 1, PCNT_SWEEP_SOLVED_EQUIVALENCES, "%", "sweep_solve_equivalences") \
+  STATISTIC (sweep_variables, 1, PCNT_VARIABLES, "%", "variables") \
+  COUNTER (switched, 0, CONF_INT, "", "interval") \
+  METRIC (target_decisions, 1, PCNT_DECISIONS, "%", "decisions") \
+  METRIC (target_saved, 1, CONF_INT, "", "interval") \
+  STATISTIC (ticks, 2, PER_PROPAGATION, 0, "per prop") \
+  METRIC (transitive_probes, 2, PER_VARIABLE, "", "per variable") \
+  METRIC (transitive_propagations, 2, PCNT_PROPS, "%", "propagations") \
+  METRIC (transitive_reduced, 1, PCNT_CLS_ADDED, "%", "added") \
+  METRIC (transitive_reductions, 1, CONF_INT, "", "interval") \
+  COUNTER (transitive_ticks, 2, PCNT_TICKS, "%", "ticks") \
+  METRIC (transitive_units, 1, PCNT_VARIABLES, "%", "variables") \
+  COUNTER (units, 2, PCNT_VARIABLES, "%", "variables") \
+  COUNTER (variables_activated, 2, PER_VARIABLE, 0, "per variable") \
+  COUNTER (variables_eliminate, 2, PER_VARIABLE, 0, "variables") \
+  COUNTER (variables_extension, 2, PER_VARIABLE, 0, "per variable") \
+  COUNTER (variables_factor, 2, PER_VARIABLE, 0, "per variable") \
+  COUNTER (variables_original, 2, PER_VARIABLE, 0, "per variable") \
+  COUNTER (variables_subsume, 2, PER_VARIABLE, 0, "per variable") \
+  METRIC (vectors_defrags_needed, 1, PCNT_DEFRAGS, "%", "defrags") \
+  METRIC (vectors_enlarged, 2, CONF_INT, "", "interval") \
+  COUNTER (vivifications, 2, CONF_INT, "", "interval") \
+  COUNTER (vivified, 1, PCNT_VIVIFY_CHECK, "%", "checks") \
+  STATISTIC (vivified_asym, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_implied, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_instantiated, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_instirr, 1, PCNT_VIVIFY_INST, "%", "instantiated") \
+  STATISTIC (vivified_instred, 1, PCNT_VIVIFY_INST, "%", "instantiated") \
+  STATISTIC (vivified_irredundant, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_promoted, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_shrunken, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_shrunkirr, 1, PCNT_VIVIFY_SHRUNKEN, "%", "shrunken") \
+  STATISTIC (vivified_shrunkred, 1, PCNT_VIVIFY_SHRUNKEN, "%", "shrunken") \
+  STATISTIC (vivified_subirr, 1, PCNT_VIVIFY_SUB, "%", "subsumed") \
+  STATISTIC (vivified_subred, 1, PCNT_VIVIFY_SUB, "%", "subsumed") \
+  STATISTIC (vivified_subsumed, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_tier1, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_tier2, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_tier3, 1, PCNT_VIVIFIED, "%", "vivified") \
+  STATISTIC (vivified_unlearn, 1, PCNT_VIVIFIED, "%", "vivified") \
+  COUNTER (vivify_checks, 2, PER_VIVIFICATION, "", "per vivify") \
+  COUNTER (vivify_probes, 2, PER_VIVIFY_CHECK, 0, "per check") \
+  STATISTIC (vivify_propagations, 2, PCNT_PROPS, "%", "propagations") \
+  COUNTER (vivify_reused, 2, PCNT_VIVIFY_PROBES, "%", "probes") \
+  STATISTIC (vivify_ticks, 2, PCNT_TICKS, "%", "ticks") \
+  STATISTIC (vivify_units, 1, PCNT_VARIABLES, "%", "variables") \
+  METRIC (walk_decisions, 1, PCNT_WALKS, "%", "walks") \
+  STATISTIC (walk_improved, 1, PCNT_WALKS, "%", "walks") \
+  METRIC (walk_previous, 1, PCNT_WALKS, "%", "walks") \
+  COUNTER (walks, 1, CONF_INT, "", "interval") \
+  COUNTER (walk_steps, 2, PER_FLIPPED, 0, "per flipped") \
+  STATISTIC (warming_conflicts, 1, PER_WALKS, 0, "per walk") \
+  COUNTER (warming_decisions, 2, PER_WALKS, 0, "per walk") \
+  COUNTER (warming_propagations, 2, PCNT_PROPS, "%", "propagations") \
+  COUNTER (warmups, 2, PCNT_WALKS, "%", "walks") \
+  METRIC (weakened, 1, PCNT_CLS_ADDED, "%", "added")
+
+// clang-format on
+
+/*------------------------------------------------------------------------*/
+#ifdef METRICS
+
+#define METRIC COUNTER
+#define STATISTIC COUNTER
+
+#ifndef STATISTICS
+#define STATISTICS
+#endif
+
+#elif STATISTICS
+
+#define METRIC IGNORE
+#define STATISTIC COUNTER
+
+#else
+
+#define METRIC IGNORE
+#define STATISTIC IGNORE
+
+#endif
+/*------------------------------------------------------------------------*/
+// clang-format off
+
+typedef struct statistics statistics;
+
+#define MAX_GLUE_USED 127
+
+struct statistics
+{
+#define COUNTER(NAME,VERBOSE,OTHER,UNITS,TYPE) \
+  uint64_t NAME;
+#define IGNORE(...)
+
+  METRICS_COUNTERS_AND_STATISTICS
+
+#undef COUNTER
+#undef IGNORE
+
+  struct {
+    uint64_t glue[MAX_GLUE_USED + 1];
+  } used[2];
+};
+
+// clang-format on
+/*------------------------------------------------------------------------*/
+
+#define CLAUSES (IRREDUNDANT_CLAUSES + BINARY_CLAUSES + REDUNDANT_CLAUSES)
+#define CONFLICTS (solver->statistics_.conflicts)
+#define DECISIONS (solver->statistics_.decisions)
+#define IRREDUNDANT_CLAUSES (solver->statistics_.clauses_irredundant)
+#define LEARNED_CLAUSES (solver->statistics_.learned)
+#define REDUNDANT_CLAUSES (solver->statistics_.clauses_redundant)
+#define BINARY_CLAUSES (solver->statistics_.clauses_binary)
+#define BINIRR_CLAUSES (BINARY_CLAUSES + IRREDUNDANT_CLAUSES)
+
+/*------------------------------------------------------------------------*/
+
+#define COUNTER(NAME, VERBOSE, OTHER, UNITS, TYPE) \
+\
+  static inline void kissat_inc_##NAME (statistics *statistics) { \
+    KISSAT_assert (statistics->NAME < UINT64_MAX); \
+    statistics->NAME++; \
+  } \
+\
+  static inline void kissat_dec_##NAME (statistics *statistics) { \
+    KISSAT_assert (statistics->NAME); \
+    statistics->NAME--; \
+  } \
+\
+  static inline void kissat_add_##NAME (statistics *statistics, \
+                                        uint64_t n) { \
+    KISSAT_assert (UINT64_MAX - n >= statistics->NAME); \
+    statistics->NAME += n; \
+  } \
+\
+  static inline void kissat_sub_##NAME (statistics *statistics, \
+                                        uint64_t n) { \
+    KISSAT_assert (n <= statistics->NAME); \
+    statistics->NAME -= n; \
+  } \
+\
+  static inline uint64_t kissat_get_##NAME (statistics *statistics) { \
+    return statistics->NAME; \
+  }
+
+/*------------------------------------------------------------------------*/
+
+#define IGNORE(NAME, VERBOSE, OTHER, UNITS, TYPE) \
+\
+  static inline void kissat_inc_##NAME (statistics *statistics) { \
+    (void) statistics; \
+  } \
+\
+  static inline void kissat_dec_##NAME (statistics *statistics) { \
+    (void) statistics; \
+  } \
+\
+  static inline void kissat_add_##NAME (statistics *statistics, \
+                                        uint64_t n) { \
+    (void) statistics; \
+    (void) n; \
+  } \
+\
+  static inline void kissat_sub_##NAME (statistics *statistics, \
+                                        uint64_t n) { \
+    (void) statistics; \
+    (void) n; \
+  } \
+  static inline uint64_t kissat_get_##NAME (statistics *statistics) { \
+    (void) statistics; \
+    return UINT64_MAX; \
+  }
+
+/*------------------------------------------------------------------------*/
+// clang-format off
+
+METRICS_COUNTERS_AND_STATISTICS
+
+#undef COUNTER
+#undef IGNORE
+
+// clang-format on
+/*------------------------------------------------------------------------*/
+
+#define INC(NAME) kissat_inc_##NAME (&solver->statistics_)
+#define DEC(NAME) kissat_dec_##NAME (&solver->statistics_)
+#define ADD(NAME, N) kissat_add_##NAME (&solver->statistics_, (N))
+#define SUB(NAME, N) kissat_sub_##NAME (&solver->statistics_, (N))
+#define GET(NAME) kissat_get_##NAME (&solver->statistics_)
+
+/*------------------------------------------------------------------------*/
+#ifndef KISSAT_QUIET
+
+struct kissat;
+
+void kissat_statistics_print (struct kissat *, bool verbose);
+void kissat_print_glue_usage (struct kissat *);
+
+// Format widths of individual parts during printing statistics lines.
+// Shared between 'statistics.c' and 'resources.c' to align the printing.
+
+#define SFW1 "30"
+#define SFW2 "12"
+#define SFW3 "5"
+#define SFW4 "10"
+
+#define SFW34 "16"         // SFE3 + space + SFE 4
+#define SFW34EXTENDED "19" // SFE3 + space + SFE 4 + ".2"
+
+#define PRINT_STAT(NAME, PRIMARY, SECONDARY, UNITS, TYPE) \
+  do { \
+    printf ("%s%-" SFW1 "s %" SFW2 PRIu64 " ", solver->prefix, NAME ":", \
+            (uint64_t) PRIMARY); \
+    const double SAVED_SECONDARY = (double) (SECONDARY); \
+    const char *SAVED_UNITS = (const char *) (UNITS); \
+    const char *SAVED_TYPE = (const char *) (TYPE); \
+    if (SAVED_TYPE && SAVED_SECONDARY >= 0) { \
+      if (SAVED_UNITS) \
+        printf ("%" SFW34 ".0f %-2s", SAVED_SECONDARY, SAVED_UNITS); \
+      else \
+        printf ("%" SFW34EXTENDED ".2f", SAVED_SECONDARY); \
+      fputc (' ', stdout); \
+      fputs (SAVED_TYPE, stdout); \
+    } \
+    fputc ('\n', stdout); \
+  } while (0)
+
+#endif
+
+#ifndef KISSAT_NDEBUG
+
+struct kissat;
+void kissat_check_statistics (struct kissat *);
+
+#else
+
+#define kissat_check_statistics(...) \
+  do { \
+  } while (0)
+
+#endif
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/strengthen.c b/src/sat/kissat/strengthen.c
new file mode 100644
index 000000000..4d85b0d2a
--- /dev/null
+++ b/src/sat/kissat/strengthen.c
@@ -0,0 +1,191 @@
+#include "strengthen.h"
+#include "collect.h"
+#include "inline.h"
+#include "promote.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static clause *large_on_the_fly_strengthen (kissat *solver, clause *c,
+                                            unsigned lit) {
+  KISSAT_assert (solver->antecedent_size > 3);
+  LOGCLS (c,
+          "large on-the-fly strengthening "
+          "by removing %s from",
+          LOGLIT (lit));
+  unsigned *lits = c->lits;
+  KISSAT_assert (lits[0] == lit || lits[1] == lit);
+  INC (on_the_fly_strengthened);
+#ifndef KISSAT_NDEBUG
+  clause *old_next = kissat_next_clause (c);
+#endif
+  if (lits[0] == lit)
+    SWAP (unsigned, lits[0], lits[1]);
+  KISSAT_assert (lits[1] == lit);
+  const reference ref = kissat_reference_clause (solver, c);
+  kissat_unwatch_blocking (solver, lit, ref);
+  SHRINK_CLAUSE_IN_PROOF (c, lit, lits[0]);
+  CHECK_SHRINK_CLAUSE (c, lit, lits[0]);
+  {
+    const unsigned old_size = c->size;
+    unsigned new_size = 1;
+    const bool irredundant = !c->redundant;
+    for (unsigned i = 2; i < old_size; i++) {
+      const unsigned other = lits[i];
+      KISSAT_assert (VALUE (other) < 0);
+      if (!LEVEL (other))
+        continue;
+      lits[new_size++] = other;
+      if (irredundant)
+        kissat_mark_added_literal (solver, other);
+    }
+    KISSAT_assert (new_size > 2);
+    c->size = new_size;
+    c->searched = 2;
+    if (c->redundant && c->glue >= new_size)
+      kissat_promote_clause (solver, c, new_size - 1);
+    if (!c->shrunken) {
+      c->shrunken = true;
+      lits[old_size - 1] = INVALID_LIT;
+    }
+  }
+  LOGCLS (c, "unsorted on-the-fly strengthened");
+  {
+    KISSAT_assert (VALUE (lits[1]) < 0);
+    unsigned highest_pos = 1;
+    unsigned highest_level = LEVEL (lits[1]);
+    const unsigned size = c->size;
+    for (unsigned i = 2; i < size; i++) {
+      const unsigned other = lits[i];
+      KISSAT_assert (VALUE (other) < 0);
+      const unsigned level = LEVEL (other);
+      if (level <= highest_level)
+        continue;
+      highest_pos = i;
+      highest_level = level;
+    }
+    if (highest_pos != 1)
+      SWAP (unsigned, lits[1], lits[highest_pos]);
+    LOGCLS (c, "sorted on-the-fly strengthened");
+    kissat_watch_blocking (solver, lits[1], lits[0], ref);
+  }
+  {
+    watches *watches = &WATCHES (lits[0]);
+#ifndef KISSAT_NDEBUG
+    const watch *const end_of_watches = END_WATCHES (*watches);
+#endif
+    watch *p = BEGIN_WATCHES (*watches);
+    KISSAT_assert (solver->watching);
+    for (;;) {
+      KISSAT_assert (p != end_of_watches);
+      const watch head = *p++;
+      if (head.type.binary)
+        continue;
+      KISSAT_assert (p != end_of_watches);
+      const watch tail = *p++;
+      if (tail.large.ref == ref)
+        break;
+    }
+    p[-2].blocking.lit = lits[1];
+    LOGREF (ref, "updating watching %s now blocking %s in",
+            LOGLIT (lits[0]), LOGLIT (lits[1]));
+  }
+#ifndef KISSAT_NDEBUG
+  clause *new_next = kissat_next_clause (c);
+  KISSAT_assert (old_next == new_next);
+#endif
+  LOGCLS (c, "conflicting");
+  return c;
+}
+
+static clause *binary_on_the_fly_strengthen (kissat *solver, clause *c,
+                                             unsigned lit) {
+  KISSAT_assert (solver->antecedent_size == 3);
+  LOGCLS (c,
+          "binary on-the-fly strengthening "
+          "by removing %s from",
+          LOGLIT (lit));
+  unsigned first = INVALID_LIT, second = INVALID_LIT;
+#ifndef KISSAT_NDEBUG
+  bool found = false;
+#endif
+  for (all_literals_in_clause (other, c)) {
+    if (other == lit) {
+#ifndef KISSAT_NDEBUG
+      KISSAT_assert (!found);
+      found = true;
+#endif
+      continue;
+    }
+    KISSAT_assert (VALUE (other) < 0);
+    if (!LEVEL (other))
+      continue;
+    if (first == INVALID_LIT)
+      first = other;
+    else {
+      KISSAT_assert (second == INVALID_LIT);
+      second = other;
+#ifndef KISSAT_NDEBUG
+      break;
+#endif
+    }
+  }
+  KISSAT_assert (found);
+  KISSAT_assert (second != INVALID_LIT);
+  LOGBINARY (first, second, "on-the-fly strengthened");
+  kissat_new_binary_clause (solver, first, second);
+  const reference ref = kissat_reference_clause (solver, c);
+  kissat_unwatch_blocking (solver, c->lits[0], ref);
+  kissat_unwatch_blocking (solver, c->lits[1], ref);
+  kissat_mark_clause_as_garbage (solver, c);
+  clause *conflict = kissat_binary_conflict (solver, first, second);
+  return conflict;
+}
+
+clause *kissat_on_the_fly_strengthen (kissat *solver, clause *c,
+                                      unsigned lit) {
+  KISSAT_assert (!c->garbage);
+  KISSAT_assert (solver->antecedent_size > 2);
+  if (!c->redundant)
+    kissat_mark_removed_literal (solver, lit);
+  clause *res;
+  if (solver->antecedent_size == 3)
+    res = binary_on_the_fly_strengthen (solver, c, lit);
+  else
+    res = large_on_the_fly_strengthen (solver, c, lit);
+  return res;
+}
+
+void kissat_on_the_fly_subsume (kissat *solver, clause *c, clause *d) {
+  LOGCLS (c, "on-the-fly subsuming");
+  LOGCLS (d, "on-the-fly subsumed");
+  KISSAT_assert (c != d);
+  KISSAT_assert (!d->garbage);
+  KISSAT_assert (c->size > 1);
+  KISSAT_assert (c->size <= d->size);
+  kissat_mark_clause_as_garbage (solver, d);
+  INC (on_the_fly_subsumed);
+  if (d->redundant) {
+    if (c->redundant && c->glue > d->glue)
+      kissat_promote_clause (solver, c, d->glue);
+    return;
+  }
+  if (!c->redundant)
+    return;
+  if (c->size > 2) {
+    c->redundant = false;
+    LOGCLS (c, "turned");
+    kissat_update_last_irredundant (solver, c);
+  }
+  statistics *statistics = &solver->statistics_;
+  if (c->size > 2) {
+    KISSAT_assert (statistics->clauses_irredundant < UINT64_MAX);
+    statistics->clauses_irredundant++;
+  } else {
+    KISSAT_assert (statistics->clauses_binary < UINT64_MAX);
+    statistics->clauses_binary++;
+  }
+  KISSAT_assert (statistics->clauses_redundant > 0);
+  statistics->clauses_redundant--;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/strengthen.h b/src/sat/kissat/strengthen.h
new file mode 100644
index 000000000..6624b684a
--- /dev/null
+++ b/src/sat/kissat/strengthen.h
@@ -0,0 +1,22 @@
+#ifndef _strengthen_h_INCLUDED
+#define _strengthen_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct clause;
+struct kissat;
+
+struct clause *kissat_on_the_fly_strengthen (struct kissat *,
+                                             struct clause *, unsigned lit);
+
+void kissat_on_the_fly_subsume (struct kissat *, struct clause *,
+                                struct clause *);
+
+bool issat_strengthen_clause (struct kissat *, struct clause *, unsigned);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/substitute.c b/src/sat/kissat/substitute.c
new file mode 100644
index 000000000..76982305c
--- /dev/null
+++ b/src/sat/kissat/substitute.c
@@ -0,0 +1,621 @@
+#include "substitute.h"
+#include "allocate.h"
+#include "backtrack.h"
+#include "inline.h"
+#include "print.h"
+#include "proprobe.h"
+#include "report.h"
+#include "terminate.h"
+#include "trail.h"
+#include "weaken.h"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void assign_and_propagate_units (kissat *solver, unsigneds *units) {
+  if (EMPTY_STACK (*units))
+    return;
+  LOG ("assigning and propagating %zu units", SIZE_STACK (*units));
+  while (!solver->inconsistent && !EMPTY_STACK (*units)) {
+    const unsigned unit = POP_STACK (*units);
+    LOG ("trying to assign and propagate unit %s now", LOGLIT (unit));
+    const value value = VALUE (unit);
+    if (value > 0) {
+      LOG ("skipping satisfied unit %s", LOGLIT (unit));
+    } else if (value < 0) {
+      LOG ("inconsistent unit %s", LOGLIT (unit));
+      CHECK_AND_ADD_EMPTY ();
+      ADD_EMPTY_TO_PROOF ();
+      solver->inconsistent = true;
+    } else {
+      kissat_learned_unit (solver, unit);
+      INC (substitute_units);
+      KISSAT_assert (!solver->level);
+      (void) kissat_probing_propagate (solver, 0, false);
+    }
+  }
+}
+
+static void determine_representatives (kissat *solver, unsigned *repr) {
+  size_t bytes = LITS * sizeof (unsigned);
+  unsigned *mark = (unsigned*)kissat_calloc (solver, LITS, sizeof *mark);
+  unsigned *reach = (unsigned*)kissat_malloc (solver, LITS * sizeof *reach);
+  watches *all_watches = solver->watches;
+  const flags *const flags = solver->flags;
+  unsigned reached = 0;
+  unsigneds scc;
+  unsigneds work;
+  unsigneds units;
+  INIT_STACK (scc);
+  INIT_STACK (work);
+  INIT_STACK (units);
+#ifdef LOGGING
+  unsigned trivial_sccs = 0;
+  unsigned non_trivial_sccs = 0;
+#endif
+  bool inconsistent = false;
+  uint64_t ticks = 0;
+  for (all_literals (root)) {
+    if (inconsistent)
+      break;
+    if (mark[root])
+      continue;
+    if (!ACTIVE (IDX (root)))
+      continue;
+    KISSAT_assert (EMPTY_STACK (scc));
+    KISSAT_assert (EMPTY_STACK (work));
+    LOG ("substitute root %s", LOGLIT (root));
+    PUSH_STACK (work, root);
+    bool failed = false;
+    const unsigned mark_root = reached + 1;
+    while (!inconsistent && !EMPTY_STACK (work)) {
+      unsigned lit = TOP_STACK (work);
+      if (lit == INVALID_LIT) {
+        (void) POP_STACK (work);
+        lit = POP_STACK (work);
+        const unsigned not_lit = NOT (lit);
+        unsigned reach_lit = reach[lit];
+        unsigned mark_lit = mark[lit];
+        KISSAT_assert (reach_lit == mark_lit);
+        KISSAT_assert (repr[lit] == INVALID_LIT);
+        watches *watches = all_watches + not_lit;
+        const size_t size_watches = SIZE_WATCHES (*watches);
+        ticks += 1 + kissat_cache_lines (size_watches, sizeof (watch));
+        for (all_binary_blocking_watches (watch, *watches)) {
+          if (!watch.type.binary)
+            continue;
+          const unsigned other = watch.binary.lit;
+          const unsigned idx_other = IDX (other);
+          if (!flags[idx_other].active)
+            continue;
+          KISSAT_assert (mark[other]);
+          unsigned reach_other = reach[other];
+          if (reach_other < reach_lit)
+            reach_lit = reach_other;
+        }
+        if (reach_lit != mark_lit) {
+          LOG ("reach[%s] = %u", LOGLIT (lit), reach_lit);
+          reach[lit] = reach_lit;
+          continue;
+        }
+        unsigned *end_scc = END_STACK (scc);
+        unsigned *begin_scc = end_scc;
+        do
+          KISSAT_assert (begin_scc != BEGIN_STACK (scc));
+        while (*--begin_scc != lit);
+        SET_END_OF_STACK (scc, begin_scc);
+        const size_t size_scc = end_scc - begin_scc;
+        unsigned min_lit = lit;
+        if (size_scc > 1) {
+          for (const unsigned *p = begin_scc; p != end_scc; p++) {
+            const unsigned other = *p;
+            if (other < min_lit)
+              min_lit = other;
+          }
+#ifdef LOGGING
+          non_trivial_sccs++;
+#endif
+          LOG ("size %zu SCC entered trough %s representative %s", size_scc,
+               LOGLIT (lit), LOGLIT (min_lit));
+        } else {
+#ifdef LOGGING
+          trivial_sccs++;
+#endif
+          LOG ("trivial size one SCC with %s", LOGLIT (lit));
+          KISSAT_assert (min_lit == lit);
+        }
+        for (const unsigned *p = begin_scc; p != end_scc; p++) {
+          const unsigned other = *p;
+          LOG ("substitute repr[%s] = %s", LOGLIT (other),
+               LOGLIT (min_lit));
+          repr[other] = min_lit;
+          reach[other] = UINT_MAX;
+
+          const unsigned not_other = NOT (other);
+          const unsigned repr_not_other = repr[not_other];
+          if (repr_not_other == INVALID_LIT)
+            continue;
+          if (min_lit == repr_not_other) {
+            LOG ("clashing literals %s and %s in same SCC", LOGLIT (other),
+                 LOGLIT (not_other));
+            PUSH_STACK (units, min_lit);
+            inconsistent = true;
+            break;
+          }
+          KISSAT_assert (NOT (min_lit) == repr_not_other);
+          if (failed)
+            continue;
+          const unsigned mark_not_other = mark[not_other];
+          KISSAT_assert (mark_not_other != INVALID_LIT);
+          KISSAT_assert (mark[root] == mark_root);
+          if (mark_root > mark_not_other)
+            continue;
+          LOG ("root %s implies both %s and %s", LOGLIT (root),
+               LOGLIT (other), LOGLIT (not_other));
+          const unsigned unit = NOT (root);
+          PUSH_STACK (units, unit);
+          failed = true;
+        }
+        if (inconsistent)
+          break;
+      } else if (!mark[lit]) {
+        PUSH_STACK (work, INVALID_LIT);
+        PUSH_STACK (scc, lit);
+        mark[lit] = reach[lit] = ++reached;
+        LOG ("substitute mark[%s] = %u", LOGLIT (lit), reached);
+        const unsigned not_lit = NOT (lit);
+        watches *watches = all_watches + not_lit;
+        const size_t size_watches = SIZE_WATCHES (*watches);
+        ticks += 1 + kissat_cache_lines (size_watches, sizeof (watch));
+        for (all_binary_blocking_watches (watch, *watches)) {
+          if (!watch.type.binary)
+            continue;
+          const unsigned other = watch.binary.lit;
+          const unsigned idx_other = IDX (other);
+          if (!flags[idx_other].active)
+            continue;
+          if (!mark[other])
+            PUSH_STACK (work, other);
+        }
+      } else
+        (void) POP_STACK (work);
+    }
+  }
+  RELEASE_STACK (work);
+  RELEASE_STACK (scc);
+  kissat_extremely_verbose (solver,
+                            "determining substitution "
+                            "representatives took %" PRIu64
+                            " 'substitute_ticks'",
+                            ticks);
+  ADD (substitute_ticks, ticks);
+  LOG ("reached %u literals", reached);
+  LOG ("found %u non-trivial SCCs", non_trivial_sccs);
+  LOG ("found %u trivial SCCs", trivial_sccs);
+  LOG ("found %zu units", SIZE_STACK (units));
+  assign_and_propagate_units (solver, &units);
+  KISSAT_assert (!inconsistent || solver->inconsistent);
+  RELEASE_STACK (units);
+  kissat_free (solver, reach, bytes);
+  kissat_free (solver, mark, bytes);
+  for (all_literals (lit))
+    if (repr[lit] == INVALID_LIT)
+      repr[lit] = lit;
+}
+
+static bool *add_representative_equivalences (kissat *solver,
+                                              unsigned *repr) {
+  if (solver->inconsistent)
+    return 0;
+  bool *eliminate = (bool*)kissat_calloc (solver, VARS, sizeof *eliminate);
+  for (all_variables (idx)) {
+    if (!ACTIVE (idx))
+      continue;
+    const unsigned lit = LIT (idx);
+    const unsigned other = repr[lit];
+    if (lit == other)
+      continue;
+    KISSAT_assert (other < lit);
+#ifdef CHECKING_OR_PROVING
+    const unsigned not_lit = NOT (lit);
+    const unsigned not_other = NOT (other);
+
+    CHECK_AND_ADD_BINARY (not_lit, other);
+    ADD_BINARY_TO_PROOF (not_lit, other);
+
+    CHECK_AND_ADD_BINARY (lit, not_other);
+    ADD_BINARY_TO_PROOF (lit, not_other);
+#endif
+    eliminate[idx] = true;
+  }
+  return eliminate;
+}
+
+static void remove_representative_equivalences (kissat *solver,
+                                                unsigned *repr,
+                                                bool *eliminate) {
+  if (!solver->inconsistent) {
+    value *values = solver->values;
+    const bool incremental = GET_OPTION (incremental);
+    for (all_variables (idx)) {
+      if (!eliminate[idx])
+        continue;
+
+      KISSAT_assert (ACTIVE (idx));
+
+      const unsigned lit = LIT (idx);
+      const unsigned other = repr[lit];
+      const unsigned not_lit = NOT (lit);
+      const unsigned not_other = NOT (other);
+      KISSAT_assert (other < lit);
+      KISSAT_assert (not_other < not_lit);
+
+      REMOVE_CHECKER_BINARY (not_lit, other);
+      DELETE_BINARY_FROM_PROOF (not_lit, other);
+
+      REMOVE_CHECKER_BINARY (lit, not_other);
+      DELETE_BINARY_FROM_PROOF (lit, not_other);
+
+      INC (substituted);
+      kissat_mark_eliminated_variable (solver, idx);
+      const value other_value = values[other];
+      if (incremental || other_value) {
+        if (other_value <= 0)
+          kissat_weaken_binary (solver, not_lit, other);
+        if (other_value >= 0)
+          kissat_weaken_binary (solver, lit, not_other);
+      } else {
+        kissat_weaken_binary (solver, not_lit, other);
+        kissat_weaken_unit (solver, lit);
+      }
+    }
+  }
+  if (eliminate)
+    kissat_dealloc (solver, eliminate, VARS, sizeof *eliminate);
+}
+
+static void substitute_binaries (kissat *solver, unsigned *repr) {
+  if (solver->inconsistent)
+    return;
+  KISSAT_assert (sizeof (watch) == sizeof (unsigned));
+  statches *delayed_watched = (statches *) &solver->delayed;
+  watches *all_watches = solver->watches;
+#ifdef LOGGING
+  size_t removed = 0;
+  size_t substituted = 0;
+#endif
+  unsigneds units;
+  INIT_STACK (units);
+  litwatches delayed_deleted;
+  INIT_STACK (delayed_deleted);
+#ifdef CHECKING_OR_PROVING
+  litpairs delayed_removed;
+  INIT_STACK (delayed_removed);
+#endif
+  for (all_literals (lit)) {
+    const unsigned repr_lit = repr[lit];
+    const unsigned not_repr_lit = NOT (repr_lit);
+    KISSAT_assert (EMPTY_STACK (*delayed_watched));
+    watches *watches = all_watches + lit;
+    watch *begin = BEGIN_WATCHES (*watches), *q = begin;
+    const watch *const end = END_WATCHES (*watches), *p = q;
+    while (p != end) {
+      const watch src = *p++;
+      if (!src.type.binary)
+        continue;
+      const unsigned other = src.binary.lit;
+      const unsigned repr_other = repr[other];
+      LOGBINARY (lit, other, "substituting");
+      const litwatch litwatch = {lit, src};
+      if (repr_other == not_repr_lit) {
+        LOGBINARY (repr_other, repr_lit, "becomes tautological");
+        if (lit < other) {
+#ifdef LOGGING
+          removed++;
+#endif
+          PUSH_STACK (delayed_deleted, litwatch);
+        }
+      } else if (repr_other == repr_lit) {
+        const unsigned unit = repr_lit;
+        LOG ("simplifies to unit %s", LOGLIT (unit));
+        if (lit < other) {
+#ifdef LOGGING
+          removed++;
+#endif
+          PUSH_STACK (units, unit);
+          PUSH_STACK (delayed_deleted, litwatch);
+        }
+      } else {
+        watch dst = src;
+        dst.binary.lit = repr_other;
+        if (lit == repr_lit && other == repr_other) {
+          LOGBINARY (lit, other, "unchanged");
+          *q++ = dst;
+        } else {
+          if (lit == repr_lit) {
+            LOGBINARY (repr_lit, repr_other, "substituted in place");
+            *q++ = dst;
+          } else {
+            LOGBINARY (repr_lit, repr_other, "delayed substituted");
+            PUSH_STACK (*delayed_watched, dst);
+          }
+
+          if (lit < other) {
+#ifdef LOGGING
+            substituted++;
+#endif
+#ifdef CHECKING_OR_PROVING
+            ADD_BINARY_TO_PROOF (repr_lit, repr_other);
+            CHECK_AND_ADD_BINARY (repr_lit, repr_other);
+            const litpair litpair = {{lit, other}};
+            PUSH_STACK (delayed_removed, litpair);
+#endif
+          }
+        }
+      }
+    }
+    SET_END_OF_WATCHES (*watches, q);
+    if (lit == repr_lit)
+      continue;
+    watches = all_watches + repr_lit;
+    for (all_stack (watch, watch, *delayed_watched))
+      PUSH_WATCHES (*watches, watch);
+    CLEAR_STACK (*delayed_watched);
+  }
+  assign_and_propagate_units (solver, &units);
+  RELEASE_STACK (units);
+  for (all_stack (litwatch, litwatch, delayed_deleted)) {
+    const unsigned lit = litwatch.lit;
+    const watch watch = litwatch.watch;
+    KISSAT_assert (watch.type.binary);
+    const unsigned other = watch.binary.lit;
+    kissat_delete_binary (solver, lit, other);
+  }
+  RELEASE_STACK (delayed_deleted);
+#ifdef CHECKING_OR_PROVING
+  for (all_stack (litpair, litpair, delayed_removed)) {
+    const unsigned lit = litpair.lits[0];
+    const unsigned other = litpair.lits[1];
+    DELETE_BINARY_FROM_PROOF (lit, other);
+    REMOVE_CHECKER_BINARY (lit, other);
+  }
+  RELEASE_STACK (delayed_removed);
+#endif
+  LOG ("substituted %zu binary clauses", substituted);
+  LOG ("removed %zu binary clauses", removed);
+}
+
+static void substitute_clauses (kissat *solver, unsigned *repr) {
+  if (solver->inconsistent)
+    return;
+  const value *const values = solver->values;
+  value *marks = solver->marks;
+#ifdef LOGGING
+  size_t substituted = 0;
+  size_t removed = 0;
+#endif
+  unsigneds units;
+  INIT_STACK (units);
+  references delayed_garbage;
+  INIT_STACK (delayed_garbage);
+  for (all_clauses (c)) {
+    if (c->garbage)
+      continue;
+    LOGCLS (c, "substituting");
+    KISSAT_assert (EMPTY_STACK (solver->clause));
+    bool shrink = false;
+    bool satisfied = false;
+    bool substitute = false;
+    bool tautological = false;
+    for (all_literals_in_clause (lit, c)) {
+      const value lit_value = values[lit];
+      if (lit_value < 0) {
+        LOG ("dropping falsified %s", LOGLIT (lit));
+        shrink = true;
+        continue;
+      }
+      if (lit_value > 0) {
+        LOGCLS (c, "satisfied by %s", LOGLIT (lit));
+        satisfied = true;
+        break;
+      }
+      const unsigned repr_lit = repr[lit];
+      const value repr_value = values[repr_lit];
+      if (repr_value < 0) {
+        LOG ("dropping falsified substituted %s (was %s)",
+             LOGLIT (repr_lit), LOGLIT (lit));
+        shrink = true;
+        continue;
+      }
+      if (repr_value > 0) {
+        LOGCLS (c, "satisfied by substituted %s (was %s)",
+                LOGLIT (repr_lit), LOGLIT (lit));
+        satisfied = true;
+        break;
+      }
+      if (lit != repr_lit) {
+        KISSAT_assert (!values[repr_lit]);
+        LOG ("substituted literal %s (was %s)", LOGLIT (repr_lit),
+             LOGLIT (lit));
+        substitute = true;
+      } else
+        LOG ("copying literal %s", LOGLIT (lit));
+      if (marks[repr_lit]) {
+        shrink = true;
+        LOG ("skipping duplicated %s", LOGLIT (repr_lit));
+        continue;
+      }
+      const unsigned not_repr_lit = NOT (repr_lit);
+      if (marks[not_repr_lit]) {
+        LOG ("substituted clause tautological "
+             "containing both %s and %s",
+             LOGLIT (not_repr_lit), LOGLIT (repr_lit));
+        tautological = true;
+        break;
+      }
+      marks[repr_lit] = true;
+      PUSH_STACK (solver->clause, repr_lit);
+    }
+    if (satisfied || tautological) {
+      kissat_mark_clause_as_garbage (solver, c);
+#ifdef LOGGING
+      removed++;
+#endif
+    } else if (substitute || shrink) {
+      const unsigned size = SIZE_STACK (solver->clause);
+      if (!size) {
+        LOG ("simplifies to empty clause");
+
+        CHECK_AND_ADD_EMPTY ();
+        ADD_EMPTY_TO_PROOF ();
+
+        solver->inconsistent = true;
+        break;
+      } else if (size == 1) {
+        KISSAT_assert (shrink);
+#ifdef LOGGING
+        removed++;
+#endif
+        const unsigned unit = PEEK_STACK (solver->clause, 0);
+        LOGCLS (c, "simplifies to unit %s", LOGLIT (unit));
+        PUSH_STACK (units, unit);
+        const reference ref = kissat_reference_clause (solver, c);
+        PUSH_STACK (delayed_garbage, ref);
+      } else if (size == 2) {
+        KISSAT_assert (shrink);
+#ifdef LOGGING
+        substituted++;
+#endif
+        const unsigned first = PEEK_STACK (solver->clause, 0);
+        const unsigned second = PEEK_STACK (solver->clause, 1);
+        LOGCLS (c, "unsubstituted");
+        LOGBINARY (first, second, "substituted");
+        kissat_new_binary_clause (solver, first, second);
+        kissat_mark_clause_as_garbage (solver, c);
+      } else {
+#ifdef LOGGING
+        substituted++;
+#endif
+        LOGCLS (c, "unsubstituted");
+
+        const unsigned new_size = SIZE_STACK (solver->clause);
+        unsigned *new_lits = BEGIN_STACK (solver->clause);
+
+        ADD_LITS_TO_PROOF (new_size, new_lits);
+        CHECK_AND_ADD_LITS (new_size, new_lits);
+
+        DELETE_CLAUSE_FROM_PROOF (c);
+        REMOVE_CHECKER_CLAUSE (c);
+
+        const unsigned old_size = c->size;
+        unsigned *old_lits = c->lits;
+
+        KISSAT_assert (new_size <= old_size);
+        memcpy (old_lits, new_lits, new_size * sizeof *old_lits);
+
+        KISSAT_assert (shrink == (new_size < old_size));
+        if (new_size < old_size) {
+          c->size = new_size;
+          c->searched = 2;
+          if (!c->shrunken) {
+            c->shrunken = true;
+            KISSAT_assert (c->lits == old_lits);
+            old_lits[old_size - 1] = INVALID_LIT;
+          }
+        }
+        LOGCLS (c, "unsorted substituted");
+      }
+    } else
+      LOGCLS (c, "unchanged");
+    for (all_stack (unsigned, lit, solver->clause))
+      marks[lit] = 0;
+    CLEAR_STACK (solver->clause);
+  }
+  assign_and_propagate_units (solver, &units);
+  RELEASE_STACK (units);
+  for (all_stack (reference, ref, delayed_garbage)) {
+    clause *c = kissat_dereference_clause (solver, ref);
+    kissat_mark_clause_as_garbage (solver, c);
+  }
+  RELEASE_STACK (delayed_garbage);
+  LOG ("substituted %zu large clauses", substituted);
+  LOG ("removed %zu substituted large clauses", removed);
+}
+
+static bool substitute_round (kissat *solver, unsigned round) {
+  KISSAT_assert (!solver->inconsistent);
+  const unsigned active = solver->active;
+  size_t bytes = LITS * sizeof (unsigned);
+  unsigned *repr = (unsigned*)kissat_malloc (solver, bytes);
+  memset (repr, 0xff, bytes);
+  determine_representatives (solver, repr);
+  bool *eliminate = add_representative_equivalences (solver, repr);
+  substitute_binaries (solver, repr);
+  substitute_clauses (solver, repr);
+  remove_representative_equivalences (solver, repr, eliminate);
+  kissat_dealloc (solver, repr, LITS, sizeof *repr);
+  unsigned removed = active - solver->active;
+  kissat_phase (solver, "substitute", GET (substitutions),
+                "round %u removed %u variables %.0f%%", round, removed,
+                kissat_percent (removed, active));
+  kissat_check_statistics (solver);
+  REPORT (!removed, 'd');
+#ifdef KISSAT_QUIET
+  (void) round;
+#endif
+  return !solver->inconsistent && removed;
+}
+
+static void substitute_rounds (kissat *solver, bool complete) {
+  START (substitute);
+  INC (substitutions);
+  const unsigned maxrounds = GET_OPTION (substituterounds);
+  for (unsigned round = 1; round <= maxrounds; round++) {
+    const uint64_t before = solver->statistics_.substitute_ticks;
+    if (!substitute_round (solver, round))
+      break;
+    const uint64_t after = solver->statistics_.substitute_ticks;
+    const uint64_t ticks = after - before;
+    if (!complete) {
+      const uint64_t reference =
+          solver->statistics_.search_ticks - solver->last.ticks.probe;
+      const double fraction = GET_OPTION (substituteeffort) * 1e-3;
+      const uint64_t limit = fraction * reference;
+      if (ticks > limit) {
+        kissat_extremely_verbose (
+            solver,
+            "last substitute round took %" PRIu64 " 'substitute_ticks' "
+            "> limit %" PRIu64 " = %g * %" PRIu64 " 'search_ticks'",
+            ticks, limit, fraction, reference);
+        break;
+      }
+    }
+  }
+  if (!solver->inconsistent) {
+    kissat_watch_large_clauses (solver);
+    LOG ("now all large clauses are watched after binary clauses");
+    solver->large_clauses_watched_after_binary_clauses = true;
+    kissat_reset_propagate (solver);
+    KISSAT_assert (!solver->level);
+    (void) kissat_probing_propagate (solver, 0, true);
+  }
+  STOP (substitute);
+}
+
+void kissat_substitute (kissat *solver, bool complete) {
+  if (solver->inconsistent)
+    return;
+  KISSAT_assert (solver->probing);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->level);
+  LOG ("assuming not all large clauses watched after binary clauses");
+  solver->large_clauses_watched_after_binary_clauses = false;
+  if (!GET_OPTION (substitute))
+    return;
+  if (TERMINATED (substitute_terminated_1))
+    return;
+  substitute_rounds (solver, complete);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/substitute.h b/src/sat/kissat/substitute.h
new file mode 100644
index 000000000..bf2f39b51
--- /dev/null
+++ b/src/sat/kissat/substitute.h
@@ -0,0 +1,15 @@
+#ifndef _substitute_h_INCLUDED
+#define _substitute_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_substitute (struct kissat *, bool complete);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/sweep.c b/src/sat/kissat/sweep.c
new file mode 100644
index 000000000..42420cc54
--- /dev/null
+++ b/src/sat/kissat/sweep.c
@@ -0,0 +1,1728 @@
+#include "sweep.h"
+#include "dense.h"
+#include "inline.h"
+#include "kitten.h"
+#include "logging.h"
+#include "print.h"
+#include "promote.h"
+#include "propdense.h"
+#include "proprobe.h"
+#include "random.h"
+#include "rank.h"
+#include "report.h"
+#include "terminate.h"
+
+#include <inttypes.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+struct sweeper {
+  kissat *solver;
+  unsigned *depths;
+  unsigned *reprs;
+  unsigned *next, *prev;
+  unsigned first, last;
+  unsigned encoded;
+  unsigned save;
+  unsigneds vars;
+  references refs;
+  unsigneds clause;
+  unsigneds backbone;
+  unsigneds partition;
+  unsigneds core[2];
+  struct {
+    uint64_t ticks;
+    unsigned clauses, depth, vars;
+  } limit;
+};
+
+typedef struct sweeper sweeper;
+
+static int sweep_solve (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  kitten *kitten = solver->kitten;
+  kitten_randomize_phases (kitten);
+  INC (sweep_solved);
+  int res = kitten_solve (kitten);
+  if (res == 10)
+    INC (sweep_sat);
+  if (res == 20)
+    INC (sweep_unsat);
+  return res;
+}
+
+static void set_kitten_ticks_limit (sweeper *sweeper) {
+  uint64_t remaining = 0;
+  kissat *solver = sweeper->solver;
+  if (solver->statistics_.kitten_ticks < sweeper->limit.ticks)
+    remaining = sweeper->limit.ticks - solver->statistics_.kitten_ticks;
+  LOG ("'kitten_ticks' remaining %" PRIu64, remaining);
+  kitten_set_ticks_limit (solver->kitten, remaining);
+}
+
+static bool kitten_ticks_limit_hit (sweeper *sweeper, const char *when) {
+  kissat *solver = sweeper->solver;
+  if (solver->statistics_.kitten_ticks >= sweeper->limit.ticks) {
+    LOG ("'kitten_ticks' limit of %" PRIu64 " ticks hit after %" PRIu64
+         " ticks during %s",
+         sweeper->limit.ticks, solver->statistics_.kitten_ticks, when);
+    return true;
+  }
+#ifndef LOGGING
+  (void) when;
+#endif
+  return false;
+}
+
+static void init_sweeper (kissat *solver, sweeper *sweeper) {
+  sweeper->solver = solver;
+  sweeper->encoded = 0;
+  CALLOC (unsigned, sweeper->depths, VARS);
+  NALLOC (unsigned, sweeper->reprs, LITS);
+  for (all_literals (lit))
+    sweeper->reprs[lit] = lit;
+  NALLOC (unsigned, sweeper->prev, VARS);
+  memset (sweeper->prev, 0xff, VARS * sizeof *sweeper->prev);
+  NALLOC (unsigned, sweeper->next, VARS);
+  memset (sweeper->next, 0xff, VARS * sizeof *sweeper->next);
+#ifndef KISSAT_NDEBUG
+  for (all_variables (idx))
+    KISSAT_assert (sweeper->prev[idx] == INVALID_IDX);
+  for (all_variables (idx))
+    KISSAT_assert (sweeper->next[idx] == INVALID_IDX);
+#endif
+  sweeper->first = sweeper->last = INVALID_IDX;
+  INIT_STACK (sweeper->vars);
+  INIT_STACK (sweeper->refs);
+  INIT_STACK (sweeper->clause);
+  INIT_STACK (sweeper->backbone);
+  INIT_STACK (sweeper->partition);
+  INIT_STACK (sweeper->core[0]);
+  INIT_STACK (sweeper->core[1]);
+  KISSAT_assert (!solver->kitten);
+  solver->kitten = kitten_embedded (solver);
+  kitten_track_antecedents (solver->kitten);
+  kissat_enter_dense_mode (solver, 0);
+  kissat_connect_irredundant_large_clauses (solver);
+
+  unsigned completed = solver->statistics_.sweep_completed;
+  const unsigned max_completed = 32;
+  if (completed > max_completed)
+    completed = max_completed;
+
+  uint64_t vars_limit = GET_OPTION (sweepvars);
+  vars_limit <<= completed;
+  const unsigned max_vars_limit = GET_OPTION (sweepmaxvars);
+  if (vars_limit > max_vars_limit)
+    vars_limit = max_vars_limit;
+  sweeper->limit.vars = vars_limit;
+  kissat_extremely_verbose (solver, "sweeper variable limit %u",
+                            sweeper->limit.vars);
+
+  uint64_t depth_limit = solver->statistics_.sweep_completed;
+  depth_limit += GET_OPTION (sweepdepth);
+  const unsigned max_depth = GET_OPTION (sweepmaxdepth);
+  if (depth_limit > max_depth)
+    depth_limit = max_depth;
+  sweeper->limit.depth = depth_limit;
+  kissat_extremely_verbose (solver, "sweeper depth limit %u",
+                            sweeper->limit.depth);
+
+  uint64_t clause_limit = GET_OPTION (sweepclauses);
+  clause_limit <<= completed;
+  const unsigned max_clause_limit = GET_OPTION (sweepmaxclauses);
+  if (clause_limit > max_clause_limit)
+    clause_limit = max_clause_limit;
+  sweeper->limit.clauses = clause_limit;
+  kissat_extremely_verbose (solver, "sweeper clause limit %u",
+                            sweeper->limit.clauses);
+
+  if (GET_OPTION (sweepcomplete)) {
+    sweeper->limit.ticks = UINT64_MAX;
+    kissat_extremely_verbose (solver, "unlimited sweeper ticks limit");
+  } else {
+    SET_EFFORT_LIMIT (ticks_limit, sweep, kitten_ticks);
+    sweeper->limit.ticks = ticks_limit;
+  }
+  set_kitten_ticks_limit (sweeper);
+}
+
+static unsigned release_sweeper (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+
+  unsigned merged = 0;
+  for (all_variables (idx)) {
+    if (!ACTIVE (idx))
+      continue;
+    const unsigned lit = LIT (idx);
+    if (sweeper->reprs[lit] != lit)
+      merged++;
+  }
+  DEALLOC (sweeper->depths, VARS);
+  DEALLOC (sweeper->reprs, LITS);
+  DEALLOC (sweeper->prev, VARS);
+  DEALLOC (sweeper->next, VARS);
+  RELEASE_STACK (sweeper->vars);
+  RELEASE_STACK (sweeper->refs);
+  RELEASE_STACK (sweeper->clause);
+  RELEASE_STACK (sweeper->backbone);
+  RELEASE_STACK (sweeper->partition);
+  RELEASE_STACK (sweeper->core[0]);
+  RELEASE_STACK (sweeper->core[1]);
+  kitten_release (solver->kitten);
+  solver->kitten = 0;
+  kissat_resume_sparse_mode (solver, false, 0);
+  return merged;
+}
+
+static void clear_sweeper (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  LOG ("clearing sweeping environment");
+  kitten_clear (solver->kitten);
+  kitten_track_antecedents (solver->kitten);
+  for (all_stack (unsigned, idx, sweeper->vars)) {
+    KISSAT_assert (sweeper->depths[idx]);
+    sweeper->depths[idx] = 0;
+  }
+  CLEAR_STACK (sweeper->vars);
+  for (all_stack (reference, ref, sweeper->refs)) {
+    clause *c = kissat_dereference_clause (solver, ref);
+    KISSAT_assert (c->swept);
+    c->swept = false;
+  }
+  CLEAR_STACK (sweeper->refs);
+  CLEAR_STACK (sweeper->backbone);
+  CLEAR_STACK (sweeper->partition);
+  sweeper->encoded = 0;
+  set_kitten_ticks_limit (sweeper);
+}
+
+static unsigned sweep_repr (sweeper *sweeper, unsigned lit) {
+  unsigned res;
+  {
+    unsigned prev = lit;
+    while ((res = sweeper->reprs[prev]) != prev)
+      prev = res;
+  }
+  if (res == lit)
+    return res;
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  kissat *solver = sweeper->solver;
+#endif
+  LOG ("sweeping repr[%s] = %s", LOGLIT (lit), LOGLIT (res));
+  {
+    const unsigned not_res = NOT (res);
+    unsigned next, prev = lit;
+    ;
+    while ((next = sweeper->reprs[prev]) != res) {
+      const unsigned not_prev = NOT (prev);
+      sweeper->reprs[not_prev] = not_res;
+      sweeper->reprs[prev] = res;
+      prev = next;
+    }
+    KISSAT_assert (sweeper->reprs[NOT (prev)] == not_res);
+  }
+  return res;
+}
+
+static void add_literal_to_environment (sweeper *sweeper, unsigned depth,
+                                        unsigned lit) {
+  const unsigned repr = sweep_repr (sweeper, lit);
+  if (repr != lit)
+    return;
+  kissat *solver = sweeper->solver;
+  const unsigned idx = IDX (lit);
+  if (sweeper->depths[idx])
+    return;
+  KISSAT_assert (depth < UINT_MAX);
+  sweeper->depths[idx] = depth + 1;
+  PUSH_STACK (sweeper->vars, idx);
+  LOG ("sweeping[%u] adding literal %s", depth, LOGLIT (lit));
+}
+
+static void sweep_clause (sweeper *sweeper, unsigned depth) {
+  kissat *solver = sweeper->solver;
+  KISSAT_assert (SIZE_STACK (sweeper->clause) > 1);
+  for (all_stack (unsigned, lit, sweeper->clause))
+    add_literal_to_environment (sweeper, depth, lit);
+  kitten_clause (solver->kitten, SIZE_STACK (sweeper->clause),
+                 BEGIN_STACK (sweeper->clause));
+  CLEAR_STACK (sweeper->clause);
+  sweeper->encoded++;
+}
+
+static void sweep_binary (sweeper *sweeper, unsigned depth, unsigned lit,
+                          unsigned other) {
+  if (sweep_repr (sweeper, lit) != lit)
+    return;
+  if (sweep_repr (sweeper, other) != other)
+    return;
+  kissat *solver = sweeper->solver;
+  LOGBINARY (lit, other, "sweeping[%u]", depth);
+  value *values = solver->values;
+  KISSAT_assert (!values[lit]);
+  const value other_value = values[other];
+  if (other_value > 0) {
+    LOGBINARY (lit, other, "skipping satisfied");
+    return;
+  }
+  const unsigned *depths = sweeper->depths;
+  const unsigned other_idx = IDX (other);
+  const unsigned other_depth = depths[other_idx];
+  const unsigned lit_idx = IDX (lit);
+  const unsigned lit_depth = depths[lit_idx];
+  if (other_depth && other_depth < lit_depth) {
+    LOGBINARY (lit, other, "skipping depth %u copied", other_depth);
+    return;
+  }
+  KISSAT_assert (!other_value);
+  KISSAT_assert (EMPTY_STACK (sweeper->clause));
+  PUSH_STACK (sweeper->clause, lit);
+  PUSH_STACK (sweeper->clause, other);
+  sweep_clause (sweeper, depth);
+}
+
+static void sweep_reference (sweeper *sweeper, unsigned depth,
+                             reference ref) {
+  KISSAT_assert (EMPTY_STACK (sweeper->clause));
+  kissat *solver = sweeper->solver;
+  clause *c = kissat_dereference_clause (solver, ref);
+  if (c->swept)
+    return;
+  if (c->garbage)
+    return;
+  LOGCLS (c, "sweeping[%u]", depth);
+  value *values = solver->values;
+  for (all_literals_in_clause (lit, c)) {
+    const value value = values[lit];
+    if (value > 0) {
+      kissat_mark_clause_as_garbage (solver, c);
+      CLEAR_STACK (sweeper->clause);
+      return;
+    }
+    if (value < 0)
+      continue;
+    PUSH_STACK (sweeper->clause, lit);
+  }
+  PUSH_STACK (sweeper->refs, ref);
+  c->swept = true;
+  sweep_clause (sweeper, depth);
+}
+
+static void save_core_clause (void *state, bool learned, size_t size,
+                              const unsigned *lits) {
+  sweeper *sweeper = (struct sweeper*)state;
+  kissat *solver = sweeper->solver;
+  if (solver->inconsistent)
+    return;
+  const value *const values = solver->values;
+  unsigneds *core = sweeper->core + sweeper->save;
+  size_t saved = SIZE_STACK (*core);
+  const unsigned *end = lits + size;
+  unsigned non_false = 0;
+  for (const unsigned *p = lits; p != end; p++) {
+    const unsigned lit = *p;
+    const value value = values[lit];
+    if (value > 0) {
+      LOGLITS (size, lits, "extracted %s satisfied lemma", LOGLIT (lit));
+      RESIZE_STACK (*core, saved);
+      return;
+    }
+    PUSH_STACK (*core, lit);
+    if (value < 0)
+      continue;
+    if (!learned && ++non_false > 1) {
+      LOGLITS (size, lits, "ignoring extracted original clause");
+      RESIZE_STACK (*core, saved);
+      return;
+    }
+  }
+#ifdef LOGGING
+  unsigned *saved_lits = BEGIN_STACK (*core) + saved;
+  size_t saved_size = SIZE_STACK (*core) - saved;
+  LOGLITS (saved_size, saved_lits, "saved core[%u]", sweeper->save);
+#endif
+  PUSH_STACK (*core, INVALID_LIT);
+}
+
+static void add_core (sweeper *sweeper, unsigned core_idx) {
+  kissat *solver = sweeper->solver;
+  if (solver->inconsistent)
+    return;
+  LOG ("check and add extracted core[%u] lemmas to proof", core_idx);
+  KISSAT_assert (core_idx == 0 || core_idx == 1);
+  unsigneds *core = sweeper->core + core_idx;
+  const value *const values = solver->values;
+
+  unsigned *q = BEGIN_STACK (*core);
+  const unsigned *const end_core = END_STACK (*core), *p = q;
+
+  while (p != end_core) {
+    const unsigned *c = p;
+    while (*p != INVALID_LIT)
+      p++;
+#ifdef LOGGING
+    size_t old_size = p - c;
+    LOGLITS (old_size, c, "simplifying extracted core[%u] lemma", core_idx);
+#endif
+    bool satisfied = false;
+    unsigned unit = INVALID_LIT;
+
+    unsigned *d = q;
+
+    for (const unsigned *l = c; !satisfied && l != p; l++) {
+      const unsigned lit = *l;
+      const value value = values[lit];
+      if (value > 0) {
+        satisfied = true;
+        break;
+      }
+      if (!value)
+        unit = *q++ = lit;
+    }
+
+    size_t new_size = q - d;
+    p++;
+
+    if (satisfied) {
+      q = d;
+      LOG ("not adding satisfied clause");
+      continue;
+    }
+
+    if (!new_size) {
+      LOG ("sweeping produced empty clause");
+      CHECK_AND_ADD_EMPTY ();
+      ADD_EMPTY_TO_PROOF ();
+      solver->inconsistent = true;
+      CLEAR_STACK (*core);
+      return;
+    }
+
+    if (new_size == 1) {
+      q = d;
+      KISSAT_assert (unit != INVALID_LIT);
+      LOG ("sweeping produced unit %s", LOGLIT (unit));
+      CHECK_AND_ADD_UNIT (unit);
+      ADD_UNIT_TO_PROOF (unit);
+      kissat_assign_unit (solver, unit, "sweeping backbone reason");
+      INC (sweep_units);
+      continue;
+    }
+
+    *q++ = INVALID_LIT;
+
+    KISSAT_assert (new_size > 1);
+    LOGLITS (new_size, d, "adding extracted core[%u] lemma", core_idx);
+    CHECK_AND_ADD_LITS (new_size, d);
+    ADD_LITS_TO_PROOF (new_size, d);
+  }
+  SET_END_OF_STACK (*core, q);
+#ifndef LOGGING
+  (void) core_idx;
+#endif
+}
+
+static void save_core (sweeper *sweeper, unsigned core) {
+  kissat *solver = sweeper->solver;
+  LOG ("saving extracted core[%u] lemmas", core);
+  KISSAT_assert (core == 0 || core == 1);
+  KISSAT_assert (EMPTY_STACK (sweeper->core[core]));
+  sweeper->save = core;
+  kitten_compute_clausal_core (solver->kitten, 0);
+  kitten_traverse_core_clauses (solver->kitten, sweeper, save_core_clause);
+}
+
+static void clear_core (sweeper *sweeper, unsigned core_idx) {
+  kissat *solver = sweeper->solver;
+  if (solver->inconsistent)
+    return;
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG) || !defined(KISSAT_NPROOFS)
+  KISSAT_assert (core_idx == 0 || core_idx == 1);
+  LOG ("clearing core[%u] lemmas", core_idx);
+#endif
+  unsigneds *core = sweeper->core + core_idx;
+#ifdef CHECKING_OR_PROVING
+  LOG ("deleting sub-solver core clauses");
+  const unsigned *const end = END_STACK (*core);
+  const unsigned *c = BEGIN_STACK (*core);
+  for (const unsigned *p = c; c != end; c = ++p) {
+    while (*p != INVALID_LIT)
+      p++;
+    const size_t size = p - c;
+    KISSAT_assert (size > 1);
+    REMOVE_CHECKER_LITS (size, c);
+    DELETE_LITS_FROM_PROOF (size, c);
+  }
+#endif
+  CLEAR_STACK (*core);
+}
+
+static void save_add_clear_core (sweeper *sweeper) {
+  save_core (sweeper, 0);
+  add_core (sweeper, 0);
+  clear_core (sweeper, 0);
+}
+
+#define LOGBACKBONE(MESSAGE) \
+  LOGLITSET (SIZE_STACK (sweeper->backbone), \
+             BEGIN_STACK (sweeper->backbone), MESSAGE)
+
+#define LOGPARTITION(MESSAGE) \
+  LOGLITPART (SIZE_STACK (sweeper->partition), \
+              BEGIN_STACK (sweeper->partition), MESSAGE)
+
+static void init_backbone_and_partition (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  LOG ("initializing backbone and equivalent literals candidates");
+  for (all_stack (unsigned, idx, sweeper->vars)) {
+    if (!ACTIVE (idx))
+      continue;
+    const unsigned lit = LIT (idx);
+    const unsigned not_lit = NOT (lit);
+    const signed char tmp = kitten_value (solver->kitten, lit);
+    const unsigned candidate = (tmp < 0) ? not_lit : lit;
+    LOG ("sweeping candidate %s", LOGLIT (candidate));
+    PUSH_STACK (sweeper->backbone, candidate);
+    PUSH_STACK (sweeper->partition, candidate);
+  }
+  PUSH_STACK (sweeper->partition, INVALID_LIT);
+
+  LOGBACKBONE ("initialized backbone candidates");
+  LOGPARTITION ("initialized equivalence candidates");
+}
+
+static void sweep_empty_clause (sweeper *sweeper) {
+  KISSAT_assert (!sweeper->solver->inconsistent);
+  save_add_clear_core (sweeper);
+  KISSAT_assert (sweeper->solver->inconsistent);
+}
+
+static void sweep_refine_partition (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  LOG ("refining partition");
+  kitten *kitten = solver->kitten;
+  unsigneds old_partition = sweeper->partition;
+  unsigneds new_partition;
+  INIT_STACK (new_partition);
+  const value *const values = solver->values;
+  const unsigned *const old_begin = BEGIN_STACK (old_partition);
+  const unsigned *const old_end = END_STACK (old_partition);
+#ifdef LOGGING
+  unsigned old_classes = 0;
+  unsigned new_classes = 0;
+#endif
+  for (const unsigned *p = old_begin, *q; p != old_end; p = q + 1) {
+    unsigned assigned_true = 0, other;
+    for (q = p; (other = *q) != INVALID_LIT; q++) {
+      if (sweep_repr (sweeper, other) != other)
+        continue;
+      if (values[other])
+        continue;
+      signed char value = kitten_value (kitten, other);
+      if (!value)
+        LOG ("dropping sub-solver unassigned %s", LOGLIT (other));
+      else if (value > 0) {
+        PUSH_STACK (new_partition, other);
+        assigned_true++;
+      }
+    }
+#ifdef LOGGING
+    LOG ("refining class %u of size %zu", old_classes, (size_t) (q - p));
+    old_classes++;
+#endif
+    if (assigned_true == 0)
+      LOG ("no positive literal in class");
+    else if (assigned_true == 1) {
+#ifdef LOGGING
+      other =
+#else
+      (void)
+#endif
+          POP_STACK (new_partition);
+      LOG ("dropping singleton class %s", LOGLIT (other));
+    } else {
+      LOG ("%u positive literal in class", assigned_true);
+      PUSH_STACK (new_partition, INVALID_LIT);
+#ifdef LOGGING
+      new_classes++;
+#endif
+    }
+
+    unsigned assigned_false = 0;
+    for (q = p; (other = *q) != INVALID_LIT; q++) {
+      if (sweep_repr (sweeper, other) != other)
+        continue;
+      if (values[other])
+        continue;
+      signed char value = kitten_value (kitten, other);
+      if (value < 0) {
+        PUSH_STACK (new_partition, other);
+        assigned_false++;
+      }
+    }
+
+    if (assigned_false == 0)
+      LOG ("no negative literal in class");
+    else if (assigned_false == 1) {
+#ifdef LOGGING
+      other =
+#else
+      (void)
+#endif
+          POP_STACK (new_partition);
+      LOG ("dropping singleton class %s", LOGLIT (other));
+    } else {
+      LOG ("%u negative literal in class", assigned_false);
+      PUSH_STACK (new_partition, INVALID_LIT);
+#ifdef LOGGING
+      new_classes++;
+#endif
+    }
+  }
+  RELEASE_STACK (old_partition);
+  sweeper->partition = new_partition;
+  LOG ("refined %u classes into %u", old_classes, new_classes);
+  LOGPARTITION ("refined equivalence candidates");
+}
+
+static void sweep_refine_backbone (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  LOG ("refining backbone candidates");
+  const unsigned *const end = END_STACK (sweeper->backbone);
+  unsigned *q = BEGIN_STACK (sweeper->backbone);
+  const value *const values = solver->values;
+  kitten *kitten = solver->kitten;
+  for (const unsigned *p = q; p != end; p++) {
+    const unsigned lit = *p;
+    if (values[lit])
+      continue;
+    signed char value = kitten_value (kitten, lit);
+    if (!value)
+      LOG ("dropping sub-solver unassigned %s", LOGLIT (lit));
+    else if (value >= 0)
+      *q++ = lit;
+  }
+  SET_END_OF_STACK (sweeper->backbone, q);
+  LOGBACKBONE ("refined backbone candidates");
+}
+
+static void sweep_refine (sweeper *sweeper) {
+#ifdef LOGGING
+  kissat *solver = sweeper->solver;
+#endif
+  if (EMPTY_STACK (sweeper->backbone))
+    LOG ("no need to refine empty backbone candidates");
+  else
+    sweep_refine_backbone (sweeper);
+  if (EMPTY_STACK (sweeper->partition))
+    LOG ("no need to refine empty partition candidates");
+  else
+    sweep_refine_partition (sweeper);
+}
+
+static void flip_backbone_literals (struct sweeper *sweeper) {
+  struct kissat *solver = sweeper->solver;
+  const unsigned max_rounds = GET_OPTION (sweepfliprounds);
+  if (!max_rounds)
+    return;
+  KISSAT_assert (!EMPTY_STACK (sweeper->backbone));
+  struct kitten *kitten = solver->kitten;
+  if (kitten_status (kitten) != 10)
+    return;
+#ifdef LOGGING
+  unsigned total_flipped = 0;
+#endif
+  unsigned flipped, round = 0;
+  do {
+    round++;
+    flipped = 0;
+    unsigned *begin = BEGIN_STACK (sweeper->backbone), *q = begin;
+    const unsigned *const end = END_STACK (sweeper->backbone), *p = q;
+    while (p != end) {
+      const unsigned lit = *p++;
+      INC (sweep_flip_backbone);
+      if (kitten_flip_literal (kitten, lit)) {
+        LOG ("flipping backbone candidate %s succeeded", LOGLIT (lit));
+#ifdef LOGGING
+        total_flipped++;
+#endif
+        INC (sweep_flipped_backbone);
+        flipped++;
+      } else {
+        LOG ("flipping backbone candidate %s failed", LOGLIT (lit));
+        *q++ = lit;
+      }
+    }
+    SET_END_OF_STACK (sweeper->backbone, q);
+    LOG ("flipped %u backbone candidates in round %u", flipped, round);
+
+    if (TERMINATED (sweep_terminated_1))
+      break;
+    if (solver->statistics_.kitten_ticks > sweeper->limit.ticks)
+      break;
+  } while (flipped && round < max_rounds);
+  LOG ("flipped %u backbone candidates in total in %u rounds",
+       total_flipped, round);
+}
+
+static bool sweep_backbone_candidate (sweeper *sweeper, unsigned lit) {
+  kissat *solver = sweeper->solver;
+  LOG ("trying backbone candidate %s", LOGLIT (lit));
+  kitten *kitten = solver->kitten;
+  signed char value = kitten_fixed (kitten, lit);
+  if (value) {
+    INC (sweep_fixed_backbone);
+    LOG ("literal %s already fixed", LOGLIT (lit));
+    KISSAT_assert (value > 0);
+    return false;
+  }
+
+  INC (sweep_flip_backbone);
+  if (kitten_status (kitten) == 10 && kitten_flip_literal (kitten, lit)) {
+    INC (sweep_flipped_backbone);
+    LOG ("flipping %s succeeded", LOGLIT (lit));
+    LOGBACKBONE ("refined backbone candidates");
+    return false;
+  }
+
+  LOG ("flipping %s failed", LOGLIT (lit));
+  const unsigned not_lit = NOT (lit);
+  INC (sweep_solved_backbone);
+  kitten_assume (kitten, not_lit);
+  int res = sweep_solve (sweeper);
+  if (res == 10) {
+    LOG ("sweeping backbone candidate %s failed", LOGLIT (lit));
+    sweep_refine (sweeper);
+    INC (sweep_sat_backbone);
+    return false;
+  }
+
+  if (res == 20) {
+    LOG ("sweep unit %s", LOGLIT (lit));
+    save_add_clear_core (sweeper);
+    INC (sweep_unsat_backbone);
+    return true;
+  }
+
+  INC (sweep_unknown_backbone);
+
+  LOG ("sweeping backbone candidate %s failed", LOGLIT (lit));
+  return false;
+}
+
+static void add_binary (kissat *solver, unsigned lit, unsigned other) {
+  kissat_new_binary_clause (solver, lit, other);
+}
+
+static bool scheduled_variable (sweeper *sweeper, unsigned idx) {
+#ifndef KISSAT_NDEBUG
+  kissat *const solver = sweeper->solver;
+  KISSAT_assert (VALID_INTERNAL_INDEX (idx));
+#endif
+  return sweeper->prev[idx] != INVALID_IDX || sweeper->first == idx;
+}
+
+static void schedule_inner (sweeper *sweeper, unsigned idx) {
+  kissat *const solver = sweeper->solver;
+  KISSAT_assert (VALID_INTERNAL_INDEX (idx));
+  if (!ACTIVE (idx))
+    return;
+  const unsigned next = sweeper->next[idx];
+  if (next != INVALID_IDX) {
+    LOG ("rescheduling inner %s as last", LOGVAR (idx));
+    const unsigned prev = sweeper->prev[idx];
+    KISSAT_assert (sweeper->prev[next] == idx);
+    sweeper->prev[next] = prev;
+    if (prev == INVALID_IDX) {
+      KISSAT_assert (sweeper->first == idx);
+      sweeper->first = next;
+    } else {
+      KISSAT_assert (sweeper->next[prev] == idx);
+      sweeper->next[prev] = next;
+    }
+    const unsigned last = sweeper->last;
+    if (last == INVALID_IDX) {
+      KISSAT_assert (sweeper->first == INVALID_IDX);
+      sweeper->first = idx;
+    } else {
+      KISSAT_assert (sweeper->next[last] == INVALID_IDX);
+      sweeper->next[last] = idx;
+    }
+    sweeper->prev[idx] = last;
+    sweeper->next[idx] = INVALID_IDX;
+    sweeper->last = idx;
+  } else if (sweeper->last != idx) {
+    LOG ("scheduling inner %s as last", LOGVAR (idx));
+    const unsigned last = sweeper->last;
+    if (last == INVALID_IDX) {
+      KISSAT_assert (sweeper->first == INVALID_IDX);
+      sweeper->first = idx;
+    } else {
+      KISSAT_assert (sweeper->next[last] == INVALID_IDX);
+      sweeper->next[last] = idx;
+    }
+    KISSAT_assert (sweeper->next[idx] == INVALID_IDX);
+    sweeper->prev[idx] = last;
+    sweeper->last = idx;
+  } else
+    LOG ("keeping inner %s scheduled as last", LOGVAR (idx));
+}
+
+static void schedule_outer (sweeper *sweeper, unsigned idx) {
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+  kissat *const solver = sweeper->solver;
+#endif
+  KISSAT_assert (VALID_INTERNAL_INDEX (idx));
+  KISSAT_assert (!scheduled_variable (sweeper, idx));
+  KISSAT_assert (ACTIVE (idx));
+  const unsigned first = sweeper->first;
+  if (first == INVALID_IDX) {
+    KISSAT_assert (sweeper->last == INVALID_IDX);
+    sweeper->last = idx;
+  } else {
+    KISSAT_assert (sweeper->prev[first] == INVALID_IDX);
+    sweeper->prev[first] = idx;
+  }
+  KISSAT_assert (sweeper->prev[idx] == INVALID_IDX);
+  sweeper->next[idx] = first;
+  sweeper->first = idx;
+  LOG ("scheduling outer %s as first", LOGVAR (idx));
+}
+
+static unsigned next_scheduled (sweeper *sweeper) {
+#if !defined(KISSAT_NDEBUG) || defined(LOGGING)
+  kissat *const solver = sweeper->solver;
+#endif
+  unsigned res = sweeper->last;
+  if (res == INVALID_IDX) {
+    LOG ("no more scheduled variables left");
+    return INVALID_IDX;
+  }
+  KISSAT_assert (VALID_INTERNAL_INDEX (res));
+  LOG ("dequeuing next scheduled %s", LOGVAR (res));
+  const unsigned prev = sweeper->prev[res];
+  KISSAT_assert (sweeper->next[res] == INVALID_IDX);
+  sweeper->prev[res] = INVALID_IDX;
+  if (prev == INVALID_IDX) {
+    KISSAT_assert (sweeper->first == res);
+    sweeper->first = INVALID_IDX;
+  } else {
+    KISSAT_assert (sweeper->next[prev] == res);
+    sweeper->next[prev] = INVALID_IDX;
+  }
+  sweeper->last = prev;
+  return res;
+}
+
+#define all_scheduled(IDX) \
+  unsigned IDX = sweeper->first, NEXT_##IDX; \
+  IDX != INVALID_IDX && (NEXT_##IDX = sweeper->next[IDX], true); \
+  IDX = NEXT_##IDX
+
+static void substitute_connected_clauses (sweeper *sweeper, unsigned lit,
+                                          unsigned repr) {
+  kissat *solver = sweeper->solver;
+  if (solver->inconsistent)
+    return;
+  value *const values = solver->values;
+  if (values[lit])
+    return;
+  if (values[repr])
+    return;
+  LOG ("substituting %s with %s in all irredundant clauses", LOGLIT (lit),
+       LOGLIT (repr));
+
+  KISSAT_assert (lit != repr);
+  KISSAT_assert (lit != NOT (repr));
+
+#ifdef CHECKING_OR_PROVING
+  const bool checking_or_proving = kissat_checking_or_proving (solver);
+  KISSAT_assert (EMPTY_STACK (solver->added));
+  KISSAT_assert (EMPTY_STACK (solver->removed));
+#endif
+
+  unsigneds *const delayed = &solver->delayed;
+  KISSAT_assert (EMPTY_STACK (*delayed));
+
+  {
+    watches *lit_watches = &WATCHES (lit);
+    watch *const begin_watches = BEGIN_WATCHES (*lit_watches);
+    const watch *const end_watches = END_WATCHES (*lit_watches);
+
+    watch *q = begin_watches;
+    const watch *p = q;
+
+    while (p != end_watches) {
+      const watch head = *q++ = *p++;
+      if (head.type.binary) {
+        const unsigned other = head.binary.lit;
+        const value other_value = values[other];
+        if (other == NOT (repr))
+          continue;
+        if (other_value < 0)
+          break;
+        if (other_value > 0)
+          continue;
+        if (other == repr) {
+          CHECK_AND_ADD_UNIT (lit);
+          ADD_UNIT_TO_PROOF (lit);
+          kissat_assign_unit (solver, lit, "substituted binary clause");
+          INC (sweep_units);
+          break;
+        }
+        CHECK_AND_ADD_BINARY (repr, other);
+        ADD_BINARY_TO_PROOF (repr, other);
+        REMOVE_CHECKER_BINARY (lit, other);
+        DELETE_BINARY_FROM_PROOF (lit, other);
+        PUSH_STACK (*delayed, head.raw);
+        watch src = {.raw = head.raw};
+        watch dst = {.raw = head.raw};
+        src.binary.lit = lit;
+        dst.binary.lit = repr;
+        watches *other_watches = &WATCHES (other);
+        kissat_substitute_large_watch (solver, other_watches, src, dst);
+        q--;
+      } else {
+        const reference ref = head.large.ref;
+        KISSAT_assert (EMPTY_STACK (sweeper->clause));
+        clause *c = kissat_dereference_clause (solver, ref);
+        if (c->garbage)
+          continue;
+
+        bool satisfied = false;
+        bool repr_already_watched = false;
+        const unsigned not_repr = NOT (repr);
+#ifndef KISSAT_NDEBUG
+        bool found = false;
+#endif
+        for (all_literals_in_clause (other, c)) {
+          if (other == lit) {
+#ifndef KISSAT_NDEBUG
+            KISSAT_assert (!found);
+            found = true;
+#endif
+            PUSH_STACK (solver->clause, repr);
+            continue;
+          }
+          KISSAT_assert (other != NOT (lit));
+          if (other == repr) {
+            KISSAT_assert (!repr_already_watched);
+            repr_already_watched = true;
+            continue;
+          }
+          if (other == not_repr) {
+            satisfied = true;
+            break;
+          }
+          const value tmp = values[other];
+          if (tmp < 0)
+            continue;
+          if (tmp > 0) {
+            satisfied = true;
+            break;
+          }
+          PUSH_STACK (solver->clause, other);
+        }
+
+        if (satisfied) {
+          CLEAR_STACK (solver->clause);
+          kissat_mark_clause_as_garbage (solver, c);
+          continue;
+        }
+        KISSAT_assert (found);
+
+        const unsigned new_size = SIZE_STACK (solver->clause);
+
+        if (new_size == 0) {
+          LOGCLS (c, "substituted empty clause");
+          KISSAT_assert (!solver->inconsistent);
+          solver->inconsistent = true;
+          CHECK_AND_ADD_EMPTY ();
+          ADD_EMPTY_TO_PROOF ();
+          break;
+        }
+
+        if (new_size == 1) {
+          LOGCLS (c, "reduces to unit");
+          const unsigned unit = POP_STACK (solver->clause);
+          CHECK_AND_ADD_UNIT (unit);
+          ADD_UNIT_TO_PROOF (unit);
+          kissat_assign_unit (solver, unit, "substituted large clause");
+          INC (sweep_units);
+          break;
+        }
+
+        CHECK_AND_ADD_STACK (solver->clause);
+        ADD_STACK_TO_PROOF (solver->clause);
+        REMOVE_CHECKER_CLAUSE (c);
+        DELETE_CLAUSE_FROM_PROOF (c);
+
+        if (!c->redundant)
+          kissat_mark_added_literals (solver, new_size,
+                                      BEGIN_STACK (solver->clause));
+
+        if (new_size == 2) {
+          const unsigned second = POP_STACK (solver->clause);
+          const unsigned first = POP_STACK (solver->clause);
+          LOGCLS (c, "reduces to binary clause %s %s", LOGLIT (first),
+                  LOGLIT (second));
+          KISSAT_assert (first == repr || second == repr);
+          const unsigned other = first ^ second ^ repr;
+          const watch src = {.raw = head.raw};
+          watch dst = kissat_binary_watch (repr);
+          watches *other_watches = &WATCHES (other);
+          kissat_substitute_large_watch (solver, other_watches, src, dst);
+          KISSAT_assert (solver->statistics_.clauses_irredundant);
+          solver->statistics_.clauses_irredundant--;
+          KISSAT_assert (solver->statistics_.clauses_binary < UINT64_MAX);
+          solver->statistics_.clauses_binary++;
+          dst.binary.lit = other;
+          PUSH_STACK (*delayed, dst.raw);
+          const size_t bytes = kissat_actual_bytes_of_clause (c);
+          ADD (arena_garbage, bytes);
+          c->garbage = true;
+          q--;
+          continue;
+        }
+
+        KISSAT_assert (2 < new_size);
+        const unsigned old_size = c->size;
+        KISSAT_assert (new_size <= old_size);
+
+        const unsigned *const begin = BEGIN_STACK (solver->clause);
+        const unsigned *const end = END_STACK (solver->clause);
+
+        unsigned *lits = c->lits;
+        unsigned *q = lits;
+
+        for (const unsigned *p = begin; p != end; p++) {
+          const unsigned other = *p;
+          *q++ = other;
+        }
+
+        if (new_size < old_size) {
+          c->size = new_size;
+          c->searched = 2;
+          if (c->redundant && c->glue >= new_size)
+            kissat_promote_clause (solver, c, new_size - 1);
+          if (!c->shrunken) {
+            c->shrunken = true;
+            lits[old_size - 1] = INVALID_LIT;
+          }
+        }
+
+        LOGCLS (c, "substituted");
+
+        if (!repr_already_watched)
+          PUSH_STACK (*delayed, head.raw);
+        CLEAR_STACK (solver->clause);
+        q--;
+      }
+    }
+    while (p != end_watches)
+      *q++ = *p++;
+    SET_END_OF_WATCHES (*lit_watches, q);
+  }
+  {
+    const unsigned *const begin_delayed = BEGIN_STACK (*delayed);
+    const unsigned *const end_delayed = END_STACK (*delayed);
+    for (const unsigned *p = begin_delayed; p != end_delayed; p++) {
+      const watch head = {.raw = *p};
+      watches *repr_watches = &WATCHES (repr);
+      PUSH_WATCHES (*repr_watches, head);
+    }
+
+    CLEAR_STACK (*delayed);
+  }
+
+#ifdef CHECKING_OR_PROVING
+  if (checking_or_proving) {
+    CLEAR_STACK (solver->added);
+    CLEAR_STACK (solver->removed);
+  }
+#endif
+}
+
+static void sweep_remove (sweeper *sweeper, unsigned lit) {
+  kissat *solver = sweeper->solver;
+  KISSAT_assert (sweeper->reprs[lit] != lit);
+  unsigneds *partition = &sweeper->partition;
+  unsigned *const begin_partition = BEGIN_STACK (*partition), *p;
+  const unsigned *const end_partition = END_STACK (*partition);
+  for (p = begin_partition; *p != lit; p++)
+    KISSAT_assert (p + 1 != end_partition);
+  unsigned *begin_class = p;
+  while (begin_class != begin_partition && begin_class[-1] != INVALID_LIT)
+    begin_class--;
+  const unsigned *end_class = p;
+  while (*end_class != INVALID_LIT)
+    end_class++;
+  const unsigned size = end_class - begin_class;
+  LOG ("removing non-representative %s from equivalence class of size %u",
+       LOGLIT (lit), size);
+  KISSAT_assert (size > 1);
+  unsigned *q = begin_class;
+  if (size == 2) {
+    LOG ("completely squashing equivalence class of %s", LOGLIT (lit));
+    for (const unsigned *r = end_class + 1; r != end_partition; r++)
+      *q++ = *r;
+  } else {
+    for (const unsigned *r = begin_class; r != end_partition; r++)
+      if (r != p)
+        *q++ = *r;
+  }
+  SET_END_OF_STACK (*partition, q);
+#ifndef LOGGING
+  (void) solver;
+#endif
+}
+
+static void flip_partition_literals (struct sweeper *sweeper) {
+  struct kissat *solver = sweeper->solver;
+  const unsigned max_rounds = GET_OPTION (sweepfliprounds);
+  if (!max_rounds)
+    return;
+  KISSAT_assert (!EMPTY_STACK (sweeper->partition));
+  struct kitten *kitten = solver->kitten;
+  if (kitten_status (kitten) != 10)
+    return;
+#ifdef LOGGING
+  unsigned total_flipped = 0;
+#endif
+  unsigned flipped, round = 0;
+  do {
+    round++;
+    flipped = 0;
+    unsigned *begin = BEGIN_STACK (sweeper->partition), *dst = begin;
+    const unsigned *const end = END_STACK (sweeper->partition), *src = dst;
+    while (src != end) {
+      const unsigned *end_src = src;
+      while (KISSAT_assert (end_src != end), *end_src != INVALID_LIT)
+        end_src++;
+      unsigned size = end_src - src;
+      KISSAT_assert (size > 1);
+      unsigned *q = dst;
+      for (const unsigned *p = src; p != end_src; p++) {
+        const unsigned lit = *p;
+        if (kitten_flip_literal (kitten, lit)) {
+          LOG ("flipping equivalence candidate %s succeeded", LOGLIT (lit));
+#ifdef LOGGING
+          total_flipped++;
+#endif
+          flipped++;
+          if (--size < 2)
+            break;
+        } else {
+          LOG ("flipping equivalence candidate %s failed", LOGLIT (lit));
+          *q++ = lit;
+        }
+      }
+      if (size > 1) {
+        *q++ = INVALID_LIT;
+        dst = q;
+      }
+      src = end_src + 1;
+    }
+    SET_END_OF_STACK (sweeper->partition, dst);
+    LOG ("flipped %u equivalence candidates in round %u", flipped, round);
+
+    if (TERMINATED (sweep_terminated_2))
+      break;
+    if (solver->statistics_.kitten_ticks > sweeper->limit.ticks)
+      break;
+  } while (flipped && round < max_rounds);
+  LOG ("flipped %u equivalence candidates in total in %u rounds",
+       total_flipped, round);
+}
+
+static bool sweep_equivalence_candidates (sweeper *sweeper, unsigned lit,
+                                          unsigned other) {
+  kissat *solver = sweeper->solver;
+  LOG ("trying equivalence candidates %s = %s", LOGLIT (lit),
+       LOGLIT (other));
+  const unsigned not_other = NOT (other);
+  const unsigned not_lit = NOT (lit);
+  kitten *kitten = solver->kitten;
+  const unsigned *const begin = BEGIN_STACK (sweeper->partition);
+  unsigned *const end = END_STACK (sweeper->partition);
+  KISSAT_assert (begin + 3 <= end);
+  KISSAT_assert (end[-3] == lit);
+  KISSAT_assert (end[-2] == other);
+  const unsigned third = (end - begin == 3) ? INVALID_LIT : end[-4];
+  const int status = kitten_status (kitten);
+  if (status == 10 && kitten_flip_literal (kitten, lit)) {
+    INC (sweep_flip_equivalences);
+    INC (sweep_flipped_equivalences);
+    LOG ("flipping %s succeeded", LOGLIT (lit));
+    if (third == INVALID_LIT) {
+      LOG ("squashing equivalence class of %s", LOGLIT (lit));
+      SET_END_OF_STACK (sweeper->partition, end - 3);
+    } else {
+      LOG ("removing %s from equivalence class of %s", LOGLIT (lit),
+           LOGLIT (other));
+      end[-3] = other;
+      end[-2] = INVALID_LIT;
+      SET_END_OF_STACK (sweeper->partition, end - 1);
+    }
+    LOGPARTITION ("refined equivalence candidates");
+    return false;
+  } else if (status == 10 && kitten_flip_literal (kitten, other)) {
+    ADD (sweep_flip_equivalences, 2);
+    INC (sweep_flipped_equivalences);
+    LOG ("flipping %s succeeded", LOGLIT (other));
+    if (third == INVALID_LIT) {
+      LOG ("squashing equivalence class of %s", LOGLIT (lit));
+      SET_END_OF_STACK (sweeper->partition, end - 3);
+    } else {
+      LOG ("removing %s from equivalence class of %s", LOGLIT (other),
+           LOGLIT (lit));
+      end[-2] = INVALID_LIT;
+      SET_END_OF_STACK (sweeper->partition, end - 1);
+    }
+    LOGPARTITION ("refined equivalence candidates");
+    return false;
+  }
+  if (status == 10)
+    ADD (sweep_flip_equivalences, 2);
+  LOG ("flipping %s and %s both failed", LOGLIT (lit), LOGLIT (other));
+  kitten_assume (kitten, not_lit);
+  kitten_assume (kitten, other);
+  INC (sweep_solved_equivalences);
+  int res = sweep_solve (sweeper);
+  if (res == 10) {
+    INC (sweep_sat_equivalences);
+    LOG ("first sweeping implication %s -> %s failed", LOGLIT (other),
+         LOGLIT (lit));
+    sweep_refine (sweeper);
+  } else if (!res) {
+    INC (sweep_unknown_equivalences);
+    LOG ("first sweeping implication %s -> %s hit ticks limit",
+         LOGLIT (other), LOGLIT (lit));
+  }
+
+  if (res != 20)
+    return false;
+
+  INC (sweep_unsat_equivalences);
+  LOG ("first sweeping implication %s -> %s succeeded", LOGLIT (other),
+       LOGLIT (lit));
+
+  save_core (sweeper, 0);
+
+  kitten_assume (kitten, lit);
+  kitten_assume (kitten, not_other);
+  res = sweep_solve (sweeper);
+  INC (sweep_solved_equivalences);
+  if (res == 10) {
+    INC (sweep_sat_equivalences);
+    LOG ("second sweeping implication %s <- %s failed", LOGLIT (other),
+         LOGLIT (lit));
+    sweep_refine (sweeper);
+  } else if (!res) {
+    INC (sweep_unknown_equivalences);
+    LOG ("second sweeping implication %s <- %s hit ticks limit",
+         LOGLIT (other), LOGLIT (lit));
+  }
+
+  if (res != 20) {
+    CLEAR_STACK (sweeper->core[0]);
+    return false;
+  }
+
+  INC (sweep_unsat_equivalences);
+  LOG ("second sweeping implication %s <- %s succeeded too", LOGLIT (other),
+       LOGLIT (lit));
+
+  save_core (sweeper, 1);
+
+  LOG ("sweep equivalence %s = %s", LOGLIT (lit), LOGLIT (other));
+  INC (sweep_equivalences);
+
+  add_core (sweeper, 0);
+  add_binary (solver, lit, not_other);
+  clear_core (sweeper, 0);
+
+  add_core (sweeper, 1);
+  add_binary (solver, not_lit, other);
+  clear_core (sweeper, 1);
+
+  unsigned repr;
+  if (lit < other) {
+    repr = sweeper->reprs[other] = lit;
+    sweeper->reprs[not_other] = not_lit;
+    substitute_connected_clauses (sweeper, other, lit);
+    substitute_connected_clauses (sweeper, not_other, not_lit);
+    sweep_remove (sweeper, other);
+  } else {
+    repr = sweeper->reprs[lit] = other;
+    sweeper->reprs[not_lit] = not_other;
+    substitute_connected_clauses (sweeper, lit, other);
+    substitute_connected_clauses (sweeper, not_lit, not_other);
+    sweep_remove (sweeper, lit);
+  }
+
+  const unsigned repr_idx = IDX (repr);
+  schedule_inner (sweeper, repr_idx);
+
+  return true;
+}
+
+static const char *sweep_variable (sweeper *sweeper, unsigned idx) {
+  kissat *solver = sweeper->solver;
+  KISSAT_assert (!solver->inconsistent);
+  if (!ACTIVE (idx))
+    return "inactive variable";
+  const unsigned start = LIT (idx);
+  if (sweeper->reprs[start] != start)
+    return "non-representative variable";
+  KISSAT_assert (EMPTY_STACK (sweeper->vars));
+  KISSAT_assert (EMPTY_STACK (sweeper->refs));
+  KISSAT_assert (EMPTY_STACK (sweeper->backbone));
+  KISSAT_assert (EMPTY_STACK (sweeper->partition));
+  KISSAT_assert (!sweeper->encoded);
+
+  INC (sweep_variables);
+
+  LOG ("sweeping %s", LOGVAR (idx));
+  KISSAT_assert (!VALUE (start));
+  LOG ("starting sweeping[0]");
+  add_literal_to_environment (sweeper, 0, start);
+  LOG ("finished sweeping[0]");
+  LOG ("starting sweeping[1]");
+
+  bool limit_reached = false;
+  size_t expand = 0, next = 1;
+  bool success = false;
+  unsigned depth = 1;
+
+  while (!limit_reached) {
+    if (sweeper->encoded >= sweeper->limit.clauses) {
+      LOG ("environment clause limit reached");
+      limit_reached = true;
+      break;
+    }
+    if (expand == next) {
+      LOG ("finished sweeping[%u]", depth);
+      if (depth >= sweeper->limit.depth) {
+        LOG ("environment depth limit reached");
+        break;
+      }
+      next = SIZE_STACK (sweeper->vars);
+      if (expand == next) {
+        LOG ("completely copied all clauses");
+        break;
+      }
+      depth++;
+      LOG ("starting sweeping[%u]", depth);
+    }
+    const unsigned choices = next - expand;
+    if (GET_OPTION (sweeprand) && choices > 1) {
+      const unsigned swap =
+          kissat_pick_random (&solver->random, 0, choices);
+      if (swap) {
+        unsigned *vars = sweeper->vars.begin;
+        SWAP (unsigned, vars[expand], vars[expand + swap]);
+      }
+    }
+    const unsigned idx = PEEK_STACK (sweeper->vars, expand);
+    LOG ("traversing and adding clauses of %s", LOGVAR (idx));
+    for (unsigned sign = 0; sign < 2; sign++) {
+      const unsigned lit = LIT (idx) + sign;
+      watches *watches = &WATCHES (lit);
+      for (all_binary_large_watches (watch, *watches)) {
+        if (watch.type.binary) {
+          const unsigned other = watch.binary.lit;
+          sweep_binary (sweeper, depth, lit, other);
+        } else {
+          reference ref = watch.large.ref;
+          sweep_reference (sweeper, depth, ref);
+        }
+        if (SIZE_STACK (sweeper->vars) >= sweeper->limit.vars) {
+          LOG ("environment variable limit reached");
+          limit_reached = true;
+          break;
+        }
+      }
+      if (limit_reached)
+        break;
+    }
+    expand++;
+  }
+  ADD (sweep_depth, depth);
+  ADD (sweep_clauses, sweeper->encoded);
+  ADD (sweep_environment, SIZE_STACK (sweeper->vars));
+  kissat_extremely_verbose (solver,
+                            "sweeping variable %d environment of "
+                            "%zu variables %u clauses depth %u",
+                            kissat_export_literal (solver, LIT (idx)),
+                            SIZE_STACK (sweeper->vars), sweeper->encoded,
+                            depth);
+  int res = sweep_solve (sweeper);
+  LOG ("sub-solver returns '%d'", res);
+  if (res == 10) {
+    init_backbone_and_partition (sweeper);
+#ifndef KISSAT_QUIET
+    uint64_t units = solver->statistics_.sweep_units;
+    uint64_t solved = solver->statistics_.sweep_solved;
+#endif
+    START (sweepbackbone);
+    while (!EMPTY_STACK (sweeper->backbone)) {
+      if (solver->inconsistent || TERMINATED (sweep_terminated_3) ||
+          kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
+        limit_reached = true;
+      STOP_SWEEP_BACKBONE:
+        STOP (sweepbackbone);
+        goto DONE;
+      }
+      flip_backbone_literals (sweeper);
+      if (TERMINATED (sweep_terminated_4) ||
+          kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
+        limit_reached = true;
+        goto STOP_SWEEP_BACKBONE;
+      }
+      if (EMPTY_STACK (sweeper->backbone))
+        break;
+      const unsigned lit = POP_STACK (sweeper->backbone);
+      if (!ACTIVE (IDX (lit)))
+        continue;
+      if (sweep_backbone_candidate (sweeper, lit))
+        success = true;
+    }
+    STOP (sweepbackbone);
+#ifndef KISSAT_QUIET
+    units = solver->statistics_.sweep_units - units;
+    solved = solver->statistics_.sweep_solved - solved;
+    kissat_extremely_verbose (
+        solver,
+        "complete swept variable %d backbone with %" PRIu64
+        " units in %" PRIu64 " solver calls",
+        kissat_export_literal (solver, LIT (idx)), units, solved);
+#endif
+    KISSAT_assert (EMPTY_STACK (sweeper->backbone));
+#ifndef KISSAT_QUIET
+    uint64_t equivalences = solver->statistics_.sweep_equivalences;
+    solved = solver->statistics_.sweep_solved;
+#endif
+    START (sweepequivalences);
+    while (!EMPTY_STACK (sweeper->partition)) {
+      if (solver->inconsistent || TERMINATED (sweep_terminated_5) ||
+          kitten_ticks_limit_hit (sweeper, "partition refinement")) {
+        limit_reached = true;
+      STOP_SWEEP_EQUIVALENCES:
+        STOP (sweepequivalences);
+        goto DONE;
+      }
+      flip_partition_literals (sweeper);
+      if (TERMINATED (sweep_terminated_6) ||
+          kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
+        limit_reached = true;
+        goto STOP_SWEEP_EQUIVALENCES;
+      }
+      if (EMPTY_STACK (sweeper->partition))
+        break;
+      if (SIZE_STACK (sweeper->partition) > 2) {
+        const unsigned *end = END_STACK (sweeper->partition);
+        KISSAT_assert (end[-1] == INVALID_LIT);
+        unsigned lit = end[-3];
+        unsigned other = end[-2];
+        if (sweep_equivalence_candidates (sweeper, lit, other))
+          success = true;
+      } else
+        CLEAR_STACK (sweeper->partition);
+    }
+    STOP (sweepequivalences);
+#ifndef KISSAT_QUIET
+    equivalences = solver->statistics_.sweep_equivalences - equivalences;
+    solved = solver->statistics_.sweep_solved - solved;
+    if (equivalences)
+      kissat_extremely_verbose (
+          solver,
+          "complete swept variable %d partition with %" PRIu64
+          " equivalences in %" PRIu64 " solver calls",
+          kissat_export_literal (solver, LIT (idx)), equivalences, solved);
+#endif
+  } else if (res == 20)
+    sweep_empty_clause (sweeper);
+
+DONE:
+  clear_sweeper (sweeper);
+
+  if (!solver->inconsistent && !kissat_propagated (solver))
+    (void) kissat_dense_propagate (solver);
+
+  if (success && limit_reached)
+    return "successfully despite reaching limit";
+  if (!success && !limit_reached)
+    return "unsuccessfully without reaching limit";
+  else if (success && !limit_reached)
+    return "successfully without reaching limit";
+  KISSAT_assert (!success && limit_reached);
+  return "unsuccessfully and reached limit";
+}
+
+typedef struct sweep_candidate sweep_candidate;
+
+struct sweep_candidate {
+  unsigned rank;
+  unsigned idx;
+};
+
+// clang-format off
+
+typedef STACK(sweep_candidate) sweep_candidates;
+
+// clang-format on
+
+#define RANK_SWEEP_CANDIDATE(CAND) (CAND).rank
+
+static bool scheduable_variable (sweeper *sweeper, unsigned idx,
+                                 size_t *occ_ptr) {
+  kissat *solver = sweeper->solver;
+  const unsigned lit = LIT (idx);
+  const size_t pos = SIZE_WATCHES (WATCHES (lit));
+  if (!pos)
+    return false;
+  const unsigned max_occurrences = sweeper->limit.clauses;
+  if (pos > max_occurrences)
+    return false;
+  const unsigned not_lit = NOT (lit);
+  const size_t neg = SIZE_WATCHES (WATCHES (not_lit));
+  if (!neg)
+    return false;
+  if (neg > max_occurrences)
+    return false;
+  *occ_ptr = pos + neg;
+  return true;
+}
+
+static unsigned schedule_all_other_not_scheduled_yet (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  sweep_candidates fresh;
+  INIT_STACK (fresh);
+  flags *const flags = solver->flags;
+  const bool incomplete = solver->sweep_incomplete;
+  for (all_variables (idx)) {
+    struct flags *const f = flags + idx;
+    if (!f->active)
+      continue;
+    if (incomplete && !f->sweep)
+      continue;
+    if (scheduled_variable (sweeper, idx))
+      continue;
+    size_t occ;
+    if (!scheduable_variable (sweeper, idx, &occ)) {
+      FLAGS (idx)->sweep = false;
+      continue;
+    }
+    sweep_candidate cand;
+    cand.rank = occ;
+    cand.idx = idx;
+    PUSH_STACK (fresh, cand);
+  }
+  const size_t size = SIZE_STACK (fresh);
+  KISSAT_assert (size <= UINT_MAX);
+  RADIX_STACK (sweep_candidate, unsigned, fresh, RANK_SWEEP_CANDIDATE);
+  for (all_stack (sweep_candidate, cand, fresh))
+    schedule_outer (sweeper, cand.idx);
+  RELEASE_STACK (fresh);
+  return size;
+}
+
+static unsigned reschedule_previously_remaining (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  flags *flags = solver->flags;
+  unsigned rescheduled = 0;
+  unsigneds *remaining = &solver->sweep_schedule;
+  for (all_stack (unsigned, idx, *remaining)) {
+    struct flags *f = flags + idx;
+    if (!f->active)
+      continue;
+    if (scheduled_variable (sweeper, idx))
+      continue;
+    size_t occ;
+    if (!scheduable_variable (sweeper, idx, &occ)) {
+      f->sweep = false;
+      continue;
+    }
+    schedule_inner (sweeper, idx);
+    rescheduled++;
+  }
+  RELEASE_STACK (*remaining);
+  return rescheduled;
+}
+
+static unsigned incomplete_variables (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  flags *flags = solver->flags;
+  unsigned res = 0;
+  for (all_variables (idx)) {
+    struct flags *f = flags + idx;
+    if (!f->active)
+      continue;
+    if (f->sweep)
+      res++;
+  }
+  return res;
+}
+
+static void mark_incomplete (sweeper *sweeper) {
+  kissat *solver = sweeper->solver;
+  flags *flags = solver->flags;
+  unsigned marked = 0;
+  for (all_scheduled (idx))
+    if (!flags[idx].sweep) {
+      flags[idx].sweep = true;
+      marked++;
+    }
+  solver->sweep_incomplete = true;
+#ifndef KISSAT_QUIET
+  kissat_extremely_verbose (
+      solver, "marked %u scheduled sweeping variables as incomplete",
+      marked);
+#else
+  (void) marked;
+#endif
+}
+
+static unsigned schedule_sweeping (sweeper *sweeper) {
+  const unsigned rescheduled = reschedule_previously_remaining (sweeper);
+  const unsigned fresh = schedule_all_other_not_scheduled_yet (sweeper);
+  const unsigned scheduled = fresh + rescheduled;
+  const unsigned incomplete = incomplete_variables (sweeper);
+  kissat *solver = sweeper->solver;
+#ifndef KISSAT_QUIET
+  kissat_phase (solver, "sweep", GET (sweep),
+                "scheduled %u variables %.0f%% "
+                "(%u rescheduled %.0f%%, %u incomplete %.0f%%)",
+                scheduled,
+                kissat_percent (scheduled, sweeper->solver->active),
+                rescheduled, kissat_percent (rescheduled, scheduled),
+                incomplete, kissat_percent (incomplete, scheduled));
+#endif
+  if (incomplete)
+    KISSAT_assert (solver->sweep_incomplete);
+  else {
+    if (solver->sweep_incomplete)
+      INC (sweep_completed);
+    mark_incomplete (sweeper);
+  }
+  return scheduled;
+}
+
+static void unschedule_sweeping (sweeper *sweeper, unsigned swept,
+                                 unsigned scheduled) {
+  kissat *solver = sweeper->solver;
+#ifdef KISSAT_QUIET
+  (void) scheduled, (void) swept;
+#endif
+  KISSAT_assert (EMPTY_STACK (solver->sweep_schedule));
+  KISSAT_assert (solver->sweep_incomplete);
+  flags *flags = solver->flags;
+  for (all_scheduled (idx))
+    if (flags[idx].active) {
+      PUSH_STACK (solver->sweep_schedule, idx);
+      LOG ("untried scheduled %s", LOGVAR (idx));
+    }
+#ifndef KISSAT_QUIET
+  const unsigned retained = SIZE_STACK (solver->sweep_schedule);
+  kissat_extremely_verbose (
+      solver, "retained %u variables %.0f%% to be swept next time",
+      retained, kissat_percent (retained, solver->active));
+#endif
+  const unsigned incomplete = incomplete_variables (sweeper);
+  if (incomplete)
+    kissat_extremely_verbose (
+        solver, "need to sweep %u more variables %.0f%% for completion",
+        incomplete, kissat_percent (incomplete, solver->active));
+  else {
+    kissat_extremely_verbose (solver,
+                              "no more variables needed to complete sweep");
+    solver->sweep_incomplete = false;
+    INC (sweep_completed);
+  }
+  kissat_phase (solver, "sweep", GET (sweep),
+                "swept %u variables (%u remain %.0f%%)", swept, incomplete,
+                kissat_percent (incomplete, scheduled));
+}
+
+bool kissat_sweep (kissat *solver) {
+  if (!GET_OPTION (sweep))
+    return false;
+  if (solver->inconsistent)
+    return false;
+  if (TERMINATED (sweep_terminated_7))
+    return false;
+  if (DELAYING (sweep))
+    return false;
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->unflushed);
+  START (sweep);
+  INC (sweep);
+  statistics *statistics = &solver->statistics_;
+  uint64_t equivalences = statistics->sweep_equivalences;
+  uint64_t units = statistics->sweep_units;
+  sweeper sweeper;
+  init_sweeper (solver, &sweeper);
+  const unsigned scheduled = schedule_sweeping (&sweeper);
+  uint64_t swept = 0, limit = 10;
+  for (;;) {
+    if (solver->inconsistent)
+      break;
+    if (TERMINATED (sweep_terminated_8))
+      break;
+    if (solver->statistics_.kitten_ticks > sweeper.limit.ticks)
+      break;
+    unsigned idx = next_scheduled (&sweeper);
+    if (idx == INVALID_IDX)
+      break;
+    FLAGS (idx)->sweep = false;
+#ifndef KISSAT_QUIET
+    const char *res =
+#endif
+        sweep_variable (&sweeper, idx);
+    kissat_extremely_verbose (
+        solver, "swept[%" PRIu64 "] external variable %d %s", swept,
+        kissat_export_literal (solver, LIT (idx)), res);
+    if (++swept == limit) {
+      kissat_very_verbose (solver,
+                           "found %" PRIu64 " equivalences and %" PRIu64
+                           " units after sweeping %" PRIu64 " variables ",
+                           statistics->sweep_equivalences - equivalences,
+                           solver->statistics_.sweep_units - units, swept);
+      limit *= 10;
+    }
+  }
+  kissat_very_verbose (solver, "swept %" PRIu64 " variables", swept);
+  equivalences = statistics->sweep_equivalences - equivalences,
+  units = solver->statistics_.sweep_units - units;
+  kissat_phase (solver, "sweep", GET (sweep),
+                "found %" PRIu64 " equivalences and %" PRIu64 " units",
+                equivalences, units);
+  unschedule_sweeping (&sweeper, swept, scheduled);
+  unsigned inactive = release_sweeper (&sweeper);
+
+  if (!solver->inconsistent) {
+    solver->propagate = solver->trail.begin;
+    kissat_probing_propagate (solver, 0, true);
+  }
+
+  uint64_t eliminated = equivalences + units;
+#ifndef KISSAT_QUIET
+  KISSAT_assert (solver->active >= inactive);
+  solver->active -= inactive;
+  REPORT (!eliminated, '=');
+  solver->active += inactive;
+#else
+  (void) inactive;
+#endif
+  if (kissat_average (eliminated, swept) < 0.001)
+    BUMP_DELAY (sweep);
+  else
+    REDUCE_DELAY (sweep);
+  STOP (sweep);
+  return eliminated;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/sweep.h b/src/sat/kissat/sweep.h
new file mode 100644
index 000000000..995c61c79
--- /dev/null
+++ b/src/sat/kissat/sweep.h
@@ -0,0 +1,14 @@
+#ifndef _sweep_h_INCLUDED
+#define _sweep_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+bool kissat_sweep (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/terminate.c b/src/sat/kissat/terminate.c
new file mode 100644
index 000000000..25b91a866
--- /dev/null
+++ b/src/sat/kissat/terminate.c
@@ -0,0 +1,19 @@
+#include "terminate.h"
+#include "print.h"
+
+ABC_NAMESPACE_IMPL_START
+
+#ifndef KISSAT_QUIET
+
+void kissat_report_termination (kissat *solver, const char *name,
+                                const char *file, long lineno,
+                                const char *fun) {
+  kissat_very_verbose (solver, "%s:%ld: %s: 'TERMINATED (%s)' triggered",
+                       file, lineno, fun, name);
+}
+
+#else
+int kissat_terminate_dummy_to_avoid_warning;
+#endif
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/terminate.h b/src/sat/kissat/terminate.h
new file mode 100644
index 000000000..853adecd1
--- /dev/null
+++ b/src/sat/kissat/terminate.h
@@ -0,0 +1,91 @@
+#ifndef _terminate_h_INCLUDED
+#define _terminate_h_INCLUDED
+
+#include "internal.h"
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifndef KISSAT_QUIET
+void kissat_report_termination (kissat *, const char *name,
+                                const char *file, long lineno,
+                                const char *fun);
+#endif
+
+static inline bool kissat_terminated (kissat *solver, int bit,
+                                      const char *name, const char *file,
+                                      long lineno, const char *fun) {
+  KISSAT_assert (0 <= bit), KISSAT_assert (bit < 64);
+#ifdef COVERAGE
+  const uint64_t mask = (uint64_t) 1 << bit;
+  if (!(solver->termination.flagged & mask))
+    return false;
+  solver->termination.flagged = ~(uint64_t) 0;
+#else
+  if (!solver->termination.flagged)
+    return false;
+#endif
+#ifndef KISSAT_QUIET
+  kissat_report_termination (solver, name, file, lineno, fun);
+#else
+  (void) file;
+  (void) fun;
+  (void) lineno;
+  (void) name;
+#endif
+#if !defined(COVERAGE) && defined(KISSAT_NDEBUG)
+  (void) bit;
+#endif
+  return true;
+}
+
+#define TERMINATED(BIT) \
+  kissat_terminated (solver, BIT, #BIT, __FILE__, __LINE__, __func__)
+
+#define backbone_terminated_1 1
+#define backbone_terminated_2 2
+#define backbone_terminated_3 3
+#define congruence_terminated_1 4
+#define congruence_terminated_2 5
+#define congruence_terminated_3 6
+#define congruence_terminated_4 7
+#define congruence_terminated_5 8
+#define congruence_terminated_6 9
+#define congruence_terminated_7 10
+#define congruence_terminated_8 11
+#define congruence_terminated_9 12
+#define congruence_terminated_10 13
+#define congruence_terminated_11 14
+#define congruence_terminated_12 15
+#define eliminate_terminated_1 16
+#define eliminate_terminated_2 17
+#define factor_terminated_1 18
+#define fastel_terminated_1 19
+#define forward_terminated_1 20
+#define kitten_terminated_1 21
+#define kitten_terminated_2 22
+#define preprocess_terminated_1 23
+#define search_terminated_1 24
+#define substitute_terminated_1 25
+#define sweep_terminated_1 26
+#define sweep_terminated_2 27
+#define sweep_terminated_3 28
+#define sweep_terminated_4 29
+#define sweep_terminated_5 30
+#define sweep_terminated_6 31
+#define sweep_terminated_7 32
+#define sweep_terminated_8 33
+#define transitive_terminated_1 34
+#define transitive_terminated_2 35
+#define transitive_terminated_3 36
+#define vivify_terminated_1 37
+#define vivify_terminated_2 38
+#define vivify_terminated_3 39
+#define vivify_terminated_4 40
+#define vivify_terminated_5 41
+#define walk_terminated_1 42
+#define warmup_terminated_1 43
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/tiers.c b/src/sat/kissat/tiers.c
new file mode 100644
index 000000000..3f044d746
--- /dev/null
+++ b/src/sat/kissat/tiers.c
@@ -0,0 +1,165 @@
+#include "tiers.h"
+#include "internal.h"
+#include "logging.h"
+#include "print.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static void compute_tier_limits (kissat *solver, bool stable,
+                                 unsigned *tier1_ptr, unsigned *tier2_ptr) {
+  statistics *statistics = &solver->statistics_;
+  uint64_t *used_stats = statistics->used[stable].glue;
+  uint64_t total_used = 0;
+  for (unsigned glue = 0; glue <= MAX_GLUE_USED; glue++)
+    total_used += used_stats[glue];
+  int tier1 = -1, tier2 = -1;
+  if (total_used) {
+    uint64_t accumulated_tier1_limit = total_used * TIER1RELATIVE;
+    uint64_t accumulated_tier2_limit = total_used * TIER2RELATIVE;
+    uint64_t accumulated_used = 0;
+    unsigned glue;
+    for (glue = 0; glue <= MAX_GLUE_USED; glue++) {
+      uint64_t glue_used = used_stats[glue];
+      accumulated_used += glue_used;
+      if (accumulated_used >= accumulated_tier1_limit) {
+        tier1 = glue;
+        break;
+      }
+    }
+    if (accumulated_used < accumulated_tier2_limit) {
+      for (glue = tier1 + 1; glue <= MAX_GLUE_USED; glue++) {
+        uint64_t glue_used = used_stats[glue];
+        accumulated_used += glue_used;
+        if (accumulated_used >= accumulated_tier2_limit) {
+          tier2 = glue;
+          break;
+        }
+      }
+    }
+  }
+  if (tier1 < 0) {
+    tier1 = GET_OPTION (tier1);
+    tier2 = MAX (GET_OPTION (tier2), tier1);
+  } else if (tier2 < 0)
+    tier2 = tier1;
+  KISSAT_assert (0 <= tier1);
+  KISSAT_assert (0 <= tier2);
+  *tier1_ptr = tier1;
+  *tier2_ptr = tier2;
+  LOG ("%s tier1 limit %u", stable ? "stable" : "focused", tier1);
+  LOG ("%s tier2 limit %u", stable ? "stable" : "focused", tier2);
+}
+
+void kissat_compute_and_set_tier_limits (struct kissat *solver) {
+  bool stable = solver->stable;
+  unsigned tier1, tier2;
+  compute_tier_limits (solver, stable, &tier1, &tier2);
+  solver->tier1[stable] = tier1;
+  solver->tier2[stable] = tier2;
+  kissat_phase (solver, "retiered", GET (retiered),
+                "recomputed %s tier1 limit %u and tier2 limit %u "
+                "after %" PRIu64 " conflicts",
+                stable ? "stable" : "focused", tier1, tier2, CONFLICTS);
+}
+
+static unsigned decimal_digits (uint64_t i) {
+  unsigned res = 1;
+  uint64_t limit = 10;
+  for (;;) {
+    if (i < limit)
+      return res;
+    limit *= 10;
+    res++;
+  }
+}
+
+void kissat_print_tier_usage_statistics (kissat *solver, bool stable) {
+  unsigned tier1, tier2;
+  compute_tier_limits (solver, stable, &tier1, &tier2);
+  statistics *statistics = &solver->statistics_;
+  uint64_t *used_stats = statistics->used[stable].glue;
+  uint64_t total_used = 0;
+  for (unsigned glue = 0; glue <= MAX_GLUE_USED; glue++)
+    total_used += used_stats[glue];
+  const char *mode = stable ? "stable" : "focused";
+  KISSAT_assert (tier1 <= tier2);
+  unsigned span = tier2 - tier1 + 1;
+  const unsigned max_printed = 5;
+  KISSAT_assert (max_printed & 1), KISSAT_assert (max_printed / 2 > 0);
+  unsigned prefix, suffix;
+  if (span > max_printed) {
+    prefix = tier1 + max_printed / 2 - 1;
+    suffix = tier2 - max_printed / 2 + 1;
+  } else
+    prefix = UINT_MAX, suffix = 0;
+  uint64_t accumulated_middle = 0;
+  int glue_digits = 1, clauses_digits = 1;
+  for (unsigned glue = 0; glue <= MAX_GLUE_USED; glue++) {
+    if (glue < tier1)
+      continue;
+    uint64_t used = used_stats[glue];
+    int tmp_glue = 0, tmp_clauses = 0;
+    if (glue <= prefix || suffix <= glue) {
+      tmp_glue = decimal_digits (glue);
+      tmp_clauses = decimal_digits (used);
+    } else {
+      accumulated_middle += used;
+      if (glue + 1 == suffix) {
+        tmp_glue = decimal_digits (prefix + 1) + decimal_digits (glue) + 1;
+        tmp_clauses = decimal_digits (accumulated_middle);
+      }
+    }
+    if (tmp_glue > glue_digits)
+      glue_digits = tmp_glue;
+    if (tmp_clauses > clauses_digits)
+      clauses_digits = tmp_clauses;
+    if (glue == tier2)
+      break;
+  }
+  char fmt[32];
+  sprintf (fmt, "%%%d" PRIu64, clauses_digits);
+  accumulated_middle = 0;
+  uint64_t accumulated = 0;
+  for (unsigned glue = 0; glue <= MAX_GLUE_USED; glue++) {
+    uint64_t used = used_stats[glue];
+    accumulated += used;
+    if (glue < tier1)
+      continue;
+    if (glue <= prefix || suffix <= glue + 1) {
+      fputs (solver->prefix, stdout);
+      fputs (mode, stdout);
+      fputs (" glue ", stdout);
+    }
+    if (glue <= prefix || suffix <= glue) {
+      int len = printf ("%u", glue);
+      while (len > 0 && len < glue_digits)
+        fputc (' ', stdout), len++;
+      fputs (" used ", stdout);
+      printf (fmt, used);
+      printf (" clauses %5.2f%% accumulated %5.2f%%",
+              kissat_percent (used, total_used),
+              kissat_percent (accumulated, total_used));
+      if (glue == tier1)
+        fputs (" tier1", stdout);
+      if (glue == tier2)
+        fputs (" tier2", stdout);
+      fputc ('\n', stdout);
+    } else {
+      accumulated_middle += used;
+      if (glue + 1 == suffix) {
+        int len = printf ("%u-%u", prefix + 1, suffix - 1);
+        while (len > 0 && len < glue_digits)
+          fputc (' ', stdout), len++;
+        fputs (" used ", stdout);
+        printf (fmt, accumulated_middle);
+        printf (" clauses %5.2f%% accumulated %5.2f%%\n",
+                kissat_percent (accumulated_middle, total_used),
+                kissat_percent (accumulated, total_used));
+      }
+    }
+    if (glue == tier2)
+      break;
+  }
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/tiers.h b/src/sat/kissat/tiers.h
new file mode 100644
index 000000000..c706ccc62
--- /dev/null
+++ b/src/sat/kissat/tiers.h
@@ -0,0 +1,17 @@
+#ifndef _tiers_h_INCLUDED
+#define _tiers_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_compute_and_set_tier_limits (struct kissat *);
+void kissat_print_tier_usage_statistics (struct kissat *solver,
+                                         bool stable);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/trail.c b/src/sat/kissat/trail.c
new file mode 100644
index 000000000..256da6cfc
--- /dev/null
+++ b/src/sat/kissat/trail.c
@@ -0,0 +1,96 @@
+#include "trail.h"
+#include "backtrack.h"
+#include "inline.h"
+#include "propsearch.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_flush_trail (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (solver->unflushed);
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (kissat_propagated (solver));
+  KISSAT_assert (SIZE_ARRAY (solver->trail) == solver->unflushed);
+  LOG ("flushed %zu units from trail", SIZE_ARRAY (solver->trail));
+  CLEAR_ARRAY (solver->trail);
+  kissat_reset_propagate (solver);
+  solver->unflushed = 0;
+}
+
+void kissat_mark_reason_clauses (kissat *solver, reference start) {
+  LOG ("starting marking reason clauses at clause[%" REFERENCE_FORMAT "]",
+       start);
+  KISSAT_assert (!solver->unflushed);
+#ifdef LOGGING
+  unsigned reasons = 0;
+#endif
+  ward *arena = BEGIN_STACK (solver->arena);
+  for (all_stack (unsigned, lit, solver->trail)) {
+    assigned *a = ASSIGNED (lit);
+    KISSAT_assert (a->level > 0);
+    if (a->binary)
+      continue;
+    const reference ref = a->reason;
+    KISSAT_assert (ref != UNIT_REASON);
+    if (ref == DECISION_REASON)
+      continue;
+    if (ref < start)
+      continue;
+    clause *c = (clause *) (arena + ref);
+    KISSAT_assert (kissat_clause_in_arena (solver, c));
+    c->reason = true;
+#ifdef LOGGING
+    reasons++;
+#endif
+  }
+  LOG ("marked %u reason clauses", reasons);
+}
+
+bool kissat_flush_and_mark_reason_clauses (kissat *solver,
+                                           reference start) {
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (kissat_propagated (solver));
+
+  if (solver->unflushed) {
+    LOG ("need to flush %u units from trail", solver->unflushed);
+    kissat_backtrack_propagate_and_flush_trail (solver);
+  } else {
+    LOG ("no need to flush units from trail (all units already flushed)");
+    kissat_mark_reason_clauses (solver, start);
+  }
+
+  return true;
+}
+
+void kissat_unmark_reason_clauses (kissat *solver, reference start) {
+  LOG ("starting unmarking reason clauses at clause[%" REFERENCE_FORMAT "]",
+       start);
+  KISSAT_assert (!solver->unflushed);
+#ifdef LOGGING
+  unsigned reasons = 0;
+#endif
+  ward *arena = BEGIN_STACK (solver->arena);
+  for (all_stack (unsigned, lit, solver->trail)) {
+    assigned *a = ASSIGNED (lit);
+    KISSAT_assert (a->level > 0);
+    if (a->binary)
+      continue;
+    const reference ref = a->reason;
+    KISSAT_assert (ref != UNIT_REASON);
+    if (ref == DECISION_REASON)
+      continue;
+    if (ref < start)
+      continue;
+    clause *c = (clause *) (arena + ref);
+    KISSAT_assert (kissat_clause_in_arena (solver, c));
+    KISSAT_assert (c->reason);
+    c->reason = false;
+#ifdef LOGGING
+    reasons++;
+#endif
+  }
+  LOG ("unmarked %u reason clauses", reasons);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/trail.h b/src/sat/kissat/trail.h
new file mode 100644
index 000000000..8dcd3c57e
--- /dev/null
+++ b/src/sat/kissat/trail.h
@@ -0,0 +1,21 @@
+#ifndef _trail_h_INLCUDED
+#define _trail_h_INLCUDED
+
+#include "reference.h"
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_flush_trail (struct kissat *);
+bool kissat_flush_and_mark_reason_clauses (struct kissat *,
+                                           reference start);
+void kissat_unmark_reason_clauses (struct kissat *, reference start);
+void kissat_mark_reason_clauses (struct kissat *, reference start);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/transitive.c b/src/sat/kissat/transitive.c
new file mode 100644
index 000000000..3aa58e24e
--- /dev/null
+++ b/src/sat/kissat/transitive.c
@@ -0,0 +1,393 @@
+#include "transitive.h"
+#include "allocate.h"
+#include "analyze.h"
+#include "heap.h"
+#include "inline.h"
+#include "inlinevector.h"
+#include "logging.h"
+#include "print.h"
+#include "proprobe.h"
+#include "report.h"
+#include "sort.h"
+#include "terminate.h"
+#include "trail.h"
+
+#include <stddef.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static void transitive_assign (kissat *solver, unsigned lit) {
+  LOG ("transitive assign %s", LOGLIT (lit));
+  value *values = solver->values;
+  const unsigned not_lit = NOT (lit);
+  KISSAT_assert (!values[lit]);
+  KISSAT_assert (!values[not_lit]);
+  values[lit] = 1;
+  values[not_lit] = -1;
+  PUSH_ARRAY (solver->trail, lit);
+}
+
+static void transitive_backtrack (kissat *solver, unsigned *saved) {
+  value *values = solver->values;
+
+  unsigned *end_trail = END_ARRAY (solver->trail);
+  KISSAT_assert (saved <= end_trail);
+
+  while (end_trail != saved) {
+    const unsigned lit = *--end_trail;
+    LOG ("transitive unassign %s", LOGLIT (lit));
+    const unsigned not_lit = NOT (lit);
+    KISSAT_assert (values[lit] > 0);
+    KISSAT_assert (values[not_lit] < 0);
+    values[lit] = values[not_lit] = 0;
+  }
+
+  SET_END_OF_ARRAY (solver->trail, saved);
+  solver->propagate = saved;
+  solver->level = 0;
+}
+
+static void prioritize_binaries (kissat *solver) {
+  KISSAT_assert (solver->watching);
+  statches large;
+  INIT_STACK (large);
+  watches *all_watches = solver->watches;
+  for (all_literals (lit)) {
+    KISSAT_assert (EMPTY_STACK (large));
+    watches *watches = all_watches + lit;
+    watch *begin_watches = BEGIN_WATCHES (*watches), *q = begin_watches;
+    const watch *const end_watches = END_WATCHES (*watches), *p = q;
+    while (p != end_watches) {
+      const watch head = *q++ = *p++;
+      if (head.type.binary)
+        continue;
+      const watch tail = *p++;
+      PUSH_STACK (large, head);
+      PUSH_STACK (large, tail);
+      q--;
+    }
+    const watch *const end_large = END_STACK (large);
+    watch const *r = BEGIN_STACK (large);
+    while (r != end_large)
+      *q++ = *r++;
+    KISSAT_assert (q == end_watches);
+    CLEAR_STACK (large);
+  }
+  RELEASE_STACK (large);
+}
+
+static bool transitive_reduce (kissat *solver, unsigned src, uint64_t limit,
+                               uint64_t *reduced_ptr, unsigned *units) {
+  bool res = false;
+  KISSAT_assert (!VALUE (src));
+  LOG ("transitive reduce %s", LOGLIT (src));
+  watches *all_watches = solver->watches;
+  watches *src_watches = all_watches + src;
+  watch *end_src = END_WATCHES (*src_watches);
+  watch *begin_src = BEGIN_WATCHES (*src_watches);
+  const size_t size_src_watches = SIZE_WATCHES (*src_watches);
+  const unsigned src_ticks =
+      1 + kissat_cache_lines (size_src_watches, sizeof (watch));
+  ADD (transitive_ticks, src_ticks);
+  ADD (probing_ticks, src_ticks);
+  ADD (ticks, src_ticks);
+  INC (transitive_probes);
+  const unsigned not_src = NOT (src);
+  unsigned reduced = 0;
+  bool failed = false;
+  for (watch *p = begin_src; p != end_src; p++) {
+    const watch src_watch = *p;
+    if (!src_watch.type.binary)
+      break;
+    const unsigned dst = src_watch.binary.lit;
+    if (dst < src)
+      continue;
+    if (VALUE (dst))
+      continue;
+    KISSAT_assert (kissat_propagated (solver));
+    unsigned *saved = solver->propagate;
+    KISSAT_assert (!solver->level);
+    solver->level = 1;
+    transitive_assign (solver, not_src);
+    bool transitive = false;
+    unsigned inner_ticks = 0;
+    unsigned *propagate = solver->propagate;
+    while (!transitive && !failed &&
+           propagate != END_ARRAY (solver->trail)) {
+      const unsigned lit = *propagate++;
+      LOG ("transitive propagate %s", LOGLIT (lit));
+      KISSAT_assert (VALUE (lit) > 0);
+      const unsigned not_lit = NOT (lit);
+      watches *lit_watches = all_watches + not_lit;
+      const watch *const end_lit = END_WATCHES (*lit_watches);
+      const watch *const begin_lit = BEGIN_WATCHES (*lit_watches);
+      const size_t size_lit_watches = SIZE_WATCHES (*lit_watches);
+      inner_ticks +=
+          1 + kissat_cache_lines (size_lit_watches, sizeof (watch));
+      for (const watch *q = begin_lit; q != end_lit; q++) {
+        if (p == q)
+          continue;
+        const watch lit_watch = *q;
+        if (!lit_watch.type.binary)
+          break;
+        if (not_lit == src && lit_watch.binary.lit == ILLEGAL_LIT)
+          continue;
+        const unsigned other = lit_watch.binary.lit;
+        if (other == dst) {
+          transitive = true;
+          break;
+        }
+        const value value = VALUE (other);
+        if (value < 0) {
+          LOG ("both %s and %s reachable from %s", LOGLIT (NOT (other)),
+               LOGLIT (other), LOGLIT (src));
+          failed = true;
+          break;
+        }
+        if (!value)
+          transitive_assign (solver, other);
+      }
+    }
+
+    KISSAT_assert (solver->probing);
+
+    KISSAT_assert (solver->propagate <= propagate);
+    const unsigned propagated = propagate - solver->propagate;
+
+    ADD (transitive_propagations, propagated);
+    ADD (probing_propagations, propagated);
+    ADD (propagations, propagated);
+
+    ADD (transitive_ticks, inner_ticks);
+    ADD (probing_ticks, inner_ticks);
+    ADD (ticks, inner_ticks);
+
+    transitive_backtrack (solver, saved);
+
+    if (transitive) {
+      LOGBINARY (src, dst, "transitive reduce");
+      INC (transitive_reduced);
+      watches *dst_watches = all_watches + dst;
+      watch dst_watch = src_watch;
+      KISSAT_assert (dst_watch.binary.lit == dst);
+      dst_watch.binary.lit = src;
+      REMOVE_WATCHES (*dst_watches, dst_watch);
+      kissat_delete_binary (solver, src, dst);
+      p->binary.lit = ILLEGAL_LIT;
+      reduced++;
+      res = true;
+    }
+
+    if (failed)
+      break;
+    if (solver->statistics_.transitive_ticks > limit)
+      break;
+    if (TERMINATED (transitive_terminated_1))
+      break;
+  }
+
+  if (reduced) {
+    *reduced_ptr += reduced;
+    KISSAT_assert (begin_src == BEGIN_WATCHES (WATCHES (src)));
+    KISSAT_assert (end_src == END_WATCHES (WATCHES (src)));
+    watch *q = begin_src;
+    for (const watch *p = begin_src; p != end_src; p++) {
+      const watch src_watch = *q++ = *p;
+      if (!src_watch.type.binary) {
+        *q++ = *++p;
+        continue;
+      }
+      if (src_watch.binary.lit == ILLEGAL_LIT)
+        q--;
+    }
+    KISSAT_assert (end_src - q == (ptrdiff_t) reduced);
+    SET_END_OF_WATCHES (*src_watches, q);
+  }
+
+  if (failed) {
+    LOG ("transitive failed literal %s", LOGLIT (not_src));
+    INC (transitive_units);
+    *units += 1;
+    res = true;
+
+    kissat_learned_unit (solver, src);
+
+    KISSAT_assert (!solver->level);
+    (void) kissat_probing_propagate (solver, 0, true);
+  }
+
+  return res;
+}
+
+static inline bool less_stable_transitive (kissat *solver,
+                                           const flags *const flags,
+                                           const heap *scores, unsigned a,
+                                           unsigned b) {
+#ifdef KISSAT_NDEBUG
+  (void) solver;
+#endif
+  const unsigned i = IDX (a);
+  const unsigned j = IDX (b);
+  const bool p = flags[i].transitive;
+  const bool q = flags[j].transitive;
+  if (!p && q)
+    return true;
+  if (p && !q)
+    return false;
+  const double s = kissat_get_heap_score (scores, i);
+  const double t = kissat_get_heap_score (scores, j);
+  if (s < t)
+    return true;
+  if (s > t)
+    return false;
+  return i < j;
+}
+
+static inline unsigned less_focused_transitive (kissat *solver,
+                                                const flags *const flags,
+                                                const links *links,
+                                                unsigned a, unsigned b) {
+#ifdef KISSAT_NDEBUG
+  (void) solver;
+#endif
+  const unsigned i = IDX (a);
+  const unsigned j = IDX (b);
+  const bool p = flags[i].transitive;
+  const bool q = flags[j].transitive;
+  if (!p && q)
+    return true;
+  if (p && !q)
+    return false;
+  const unsigned s = links[i].stamp;
+  const unsigned t = links[j].stamp;
+  return s < t;
+}
+
+#define LESS_STABLE_PROBE(A, B) \
+  less_stable_transitive (solver, flags, scores, (A), (B))
+
+#define LESS_FOCUSED_PROBE(A, B) \
+  less_focused_transitive (solver, flags, links, (A), (B))
+
+static void sort_stable_transitive (kissat *solver, unsigneds *probes) {
+  const flags *const flags = solver->flags;
+  const heap *const scores = SCORES;
+  SORT_STACK (unsigned, *probes, LESS_STABLE_PROBE);
+}
+
+static void sort_focused_transitive (kissat *solver, unsigneds *probes) {
+  const flags *const flags = solver->flags;
+  const links *const links = solver->links;
+  SORT_STACK (unsigned, *probes, LESS_FOCUSED_PROBE);
+}
+
+static void sort_transitive (kissat *solver, unsigneds *probes) {
+  if (solver->stable)
+    sort_stable_transitive (solver, probes);
+  else
+    sort_focused_transitive (solver, probes);
+}
+
+static void schedule_transitive (kissat *solver, unsigneds *probes) {
+  KISSAT_assert (EMPTY_STACK (*probes));
+  for (all_variables (idx))
+    if (ACTIVE (idx))
+      PUSH_STACK (*probes, idx);
+  sort_transitive (solver, probes);
+  kissat_very_verbose (solver, "scheduled %zu transitive probes",
+                       SIZE_STACK (*probes));
+}
+
+void kissat_transitive_reduction (kissat *solver) {
+  if (solver->inconsistent)
+    return;
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (solver->probing);
+  KISSAT_assert (!solver->level);
+  if (!GET_OPTION (transitive))
+    return;
+  if (TERMINATED (transitive_terminated_2))
+    return;
+  START (transitive);
+  INC (transitive_reductions);
+#if !defined(KISSAT_NDEBUG) || defined(METRICS)
+  KISSAT_assert (!solver->transitive_reducing);
+  solver->transitive_reducing = true;
+#endif
+  prioritize_binaries (solver);
+  bool success = false;
+  uint64_t reduced = 0;
+  unsigned units = 0;
+
+  SET_EFFORT_LIMIT (limit, transitive, transitive_ticks);
+
+#ifndef KISSAT_QUIET
+  const unsigned active = solver->active;
+  const uint64_t old_ticks = solver->statistics_.transitive_ticks;
+  kissat_extremely_verbose (
+      solver, "starting with %" PRIu64 " transitive ticks", old_ticks);
+  unsigned probed = 0;
+#endif
+  unsigneds probes;
+  INIT_STACK (probes);
+  schedule_transitive (solver, &probes);
+  bool terminate = false;
+  while (!terminate && !EMPTY_STACK (probes)) {
+    const unsigned idx = POP_STACK (probes);
+    solver->flags[idx].transitive = false;
+    if (!ACTIVE (idx))
+      continue;
+    for (unsigned sign = 0; !terminate && sign < 2; sign++) {
+      const unsigned lit = 2 * idx + sign;
+      if (solver->values[lit])
+        continue;
+#ifndef KISSAT_QUIET
+      probed++;
+#endif
+      if (transitive_reduce (solver, lit, limit, &reduced, &units))
+        success = true;
+      if (solver->inconsistent)
+        terminate = true;
+      else if (solver->statistics_.transitive_ticks > limit)
+        terminate = true;
+      else if (TERMINATED (transitive_terminated_3))
+        terminate = true;
+    }
+  }
+  const size_t remain = SIZE_STACK (probes);
+  if (remain) {
+    if (!GET_OPTION (transitivekeep)) {
+      kissat_very_verbose (
+          solver, "dropping remaining %zu transitive candidates", remain);
+      while (!EMPTY_STACK (probes)) {
+        const unsigned idx = POP_STACK (probes);
+        solver->flags[idx].transitive = false;
+      }
+    }
+  } else
+    kissat_very_verbose (solver, "transitive reduction complete");
+  RELEASE_STACK (probes);
+
+#ifndef KISSAT_QUIET
+  const uint64_t new_ticks = solver->statistics_.transitive_ticks;
+  const uint64_t delta_ticks = new_ticks - old_ticks;
+  kissat_extremely_verbose (
+      solver, "finished at %" PRIu64 " after %" PRIu64 " transitive ticks",
+      new_ticks, delta_ticks);
+#endif
+  kissat_phase (solver, "transitive", GET (probings),
+                "probed %u (%.0f%%): reduced %" PRIu64 ", units %u", probed,
+                kissat_percent (probed, 2 * active), reduced, units);
+
+#if !defined(KISSAT_NDEBUG) || defined(METRICS)
+  KISSAT_assert (solver->transitive_reducing);
+  solver->transitive_reducing = false;
+#endif
+  REPORT (!success, 't');
+  STOP (transitive);
+#ifdef KISSAT_QUIET
+  (void) success;
+#endif
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/transitive.h b/src/sat/kissat/transitive.h
new file mode 100644
index 000000000..214656824
--- /dev/null
+++ b/src/sat/kissat/transitive.h
@@ -0,0 +1,13 @@
+#ifndef _transitive_h_INCLUDED
+#define _transitive_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_transitive_reduction (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/utilities.c b/src/sat/kissat/utilities.c
new file mode 100644
index 000000000..9a6b08b84
--- /dev/null
+++ b/src/sat/kissat/utilities.c
@@ -0,0 +1,20 @@
+#include "utilities.h"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+bool kissat_has_suffix (const char *str, const char *suffix) {
+  const char *p = str;
+  while (*p)
+    p++;
+  const char *q = suffix;
+  while (*q)
+    q++;
+  while (p > str && q > suffix)
+    if (*--p != *--q)
+      return false;
+  return q == suffix;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/utilities.h b/src/sat/kissat/utilities.h
new file mode 100644
index 000000000..2a9896341
--- /dev/null
+++ b/src/sat/kissat/utilities.h
@@ -0,0 +1,166 @@
+#ifndef _utilities_h_INCLUDED
+#define _utilities_h_INCLUDED
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef _MSC_VER
+#include <intrin.h>
+static inline int __builtin_clz(unsigned x) {
+  unsigned long r;
+  _BitScanReverse(&r, x);
+  return (int)(r ^ 31);
+}
+
+static inline int __builtin_clzll(unsigned long long x) {
+#if defined(_WIN64)
+    unsigned long r;
+    _BitScanReverse64(&r, x);
+    return (int)(r ^ 63);
+#else
+    int l = __builtin_clz((unsigned)x) + 32;
+    int h = __builtin_clz((unsigned)(x >> 32));
+    return !!((unsigned)(x >> 32)) ? h : l;
+#endif
+}
+
+static inline int __builtin_clzl(unsigned long x) {
+  return sizeof(x) == 8 ? __builtin_clzll(x) : __builtin_clz((unsigned)x);
+}
+#endif
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+//typedef uintptr_t word;
+typedef uintptr_t w2rd[2];
+
+#define WORD_ALIGNMENT_MASK (sizeof (word) - 1)
+#define W2RD_ALIGNMENT_MASK (sizeof (w2rd) - 1)
+
+#define WORD_FORMAT PRIuPTR
+
+#define MAX_SIZE_T (~(size_t) 0)
+
+#define ASSUMED_LD_CACHE_LINE_BYTES 7u
+
+static inline word kissat_cache_lines (word n, size_t size) {
+  if (!n)
+    return 0;
+#ifdef KISSAT_NDEBUG
+  (void) size;
+#endif
+  KISSAT_assert (size == 4);
+  KISSAT_assert (ASSUMED_LD_CACHE_LINE_BYTES > 2);
+  const unsigned shift = ASSUMED_LD_CACHE_LINE_BYTES - 2u;
+  const word mask = (((word) 1) << shift) - 1;
+  const word masked = n + mask;
+  const word res = masked >> shift;
+  return res;
+}
+
+static inline double kissat_average (double a, double b) {
+  return b ? a / b : 0.0;
+}
+
+static inline double kissat_percent (double a, double b) {
+  return kissat_average (100.0 * a, b);
+}
+
+static inline bool kissat_aligned_word (word word) {
+  return !(word & WORD_ALIGNMENT_MASK);
+}
+
+static inline bool kissat_aligned_pointer (const void *p) {
+  return kissat_aligned_word ((word) p);
+}
+
+static inline word kissat_align_word (word w) {
+  word res = w;
+  if (res & WORD_ALIGNMENT_MASK)
+    res = 1 + (res | WORD_ALIGNMENT_MASK);
+  return res;
+}
+
+static inline word kissat_align_w2rd (word w) {
+  word res = w;
+  if (res & W2RD_ALIGNMENT_MASK)
+    res = 1 + (res | W2RD_ALIGNMENT_MASK);
+  return res;
+}
+
+bool kissat_has_suffix (const char *str, const char *suffix);
+
+static inline bool kissat_is_power_of_two (uint64_t w) {
+  return w && !(w & (w - 1));
+}
+
+static inline bool kissat_is_zero_or_power_of_two (word w) {
+  return !(w & (w - 1));
+}
+
+static inline unsigned kissat_leading_zeroes_of_unsigned (unsigned x) {
+  return x ? __builtin_clz (x) : sizeof (unsigned) * 8;
+}
+
+static inline unsigned kissat_leading_zeroes_of_word (word x) {
+  if (!x)
+    return sizeof (word) * 8;
+  if (sizeof (word) == sizeof (unsigned long long))
+    return __builtin_clzll (x);
+  if (sizeof (word) == sizeof (unsigned long))
+    return __builtin_clzl (x);
+  return __builtin_clz (x);
+}
+
+static inline unsigned kissat_log2_floor_of_word (word x) {
+  return x ? sizeof (word) * 8 - 1 - kissat_leading_zeroes_of_word (x) : 0;
+}
+
+static inline unsigned kissat_log2_ceiling_of_word (word x) {
+  if (!x)
+    return 0;
+  unsigned tmp = kissat_log2_floor_of_word (x);
+  return tmp + !!(x ^ (((word) 1) << tmp));
+}
+
+static inline unsigned kissat_leading_zeroes_of_uint64 (uint64_t x) {
+  if (!x)
+    return sizeof (uint64_t) * 8;
+  if (sizeof (uint64_t) == sizeof (unsigned long long))
+    return __builtin_clzll (x);
+  if (sizeof (uint64_t) == sizeof (unsigned long))
+    return __builtin_clzl (x);
+  return __builtin_clz (x);
+}
+
+static inline unsigned kissat_log2_floor_of_uint64 (uint64_t x) {
+  return x ? sizeof (uint64_t) * 8 - 1 - kissat_leading_zeroes_of_uint64 (x)
+           : 0;
+}
+
+static inline unsigned kissat_log2_ceiling_of_uint64 (uint64_t x) {
+  if (!x)
+    return 0;
+  unsigned tmp = kissat_log2_floor_of_uint64 (x);
+  return tmp + !!(x ^ (((uint64_t) 1) << tmp));
+}
+
+#define SWAP(TYPE, A, B) \
+  do { \
+    TYPE TMP_SWAP = (A); \
+    (A) = (B); \
+    (B) = (TMP_SWAP); \
+  } while (0)
+
+#define MIN(A, B) ((A) > (B) ? (B) : (A))
+
+#define MAX(A, B) ((A) < (B) ? (B) : (A))
+
+#define ABS(A) (KISSAT_assert ((int) (A) != INT_MIN), (A) < 0 ? -(A) : (A))
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/value.h b/src/sat/kissat/value.h
new file mode 100644
index 000000000..92324ca53
--- /dev/null
+++ b/src/sat/kissat/value.h
@@ -0,0 +1,18 @@
+#ifndef _value_h_INCLUDED
+#define _value_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef signed char value;
+typedef signed char mark;
+
+#define VALUE(LIT) (solver->values[KISSAT_assert ((LIT) < LITS), (LIT)])
+
+#define MARK(LIT) (solver->marks[KISSAT_assert ((LIT) < LITS), (LIT)])
+
+#define BOOL_TO_VALUE(B) ((signed char) ((B) ? -1 : 1))
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/vector.c b/src/sat/kissat/vector.c
new file mode 100644
index 000000000..1383c97c5
--- /dev/null
+++ b/src/sat/kissat/vector.c
@@ -0,0 +1,324 @@
+#include "allocate.h"
+#include "collect.h"
+#include "error.h"
+#include "inlinevector.h"
+#include "logging.h"
+#include "print.h"
+#include "rank.h"
+
+#include <inttypes.h>
+#include <stddef.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#ifndef KISSAT_COMPACT
+
+static void fix_vector_pointers_after_moving_stack (kissat *solver,
+                                                    ptrdiff_t moved) {
+#ifdef LOGGING
+  uint64_t bytes = moved < 0 ? -moved : moved;
+  LOG ("fixing begin and end pointers of all watches "
+       "since the global watches stack has been moved by %s",
+       FORMAT_BYTES (bytes));
+#endif
+  struct vector *begin_watches = solver->watches;
+  struct vector *end_watches = begin_watches + LITS;
+  for (struct vector *p = begin_watches; p != end_watches; p++) {
+
+#define FIX_POINTER(PTR) \
+  do { \
+    char *old_char_ptr_value = (char *) (PTR); \
+    if (!old_char_ptr_value) \
+      break; \
+    char *new_char_ptr_value = old_char_ptr_value + moved; \
+    unsigned *new_unsigned_ptr_value = (unsigned *) new_char_ptr_value; \
+    (PTR) = new_unsigned_ptr_value; \
+  } while (0)
+
+    FIX_POINTER (p->begin);
+    FIX_POINTER (p->end);
+  }
+}
+
+#endif
+
+unsigned *kissat_enlarge_vector (kissat *solver, vector *vector) {
+  unsigneds *stack = &solver->vectors.stack;
+  const size_t old_vector_size = kissat_size_vector (vector);
+#ifdef LOGGING
+  const size_t old_offset = kissat_offset_vector (solver, vector);
+  LOG2 ("enlarging vector %zu[%zu] at %p", old_offset, old_vector_size,
+        (void *) vector);
+#endif
+  KISSAT_assert (old_vector_size < MAX_VECTORS / 2);
+  const size_t new_vector_size = old_vector_size ? 2 * old_vector_size : 1;
+  size_t old_stack_size = SIZE_STACK (*stack);
+  size_t capacity = CAPACITY_STACK (*stack);
+  KISSAT_assert (kissat_is_power_of_two (MAX_VECTORS));
+  KISSAT_assert (capacity <= MAX_VECTORS);
+  size_t available = capacity - old_stack_size;
+  if (new_vector_size > available) {
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_COMPACT)
+    unsigned *old_begin_stack = BEGIN_STACK (*stack);
+#endif
+    unsigned enlarged = 0;
+    do {
+      KISSAT_assert (kissat_is_zero_or_power_of_two (capacity));
+
+      if (capacity == MAX_VECTORS)
+        kissat_fatal ("maximum vector stack size "
+                      "of 2^%u entries %s exhausted",
+                      LD_MAX_VECTORS,
+                      FORMAT_BYTES (MAX_VECTORS * sizeof (unsigned)));
+      enlarged++;
+      kissat_stack_enlarge (solver, (chars *) stack, sizeof (unsigned));
+
+      capacity = CAPACITY_STACK (*stack);
+      available = capacity - old_stack_size;
+    } while (new_vector_size > available);
+
+    if (enlarged) {
+      INC (vectors_enlarged);
+#if !defined(KISSAT_QUIET) || !defined(KISSAT_COMPACT)
+      unsigned *new_begin_stack = BEGIN_STACK (*stack);
+      const ptrdiff_t moved =
+          (char *) new_begin_stack - (char *) old_begin_stack;
+#endif
+#ifndef KISSAT_QUIET
+      kissat_phase (solver, "vectors", GET (vectors_enlarged),
+                    "enlarged to %s entries %s (%s)",
+                    FORMAT_COUNT (capacity),
+                    FORMAT_BYTES (capacity * sizeof (unsigned)),
+                    (moved ? "moved" : "in place"));
+#endif
+#ifndef KISSAT_COMPACT
+      if (moved)
+        fix_vector_pointers_after_moving_stack (solver, moved);
+#endif
+    }
+    KISSAT_assert (capacity <= MAX_VECTORS);
+    KISSAT_assert (new_vector_size <= available);
+  }
+  unsigned *begin_old_vector = kissat_begin_vector (solver, vector);
+  unsigned *begin_new_vector = END_STACK (*stack);
+  unsigned *middle_new_vector = begin_new_vector + old_vector_size;
+  unsigned *end_new_vector = begin_new_vector + new_vector_size;
+  KISSAT_assert (end_new_vector <= stack->allocated);
+  const size_t old_bytes = old_vector_size * sizeof (unsigned);
+  const size_t delta_size = new_vector_size - old_vector_size;
+  KISSAT_assert (MAX_SIZE_T / sizeof (unsigned) >= delta_size);
+  const size_t delta_bytes = delta_size * sizeof (unsigned);
+  if (old_bytes) {
+    memcpy (begin_new_vector, begin_old_vector, old_bytes);
+    memset (begin_old_vector, 0xff, old_bytes);
+  }
+  solver->vectors.usable += old_vector_size;
+  kissat_add_usable (solver, delta_size);
+  if (delta_bytes)
+    memset (middle_new_vector, 0xff, delta_bytes);
+#ifdef KISSAT_COMPACT
+  const uint64_t offset = SIZE_STACK (*stack);
+  KISSAT_assert (offset <= MAX_VECTORS);
+  vector->offset = offset;
+  LOG2 ("enlarged vector at %p to %u[%u]", (void *) vector, vector->offset,
+        vector->size);
+#else
+  vector->begin = begin_new_vector;
+  vector->end = middle_new_vector;
+#ifdef LOGGING
+  const size_t new_offset = vector->begin - stack->begin;
+  LOG2 ("enlarged vector at %p to %zu[%zu]", (void *) vector, new_offset,
+        old_vector_size);
+#endif
+#endif
+  stack->end = end_new_vector;
+  KISSAT_assert (begin_new_vector < end_new_vector);
+  KISSAT_assert (kissat_size_vector (vector) == old_vector_size);
+  return middle_new_vector;
+}
+
+#ifdef KISSAT_COMPACT
+
+typedef unsigned rank;
+
+static inline rank rank_offset (vector *unsorted, unsigned i) {
+  return unsorted[i].offset;
+}
+
+#else
+
+typedef uintptr_t rank;
+
+static inline rank rank_offset (vector *unsorted, unsigned i) {
+  const unsigned *begin = unsorted[i].begin;
+  return (uintptr_t) begin;
+}
+
+#endif
+
+#define RANK_OFFSET(A) rank_offset (unsorted, (A))
+
+void kissat_defrag_vectors (kissat *solver, size_t size_unsorted,
+                            vector *unsorted) {
+  unsigneds *stack = &solver->vectors.stack;
+  const size_t size_vectors = SIZE_STACK (*stack);
+  if (size_vectors < 2)
+    return;
+  START (defrag);
+  INC (defragmentations);
+  LOG ("defragmenting vectors size %zu capacity %zu usable %zu",
+       size_vectors, CAPACITY_STACK (*stack), solver->vectors.usable);
+  size_t bytes = size_unsorted * sizeof (unsigned);
+  unsigned *sorted = (unsigned*)kissat_malloc (solver, bytes);
+  unsigned size_sorted = 0;
+  for (unsigned i = 0; i < size_unsorted; i++) {
+    vector *vector = unsorted + i;
+    if (kissat_empty_vector (vector))
+#ifdef KISSAT_COMPACT
+      vector->offset = 0;
+#else
+      vector->begin = vector->end = 0;
+#endif
+    else
+      sorted[size_sorted++] = i;
+  }
+  RADIX_SORT (unsigned, rank, size_sorted, sorted, RANK_OFFSET);
+  unsigned *old_begin_stack = BEGIN_STACK (*stack);
+  unsigned *p = old_begin_stack + 1;
+  for (unsigned i = 0; i < size_sorted; i++) {
+    unsigned j = sorted[i];
+    vector *vector = unsorted + j;
+    const size_t size = kissat_size_vector (vector);
+    unsigned *new_end_of_vector = p + size;
+#ifdef KISSAT_COMPACT
+    const unsigned old_offset = vector->offset;
+    const unsigned new_offset = p - old_begin_stack;
+    KISSAT_assert (new_offset <= old_offset);
+    vector->offset = new_offset;
+    const unsigned *const q = old_begin_stack + old_offset;
+#else
+    if (!size) {
+      vector->begin = vector->end = 0;
+      continue;
+    }
+    const unsigned *const q = vector->begin;
+    vector->begin = p;
+    vector->end = new_end_of_vector;
+#endif
+    KISSAT_assert (MAX_SIZE_T / sizeof (unsigned) >= size);
+    memmove (p, q, size * sizeof (unsigned));
+    p = new_end_of_vector;
+  }
+  kissat_free (solver, sorted, bytes);
+#ifndef KISSAT_QUIET
+  const size_t freed = END_STACK (*stack) - p;
+  double freed_fraction = kissat_percent (freed, size_vectors);
+  kissat_phase (solver, "defrag", GET (defragmentations),
+                "freed %zu usable entries %.0f%% thus %s", freed,
+                freed_fraction, FORMAT_BYTES (freed * sizeof (unsigned)));
+  KISSAT_assert (freed == solver->vectors.usable);
+#endif
+  SET_END_OF_STACK (*stack, p);
+#ifndef KISSAT_COMPACT
+  KISSAT_assert (old_begin_stack == BEGIN_STACK (*stack));
+#endif
+  SHRINK_STACK (*stack);
+#ifndef KISSAT_COMPACT
+  unsigned *new_begin_stack = BEGIN_STACK (*stack);
+  const ptrdiff_t moved =
+      (char *) new_begin_stack - (char *) old_begin_stack;
+  if (moved)
+    fix_vector_pointers_after_moving_stack (solver, moved);
+#endif
+  solver->vectors.usable = 0;
+  kissat_check_vectors (solver);
+  STOP (defrag);
+}
+
+void kissat_remove_from_vector (kissat *solver, vector *vector,
+                                unsigned remove) {
+  unsigned *begin = kissat_begin_vector (solver, vector), *p = begin;
+  const unsigned *const end = kissat_end_vector (solver, vector);
+  KISSAT_assert (p != end);
+  while (*p != remove)
+    p++, KISSAT_assert (p != end);
+  while (++p != end)
+    p[-1] = *p;
+  p[-1] = INVALID_VECTOR_ELEMENT;
+#ifdef KISSAT_COMPACT
+  vector->size--;
+#else
+  KISSAT_assert (vector->begin < vector->end);
+  vector->end--;
+#endif
+  kissat_inc_usable (solver);
+  kissat_check_vectors (solver);
+#ifndef CHECK_VECTORS
+  (void) solver;
+#endif
+}
+
+void kissat_resize_vector (kissat *solver, vector *vector,
+                           size_t new_size) {
+  const size_t old_size = kissat_size_vector (vector);
+  KISSAT_assert (new_size <= old_size);
+  if (new_size == old_size)
+    return;
+#ifdef KISSAT_COMPACT
+  vector->size = new_size;
+#else
+  vector->end = vector->begin + new_size;
+#endif
+  unsigned *begin = kissat_begin_vector (solver, vector);
+  unsigned *end = begin + new_size;
+  size_t delta = old_size - new_size;
+  kissat_add_usable (solver, delta);
+  size_t bytes = delta * sizeof (unsigned);
+  memset (end, 0xff, bytes);
+  kissat_check_vectors (solver);
+#ifndef CHECK_VECTORS
+  (void) solver;
+#endif
+}
+
+void kissat_release_vectors (kissat *solver) {
+  RELEASE_STACK (solver->vectors.stack);
+  solver->vectors.usable = 0;
+}
+
+#ifdef CHECK_VECTORS
+
+void kissat_check_vector (kissat *solver, vector *vector) {
+  const unsigned *const begin = kissat_begin_vector (solver, vector);
+  const unsigned *const end = kissat_end_vector (solver, vector);
+  if (!solver->transitive_reducing)
+    for (const unsigned *p = begin; p != end; p++)
+      KISSAT_assert (*p != INVALID_VECTOR_ELEMENT);
+#ifdef KISSAT_NDEBUG
+  (void) solver;
+#endif
+}
+
+void kissat_check_vectors (kissat *solver) {
+  if (solver->transitive_reducing)
+    return;
+  for (all_literals (lit)) {
+    vector *vector = &WATCHES (lit);
+    kissat_check_vector (solver, vector);
+  }
+  vectors *vectors = &solver->vectors;
+  unsigneds *stack = &vectors->stack;
+  const unsigned *const begin = BEGIN_STACK (*stack);
+  const unsigned *const end = END_STACK (*stack);
+  if (begin == end)
+    return;
+  size_t invalid = 0;
+  for (const unsigned *p = begin + 1; p != end; p++)
+    if (*p == INVALID_VECTOR_ELEMENT)
+      invalid++;
+  KISSAT_assert (invalid == solver->vectors.usable);
+}
+
+#endif
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/vector.h b/src/sat/kissat/vector.h
new file mode 100644
index 000000000..5353a2e7b
--- /dev/null
+++ b/src/sat/kissat/vector.h
@@ -0,0 +1,60 @@
+#ifndef _vector_h_INCLUDED
+#define _vector_h_INCLUDED
+
+#include "stack.h"
+#include "utilities.h"
+
+#include <limits.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+#ifdef KISSAT_COMPACT
+#define LD_MAX_VECTORS (sizeof (word) == 8 ? 32u : 28u)
+#else
+#define LD_MAX_VECTORS (sizeof (word) == 8 ? 48u : 28u)
+#endif
+
+#define MAX_VECTORS (((uint64_t) 1) << LD_MAX_VECTORS)
+
+#define INVALID_VECTOR_ELEMENT UINT_MAX
+
+#define MAX_SECTOR MAX_SIZE_T
+
+typedef struct vector vector;
+typedef struct vectors vectors;
+
+struct vectors {
+  unsigneds stack;
+  size_t usable;
+};
+
+struct vector {
+#ifdef KISSAT_COMPACT
+  unsigned offset;
+  unsigned size;
+#else
+  unsigned *begin;
+  unsigned *end;
+#endif
+};
+
+struct kissat;
+
+#ifdef CHECK_VECTORS
+void kissat_check_vectors (struct kissat *);
+#else
+#define kissat_check_vectors(...) \
+  do { \
+  } while (0)
+#endif
+
+unsigned *kissat_enlarge_vector (struct kissat *, vector *);
+void kissat_defrag_vectors (struct kissat *, size_t, vector *);
+void kissat_remove_from_vector (struct kissat *, vector *, unsigned);
+void kissat_resize_vector (struct kissat *, vector *, size_t);
+void kissat_release_vectors (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/vivify.c b/src/sat/kissat/vivify.c
new file mode 100644
index 000000000..f1d677e4d
--- /dev/null
+++ b/src/sat/kissat/vivify.c
@@ -0,0 +1,1489 @@
+#include "vivify.h"
+#include "allocate.h"
+#include "backtrack.h"
+#include "collect.h"
+#include "colors.h"
+#include "decide.h"
+#include "deduce.h"
+#include "inline.h"
+#include "print.h"
+#include "promote.h"
+#include "proprobe.h"
+#include "rank.h"
+#include "report.h"
+#include "sort.h"
+#include "terminate.h"
+#include "tiers.h"
+#include "trail.h"
+
+#include "cover.h"
+
+#include <inttypes.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+static inline bool more_occurrences (unsigned *counts, unsigned a,
+                                     unsigned b) {
+  const unsigned s = counts[a], t = counts[b];
+  return ((t - s) | ((b - a) & ~(s - t))) >> 31;
+}
+
+#define MORE_OCCURRENCES(A, B) more_occurrences (counts, (A), (B))
+
+static void vivify_sort_lits_by_counts (kissat *solver, size_t size,
+                                        unsigned *lits, unsigned *counts) {
+  SORT (unsigned, size, lits, MORE_OCCURRENCES);
+}
+
+static void vivify_sort_stack_by_counts (kissat *solver, unsigneds *stack,
+                                         unsigned *counts) {
+  const size_t size = SIZE_STACK (*stack);
+  unsigned *lits = BEGIN_STACK (*stack);
+  vivify_sort_lits_by_counts (solver, size, lits, counts);
+}
+
+static void vivify_sort_clause_by_counts (kissat *solver, clause *c,
+                                          unsigned *counts) {
+  vivify_sort_lits_by_counts (solver, c->size, c->lits, counts);
+}
+
+static inline void count_literal (unsigned lit, unsigned *counts) {
+  counts[lit] += counts[lit] < (unsigned) INT_MAX;
+}
+
+static void count_clause (clause *c, unsigned *counts) {
+  for (all_literals_in_clause (lit, c))
+    count_literal (lit, counts);
+}
+
+static bool simplify_vivification_candidate (kissat *solver,
+                                             clause *const c) {
+  KISSAT_assert (!solver->level);
+  CLEAR_STACK (solver->clause);
+
+  const value *const values = solver->values;
+
+  for (all_literals_in_clause (lit, c)) {
+    const value value = values[lit];
+    if (value > 0) {
+      LOGCLS (c, "vivification %s satisfied candidate", LOGLIT (lit));
+      kissat_mark_clause_as_garbage (solver, c);
+      return true;
+    }
+    if (!value)
+      PUSH_STACK (solver->clause, lit);
+  }
+
+  unsigned non_false = SIZE_STACK (solver->clause);
+  KISSAT_assert (non_false <= c->size);
+  if (non_false == c->size)
+    return false;
+
+  if (non_false == 2) {
+    const unsigned first = PEEK_STACK (solver->clause, 0);
+    const unsigned second = PEEK_STACK (solver->clause, 1);
+    LOGBINARY (first, second, "vivification shrunken candidate");
+    kissat_new_binary_clause (solver, first, second);
+    kissat_mark_clause_as_garbage (solver, c);
+    return true;
+  }
+
+  KISSAT_assert (2 < non_false);
+
+  CHECK_AND_ADD_STACK (solver->clause);
+  ADD_STACK_TO_PROOF (solver->clause);
+
+  REMOVE_CHECKER_CLAUSE (c);
+  DELETE_CLAUSE_FROM_PROOF (c);
+
+  const unsigned old_size = c->size;
+  unsigned new_size = 0, *lits = c->lits;
+  for (unsigned i = 0; i < old_size; i++) {
+    const unsigned lit = lits[i];
+    const value value = values[lit];
+    KISSAT_assert (value <= 0);
+    if (!value)
+      lits[new_size++] = lit;
+  }
+
+  KISSAT_assert (2 < new_size);
+  KISSAT_assert (new_size == non_false);
+  KISSAT_assert (new_size < old_size);
+
+  c->size = new_size;
+  c->searched = 2;
+
+  if (c->redundant && c->glue >= new_size)
+    kissat_promote_clause (solver, c, new_size - 1);
+  if (!c->shrunken) {
+    c->shrunken = true;
+    lits[old_size - 1] = INVALID_LIT;
+  }
+
+  LOGCLS (c, "vivification shrunken candidate");
+  LOG ("vivification candidate does not need to be simplified");
+
+  return false;
+}
+
+static unsigned vivify_tier1_limit (kissat *solver) {
+  return GET_OPTION (vivifyfocusedtiers) ? solver->tier1[0] : TIER1;
+}
+
+static unsigned vivify_tier2_limit (kissat *solver) {
+  return GET_OPTION (vivifyfocusedtiers) ? solver->tier2[0] : TIER2;
+}
+
+#define COUNTREF_COUNTS 1
+#define LD_MAX_COUNTREF_SIZE 31
+#define MAX_COUNTREF_SIZE ((1u << LD_MAX_COUNTREF_SIZE) - 1)
+
+struct countref {
+  unsigned vivify : 1;
+  unsigned size : LD_MAX_COUNTREF_SIZE;
+  unsigned count[COUNTREF_COUNTS];
+  reference ref;
+};
+
+typedef struct countref countref;
+typedef STACK (countref) countrefs;
+
+struct vivifier {
+  kissat *solver;
+  unsigned *counts;
+  references schedule;
+  size_t scheduled, tried, vivified;
+  countrefs countrefs;
+  unsigneds sorted;
+#ifndef KISSAT_QUIET
+  const char *mode;
+  const char *name;
+  char tag;
+#endif
+  int tier;
+};
+
+typedef struct vivifier vivifier;
+
+static void init_vivifier (kissat *solver, vivifier *vivifier) {
+  vivifier->solver = solver;
+  vivifier->counts = (unsigned*)kissat_calloc (solver, LITS, sizeof (unsigned));
+  INIT_STACK (vivifier->schedule);
+  INIT_STACK (vivifier->countrefs);
+  INIT_STACK (vivifier->sorted);
+  LOG ("initialized vivifier");
+}
+
+static void set_vivifier_mode (vivifier *vivifier, int tier) {
+  vivifier->tier = tier;
+#ifndef KISSAT_QUIET
+  switch (tier) {
+  case 1:
+    vivifier->mode = "vivify-tier1";
+    vivifier->name = "tier1";
+    vivifier->tag = 'u';
+    break;
+  case 2:
+    vivifier->mode = "vivify-tier2";
+    vivifier->name = "tier2";
+    vivifier->tag = 'v';
+    break;
+  case 3:
+    KISSAT_assert (tier == 3);
+    vivifier->mode = "vivify-tier3";
+    vivifier->name = "tier3";
+    vivifier->tag = 'w';
+    break;
+  default:
+    KISSAT_assert (tier == 0);
+    vivifier->mode = "vivify-irredundant";
+    vivifier->name = "irredundant";
+    vivifier->tag = 'x';
+    break;
+  }
+#ifdef LOGGING
+  kissat *solver = vivifier->solver;
+  LOG ("set vivifier tier %d mode '%s' with tag '%c'", tier, vivifier->mode,
+       vivifier->tag);
+#endif
+#endif
+}
+
+static void clear_vivifier (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  LOG ("clearing vivifier");
+  unsigned *counts = vivifier->counts;
+  memset (counts, 0, LITS * sizeof *counts);
+  CLEAR_STACK (vivifier->schedule);
+  CLEAR_STACK (vivifier->countrefs);
+  CLEAR_STACK (vivifier->sorted);
+}
+
+static void release_vivifier (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  LOG ("releasing vivifier");
+  unsigned *counts = vivifier->counts;
+  kissat_dealloc (solver, counts, LITS, sizeof *counts);
+  RELEASE_STACK (vivifier->schedule);
+  RELEASE_STACK (vivifier->countrefs);
+  RELEASE_STACK (vivifier->sorted);
+}
+
+static void schedule_vivification_candidates (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  LOG ("scheduling vivification candidates");
+  int tier = vivifier->tier;
+  unsigned lower_glue_limit, upper_glue_limit;
+  unsigned tier1 = vivify_tier1_limit (solver);
+  unsigned tier2 = MAX (tier1, vivify_tier2_limit (solver));
+  KISSAT_assert (tier1 <= tier2);
+  switch (tier) {
+  case 1:
+    lower_glue_limit = 0;
+    upper_glue_limit = tier1;
+    break;
+  case 2:
+    lower_glue_limit = tier1 < tier2 ? tier1 + 1 : 0;
+    upper_glue_limit = tier2;
+    break;
+  case 3:
+    lower_glue_limit = tier2 + 1;
+    upper_glue_limit = UINT_MAX;
+    break;
+  default:
+    KISSAT_assert (tier == 0);
+    lower_glue_limit = 0;
+    upper_glue_limit = UINT_MAX;
+    break;
+  }
+  KISSAT_assert (lower_glue_limit <= upper_glue_limit);
+  ward *const arena = BEGIN_STACK (solver->arena);
+  size_t prioritized = 0;
+  unsigned *counts = vivifier->counts;
+  references *schedule = &vivifier->schedule;
+  for (unsigned prioritize = 0; prioritize < 2; prioritize++) {
+    for (all_clauses (c)) {
+      if (c->garbage)
+        continue;
+      if (prioritize)
+        count_clause (c, counts);
+      if (tier) {
+        if (!c->redundant)
+          continue;
+        if (c->glue < lower_glue_limit)
+          continue;
+        if (c->glue > upper_glue_limit)
+          continue;
+      } else if (c->redundant)
+        continue;
+      if (c->vivify != prioritize)
+        continue;
+      if (simplify_vivification_candidate (solver, c))
+        continue;
+      if (prioritize)
+        prioritized++;
+      const reference ref = (ward *) c - arena;
+      PUSH_STACK (*schedule, ref);
+    }
+  }
+  CLEAR_STACK (solver->clause);
+  size_t scheduled = SIZE_STACK (*schedule);
+  if (prioritized) {
+    kissat_phase (solver, vivifier->mode, GET (vivifications),
+                  "prioritized %zu clauses %.0f%%", prioritized,
+                  kissat_percent (prioritized, scheduled));
+  } else {
+    kissat_phase (solver, vivifier->mode, GET (vivifications),
+                  "prioritizing all %zu scheduled clauses", scheduled);
+    for (all_stack (reference, ref, *schedule)) {
+      clause *c = (clause *) (arena + ref);
+      KISSAT_assert (kissat_clause_in_arena (solver, c));
+      c->vivify = true;
+    }
+  }
+  vivifier->scheduled = scheduled;
+  vivifier->tried = vivifier->vivified = 0;
+}
+
+static inline bool worse_candidate (kissat *solver, unsigned *counts,
+                                    reference r, reference s) {
+  const clause *const c = kissat_dereference_clause (solver, r);
+  const clause *const d = kissat_dereference_clause (solver, s);
+
+  if (!c->vivify && d->vivify)
+    return true;
+
+  if (c->vivify && !d->vivify)
+    return false;
+
+  unsigned const *p = BEGIN_LITS (c);
+  unsigned const *q = BEGIN_LITS (d);
+  const unsigned *const e = END_LITS (c);
+  const unsigned *const f = END_LITS (d);
+
+  unsigned a = INVALID_LIT, b = INVALID_LIT;
+
+  while (p != e && q != f) {
+    a = *p++;
+    b = *q++;
+    const unsigned u = counts[a];
+    const unsigned v = counts[b];
+    if (u < v)
+      return true;
+    if (u > v)
+      return false;
+  }
+
+  if (p != e && q == f)
+    return true;
+
+  if (p == e && q != f)
+    return false;
+
+  KISSAT_assert (p == e && q == f);
+
+  if (a < b)
+    return true;
+  if (a > b)
+    return false;
+
+  return r < s;
+}
+
+#define WORSE_CANDIDATE(A, B) worse_candidate (solver, counts, (A), (B))
+
+static void
+sort_vivification_candidates_after_sorting_literals (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  unsigned *counts = vivifier->counts;
+  references *schedule = &vivifier->schedule;
+  SORT_STACK (reference, *schedule, WORSE_CANDIDATE);
+}
+
+static void sort_scheduled_candidate_literals (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  unsigned *counts = vivifier->counts;
+  references *schedule = &vivifier->schedule;
+  for (all_stack (reference, ref, *schedule)) {
+    clause *c = kissat_dereference_clause (solver, ref);
+    vivify_sort_clause_by_counts (solver, c, counts);
+  }
+}
+
+static inline void init_countref (countref *cr, clause *c, reference ref,
+                                  unsigned *counts) {
+  KISSAT_assert (COUNTREF_COUNTS <= c->size);
+  KISSAT_assert (c->size <= MAX_COUNTREF_SIZE);
+  cr->size = c->size;
+  cr->vivify = c->vivify;
+  cr->ref = ref;
+  unsigned lits[COUNTREF_COUNTS];
+  for (unsigned i = 0; i != COUNTREF_COUNTS; i++) {
+    unsigned best = INVALID_LIT;
+    unsigned best_count = 0;
+    for (all_literals_in_clause (lit, c)) {
+      int continue_with_next_literal = 0;
+      for (unsigned j = 0; j != i; j++)
+        if (lits[j] == lit) {
+          continue_with_next_literal = 1;
+          break;
+        }
+      if(continue_with_next_literal) {
+        continue;
+      }
+      const unsigned lit_count = counts[lit];
+      KISSAT_assert (lit_count);
+      if (lit_count <= best_count)
+        continue;
+      best_count = lit_count;
+      best = lit;
+    }
+    KISSAT_assert (best != INVALID_LIT);
+    KISSAT_assert (best_count);
+    cr->count[i] = best_count;
+    lits[i] = best;
+  }
+}
+
+static void init_countrefs (vivifier *vivifier) {
+  kissat *const solver = vivifier->solver;
+  references *schedule = &vivifier->schedule;
+  countrefs *countrefs = &vivifier->countrefs;
+  unsigned *counts = vivifier->counts;
+  KISSAT_assert (EMPTY_STACK (*countrefs));
+  for (all_stack (reference, ref, *schedule)) {
+    clause *c = kissat_dereference_clause (solver, ref);
+    countref countref;
+    init_countref (&countref, c, ref, counts);
+    PUSH_STACK (*countrefs, countref);
+  }
+  RELEASE_STACK (*schedule);
+}
+
+#define RANK_COUNTREF_BY_INVERSE_SIZE(CR) ((unsigned) (~(CR).size))
+#define RANK_COUNTREF_BY_VIVIFY(CR) ((unsigned) ((CR).vivify))
+#define RANK_COUNTREF_BY_COUNT(CR) \
+  ((unsigned) ((CR).count[COUNTREF_COUNTS - 1 - i]))
+
+static void rank_vivification_candidates (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  countrefs *countrefs = &vivifier->countrefs;
+  RADIX_STACK (countref, unsigned, *countrefs,
+               RANK_COUNTREF_BY_INVERSE_SIZE);
+  for (unsigned i = 0; i != COUNTREF_COUNTS; i++)
+    RADIX_STACK (countref, unsigned, *countrefs, RANK_COUNTREF_BY_COUNT);
+  RADIX_STACK (countref, unsigned, *countrefs, RANK_COUNTREF_BY_VIVIFY);
+}
+
+static void copy_countrefs (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  references *schedule = &vivifier->schedule;
+  countrefs *countrefs = &vivifier->countrefs;
+  KISSAT_assert (EMPTY_STACK (*schedule));
+  for (all_stack (countref, cr, *countrefs))
+    PUSH_STACK (*schedule, cr.ref);
+  RELEASE_STACK (*countrefs);
+}
+
+static void sort_vivification_candidates (vivifier *vivifier) {
+#ifndef KISSAT_QUIET
+  kissat *solver = vivifier->solver;
+#endif
+  START (vivifysort);
+  if (vivifier->tier) {
+    kissat_extremely_verbose (
+        solver, "sorting %s vivification candidates precisely",
+        vivifier->name);
+    sort_scheduled_candidate_literals (vivifier);
+    sort_vivification_candidates_after_sorting_literals (vivifier);
+  } else {
+    kissat_extremely_verbose (
+        solver,
+        "sorting %s vivification candidates imprecisely "
+        "by first %u literals",
+        vivifier->name, (unsigned) COUNTREF_COUNTS);
+    init_countrefs (vivifier);
+    rank_vivification_candidates (vivifier);
+    copy_countrefs (vivifier);
+  }
+  STOP (vivifysort);
+}
+
+static void vivify_deduce (vivifier *vivifier, clause *candidate,
+                           clause *conflict, unsigned implied,
+                           clause **subsuming_ptr, bool *redundant_ptr) {
+  kissat *solver = vivifier->solver;
+  LOG ("starting vivification conflict analysis");
+  bool redundant = false;
+  bool subsumes = false;
+
+  KISSAT_assert (solver->level);
+  KISSAT_assert (EMPTY_STACK (solver->clause));
+  KISSAT_assert (EMPTY_STACK (solver->analyzed));
+
+  if (implied != INVALID_LIT) {
+    unsigned not_implied = NOT (implied);
+    LOG ("vivify analyzing %s", LOGLIT (not_implied));
+    assigned *const a = ASSIGNED (not_implied);
+    KISSAT_assert (a->level);
+    KISSAT_assert (!a->analyzed);
+    a->analyzed = true;
+    PUSH_STACK (solver->analyzed, not_implied);
+    PUSH_STACK (solver->clause, implied);
+  } else {
+    clause *reason = conflict ? conflict : candidate;
+    KISSAT_assert (reason), KISSAT_assert (!reason->garbage);
+    if (reason->redundant)
+      redundant = true;
+    subsumes = (reason != candidate);
+    for (all_literals_in_clause (other, reason)) {
+      KISSAT_assert (VALUE (other) < 0);
+      const value value = kissat_fixed (solver, other);
+      if (value < 0)
+        continue;
+      LOG ("vivify analyzing %s", LOGLIT (other));
+      KISSAT_assert (!value);
+      assigned *const a = ASSIGNED (other);
+      KISSAT_assert (a->level);
+      KISSAT_assert (!a->analyzed);
+      a->analyzed = true;
+      PUSH_STACK (solver->analyzed, other);
+      if (solver->marks[other] <= 0)
+        subsumes = false;
+    }
+    if (reason != candidate && reason->redundant)
+      kissat_recompute_and_promote (solver, reason);
+    if (subsumes) {
+      LOGCLS (candidate, "vivify subsumed");
+      LOGCLS (reason, "vivify subsuming");
+      *subsuming_ptr = reason;
+      return;
+    }
+  }
+
+  const mark *const marks = solver->marks;
+  size_t analyzed = 0;
+  while (analyzed < SIZE_STACK (solver->analyzed)) {
+    const unsigned not_lit = PEEK_STACK (solver->analyzed, analyzed);
+    const unsigned lit = NOT (not_lit);
+    KISSAT_assert (VALUE (lit) > 0);
+    analyzed++;
+    assigned *a = ASSIGNED (lit);
+    KISSAT_assert (a->level);
+    KISSAT_assert (a->analyzed);
+    if (a->reason == DECISION_REASON) {
+      LOG ("vivify analyzing decision %s", LOGLIT (not_lit));
+      PUSH_STACK (solver->clause, not_lit);
+    } else if (a->binary) {
+      const unsigned other = a->reason;
+      if (marks[lit] > 0 && marks[other] > 0) {
+        LOGCLS (candidate, "vivify subsumed");
+        LOGBINARY (lit, other, "vivify subsuming"); // Might be jumped!
+        *subsuming_ptr = kissat_binary_conflict (solver, lit, other);
+        return;
+      }
+      KISSAT_assert (VALUE (other) < 0);
+      assigned *b = ASSIGNED (other);
+      KISSAT_assert (b->level);
+      if (b->analyzed)
+        continue;
+      LOGBINARY (lit, other, "vivify analyzing %s reason", LOGLIT (lit));
+      b->analyzed = true;
+      PUSH_STACK (solver->analyzed, other);
+    } else {
+      const reference ref = a->reason;
+      LOGREF (ref, "vivify analyzing %s reason", LOGLIT (lit));
+      clause *reason = kissat_dereference_clause (solver, ref);
+      KISSAT_assert (reason != candidate);
+      if (reason->redundant)
+        redundant = true;
+      subsumes = true;
+      for (all_literals_in_clause (other, reason)) {
+        if (marks[other] <= 0)
+          subsumes = false;
+        if (other == lit)
+          continue;
+        KISSAT_assert (other != not_lit);
+        KISSAT_assert (VALUE (other) < 0);
+        assigned *b = ASSIGNED (other);
+        if (!b->level)
+          continue;
+        if (b->analyzed)
+          continue;
+        b->analyzed = true;
+        PUSH_STACK (solver->analyzed, other);
+      }
+      if (reason->redundant)
+        kissat_recompute_and_promote (solver, reason);
+      if (subsumes) {
+        LOGCLS (candidate, "vivify subsumed");
+        LOGCLS (reason, "vivify subsuming");
+        *subsuming_ptr = reason;
+        return;
+      }
+    }
+  }
+
+  LOG ("vivification analysis %s redundant clause",
+       redundant ? "used" : "without");
+  LOGTMP ("vivification analysis");
+
+  *redundant_ptr = redundant;
+}
+
+static void reset_vivify_analyzed (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  LOG ("reset vivification conflict analysis");
+  struct assigned *assigned = solver->assigned;
+  for (all_stack (unsigned, lit, solver->analyzed)) {
+    const unsigned idx = IDX (lit);
+    struct assigned *a = assigned + idx;
+    a->analyzed = false;
+  }
+  CLEAR_STACK (solver->analyzed);
+  CLEAR_STACK (solver->clause);
+}
+
+static bool vivify_shrinkable (kissat *solver, unsigneds *sorted,
+                               clause *conflict) {
+  KISSAT_assert (SIZE_STACK (solver->clause) <= SIZE_STACK (*sorted));
+  if (SIZE_STACK (solver->clause) == SIZE_STACK (*sorted))
+    return false;
+  const assigned *const assigned = solver->assigned;
+  const value *const values = solver->values;
+  unsigned count_implied = 0;
+  for (all_stack (unsigned, lit, *sorted)) {
+    value value = values[lit];
+    if (!value) {
+      LOG ("vivification unassigned %s thus shrinking", LOGLIT (lit));
+      return true;
+    }
+    if (value > 0) {
+      LOG ("vivification implied satisfied %s", LOGLIT (lit));
+      if (conflict) {
+        LOG ("at least one implied literal with conflict thus shrinking");
+        return true;
+      }
+      if (count_implied++) {
+        LOG ("at least two implied literals thus shrinking");
+        return true;
+      }
+    } else {
+      KISSAT_assert (value < 0);
+      const unsigned idx = IDX (lit);
+      const struct assigned *const a = assigned + idx;
+      KISSAT_assert (a->level);
+      if (!a->analyzed) {
+        LOG ("vivification non-analyzed %s thus shrinking", LOGLIT (lit));
+        return true;
+      }
+      if (a->reason != DECISION_REASON) {
+        LOG ("vivification implied falsified %s thus shrinking",
+             LOGLIT (lit));
+        return true;
+      }
+    }
+  }
+  LOG ("vivification learned clause not shrinkable");
+  return false;
+}
+
+static void vivify_learn_unit (kissat *solver, clause *c) {
+  LOG ("vivification learns unit clause");
+  KISSAT_assert (SIZE_STACK (solver->clause) == 1);
+  kissat_backtrack_without_updating_phases (solver, 0);
+  const unsigned unit = PEEK_STACK (solver->clause, 0);
+  kissat_learned_unit (solver, unit);
+  solver->iterating = true;
+  kissat_mark_clause_as_garbage (solver, c);
+  KISSAT_assert (!solver->level);
+  clause *conflict = kissat_probing_propagate (solver, 0, true);
+  KISSAT_assert (!conflict || solver->inconsistent);
+  INC (vivify_units);
+  (void) conflict;
+}
+
+static void vivify_learn_binary (kissat *solver, clause *c) {
+  LOG ("vivification learns binary clause");
+  kissat_backtrack_without_updating_phases (solver, 0);
+  KISSAT_assert (SIZE_STACK (solver->clause) == 2);
+  if (c->redundant)
+    (void) kissat_new_redundant_clause (solver, 1);
+  else
+    (void) kissat_new_irredundant_clause (solver);
+  kissat_mark_clause_as_garbage (solver, c);
+}
+
+static void swap_first_literal_with_best_watch (kissat *solver,
+                                                unsigned *lits,
+                                                unsigned size) {
+  KISSAT_assert (size);
+  unsigned *best_ptr = lits;
+  unsigned first = *best_ptr, best = first;
+  signed char value = VALUE (best);
+  unsigned best_level = LEVEL (best);
+  const unsigned *const end = lits + size;
+  for (unsigned *p = lits + 1; value < 0 && p != end; p++) {
+    unsigned lit = *p;
+    const signed char value = VALUE (lit);
+    if (value < 0) {
+      const unsigned level = LEVEL (lit);
+      if (level <= best_level)
+        continue;
+      best_level = level;
+    }
+    best_ptr = p;
+    best = lit;
+  }
+  if (best_ptr == lits)
+    return;
+  LOG ("better watch %s instead of %s", LOGLIT (best), LOGLIT (first));
+  *best_ptr = first;
+  *lits = best;
+}
+
+static void vivify_unwatch_clause (kissat *solver, clause *c) {
+  unsigned *lits = c->lits;
+  const reference ref = kissat_reference_clause (solver, c);
+  kissat_unwatch_blocking (solver, lits[0], ref);
+  kissat_unwatch_blocking (solver, lits[1], ref);
+}
+
+static void vivify_watch_clause (kissat *solver, clause *c) {
+  unsigned size = c->size;
+  unsigned *lits = c->lits;
+  const reference ref = kissat_reference_clause (solver, c);
+  swap_first_literal_with_best_watch (solver, lits, size);
+  swap_first_literal_with_best_watch (solver, lits + 1, size - 1);
+  kissat_watch_blocking (solver, lits[0], lits[1], ref);
+  kissat_watch_blocking (solver, lits[1], lits[0], ref);
+}
+
+static void vivify_learn_large (kissat *solver, clause *c,
+                                unsigned implied) {
+  KISSAT_assert (!c->garbage);
+  LOG ("vivification learns large clause");
+
+  CHECK_AND_ADD_STACK (solver->clause);
+  ADD_STACK_TO_PROOF (solver->clause);
+
+  REMOVE_CHECKER_CLAUSE (c);
+  DELETE_CLAUSE_FROM_PROOF (c);
+
+  vivify_unwatch_clause (solver, c);
+
+  bool irredundant = !c->redundant;
+
+  if (irredundant) { // TODO this could be made more precise.
+    for (all_literals_in_clause (lit, c))
+      kissat_mark_removed_literal (solver, lit);
+  }
+
+  unsigneds *learned = &solver->clause;
+  const unsigned old_size = c->size;
+  const unsigned new_size = SIZE_STACK (*learned);
+  KISSAT_assert (new_size <= old_size);
+
+  unsigned *lits = c->lits;
+  memcpy (lits, BEGIN_STACK (*learned), new_size * sizeof *lits);
+
+  if (irredundant)
+    for (all_literals_in_clause (lit, c))
+      kissat_mark_added_literal (solver, lit);
+
+  KISSAT_assert (new_size < old_size);
+  if (!c->shrunken) {
+    c->shrunken = true;
+    lits[old_size - 1] = INVALID_LIT;
+  }
+  c->size = new_size;
+  if (!irredundant && c->glue >= new_size)
+    kissat_promote_clause (solver, c, new_size - 1);
+  c->searched = 2;
+
+  if (implied == INVALID_LIT) {
+    LOGCLS (c, "vivified shrunken after conflict");
+    kissat_backtrack_without_updating_phases (solver, new_size - 2);
+  } else {
+    LOGCLS (c, "vivified shrunken after implied");
+    KISSAT_assert (solver->level >= new_size - 1);
+  }
+
+  vivify_watch_clause (solver, c);
+}
+
+static void vivify_learn (kissat *solver, clause *c, unsigned implied) {
+  size_t size = SIZE_STACK (solver->clause);
+  if (size == 1)
+    vivify_learn_unit (solver, c);
+  else if (size == 2)
+    vivify_learn_binary (solver, c);
+  else
+    vivify_learn_large (solver, c, implied);
+}
+
+static void binary_strengthen_after_instantiation (kissat *solver,
+                                                   clause *c,
+                                                   unsigned remove) {
+  LOG ("vivification instantiation yields binary clause");
+  KISSAT_assert (solver->level == 3);
+
+  unsigned first = INVALID_LIT, second = INVALID_LIT;
+  for (all_literals_in_clause (lit, c))
+    if (lit != remove) {
+      KISSAT_assert (VALUE (lit) < 0);
+      if (LEVEL (lit)) {
+        if (first == INVALID_LIT)
+          first = lit;
+        else {
+          KISSAT_assert (second == INVALID_LIT);
+          second = lit;
+        }
+      }
+    }
+  KISSAT_assert (first != INVALID_LIT);
+  KISSAT_assert (second != INVALID_LIT);
+  LOGBINARY (first, second, "vivified strengthened through instantiation");
+  CLEAR_STACK (solver->clause);
+  PUSH_STACK (solver->clause, first);
+  PUSH_STACK (solver->clause, second);
+  if (c->redundant)
+    (void) kissat_new_redundant_clause (solver, 1);
+  else
+    (void) kissat_new_irredundant_clause (solver);
+
+  kissat_mark_clause_as_garbage (solver, c);
+  kissat_backtrack_without_updating_phases (solver, 0);
+}
+
+static void large_strengthen_after_instantiation (kissat *solver, clause *c,
+                                                  unsigned remove) {
+  LOG ("vivification instantiation yields large clause");
+  KISSAT_assert (solver->level > 3);
+
+  SHRINK_CLAUSE_IN_PROOF (c, remove, INVALID_LIT);
+  CHECK_SHRINK_CLAUSE (c, remove, INVALID_LIT);
+
+  vivify_unwatch_clause (solver, c);
+
+  bool irredundant = !c->redundant;
+  const unsigned old_size = c->size;
+  KISSAT_assert (old_size > 3);
+  unsigned new_size = 0, *lits = c->lits;
+  for (unsigned i = 0; i != old_size; i++) {
+    const unsigned lit = lits[i];
+    if (lit == remove) {
+      if (irredundant)
+        kissat_mark_removed_literal (solver, lit);
+    } else if (kissat_fixed (solver, lit) >= 0) {
+      lits[new_size++] = lit;
+      if (irredundant)
+        kissat_mark_added_literal (solver, lit);
+    }
+  }
+  KISSAT_assert (2 < new_size);
+  KISSAT_assert (new_size < old_size);
+  if (!c->shrunken) {
+    c->shrunken = true;
+    lits[old_size - 1] = INVALID_LIT;
+  }
+  c->size = new_size;
+  if (!irredundant && c->glue >= new_size)
+    kissat_promote_clause (solver, c, new_size - 1);
+  c->searched = 2;
+  LOGCLS (c, "vivified strengthened through instantiation");
+
+  kissat_backtrack_without_updating_phases (solver, solver->level - 2);
+  vivify_watch_clause (solver, c);
+}
+
+static void vivify_strengthen_after_instantiation (kissat *solver,
+                                                   clause *c,
+                                                   unsigned remove) {
+  KISSAT_assert (solver->level >= 3);
+  KISSAT_assert (VALUE (remove) > 0);
+  KISSAT_assert (LEVEL (remove) == solver->level);
+
+  if (solver->level == 3)
+    binary_strengthen_after_instantiation (solver, c, remove);
+  else
+    large_strengthen_after_instantiation (solver, c, remove);
+}
+
+static void vivify_mark_sorted_literals (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  LOG ("marking sorted literals");
+  unsigneds *sorted = &vivifier->sorted;
+  value *marks = solver->marks;
+  for (all_stack (unsigned, lit, *sorted))
+    KISSAT_assert (!marks[lit]), marks[lit] = 1, marks[NOT (lit)] = -1;
+}
+
+static void vivify_unmark_sorted_literals (vivifier *vivifier) {
+  kissat *solver = vivifier->solver;
+  LOG ("unmarking sorted literals");
+  unsigneds *sorted = &vivifier->sorted;
+  value *marks = solver->marks;
+  for (all_stack (unsigned, lit, *sorted))
+    KISSAT_assert (solver->marks[lit] > 0), KISSAT_assert (marks[NOT (lit)] < 0),
+        marks[lit] = marks[NOT (lit)] = 0;
+}
+
+static void reestablish_watch_invariant_for_candidate (kissat *solver,
+                                                       clause *candidate) {
+  if (!solver->level)
+    return;
+  if (candidate->garbage)
+    return;
+  unsigned *lits = candidate->lits;
+  unsigned first = lits[0];
+  unsigned second = lits[1];
+  const signed char first_val = VALUE (first);
+  const signed char second_val = VALUE (second);
+  unsigned first_level = first_val ? LEVEL (first) : 0;
+  unsigned second_level = second_val ? LEVEL (second) : 0;
+  unsigned new_level;
+  if (first_val >= 0 && second_val >= 0)
+    return;
+  if (first_val < 0 && !second_val)
+    new_level = first_level;
+  else if (first_val < 0 && second_val > 0) {
+    if (first_level >= second_level)
+      return;
+    new_level = first_level;
+  } else if (second_val < 0 && !first_val)
+    new_level = second_level;
+  else if (second_val < 0 && first_val > 0) {
+    if (second_level >= first_level)
+      return;
+    new_level = second_level;
+  } else {
+    KISSAT_assert (first_val < 0), KISSAT_assert (second_val < 0);
+    new_level = MIN (first_level, second_level);
+  }
+  KISSAT_assert (new_level);
+  LOGCLS (candidate, "reestablish watch invariant by backtracking to %u",
+          new_level - 1);
+  kissat_backtrack_without_updating_phases (solver, new_level - 1);
+}
+
+static bool vivify_clause (vivifier *vivifier, clause *candidate) {
+
+  KISSAT_assert (!candidate->garbage);
+
+  kissat *solver = vivifier->solver;
+
+  KISSAT_assert (solver->probing);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+
+  LOGCLS (candidate, "vivifying candidate");
+  LOGCOUNTEDCLS (candidate, vivifier->counts,
+                 "vivifying unsorted counted candidate");
+
+  unsigneds *sorted = &vivifier->sorted;
+  CLEAR_STACK (*sorted);
+
+  for (all_literals_in_clause (lit, candidate)) {
+    const value value = kissat_fixed (solver, lit);
+    if (value < 0)
+      continue;
+    if (value > 0) {
+      LOGCLS (candidate, "%s satisfied", LOGLIT (lit));
+      kissat_mark_clause_as_garbage (solver, candidate);
+      return false;
+    }
+    PUSH_STACK (*sorted, lit);
+  }
+
+  KISSAT_assert (!candidate->garbage);
+
+  const unsigned non_false = SIZE_STACK (*sorted);
+
+  KISSAT_assert (1 < non_false);
+  KISSAT_assert (non_false <= candidate->size);
+
+#ifdef LOGGING
+  if (non_false == candidate->size)
+    LOG ("all literals root level unassigned");
+  else
+    LOG ("found %u root level non-falsified literals", non_false);
+#endif
+
+  if (non_false == 2) {
+    LOGCLS (candidate, "skipping actually binary");
+    return false;
+  }
+
+  INC (vivify_checks);
+
+  unsigned unit = INVALID_LIT;
+  for (all_literals_in_clause (lit, candidate)) {
+    const value value = VALUE (lit);
+    if (value < 0)
+      continue;
+    if (!value) {
+      unit = INVALID_LIT;
+      break;
+    }
+    KISSAT_assert (value > 0);
+    if (unit != INVALID_LIT) {
+      unit = INVALID_LIT;
+      break;
+    }
+    unit = lit;
+  }
+  reference cand_ref = kissat_reference_clause (solver, candidate);
+  if (unit != INVALID_LIT) {
+    assigned *a = ASSIGNED (unit);
+    KISSAT_assert (a->level);
+    if (a->binary)
+      unit = INVALID_LIT;
+    else {
+      if (a->reason != cand_ref)
+        unit = INVALID_LIT;
+    }
+  }
+  if (unit == INVALID_LIT)
+    LOG ("non-reason candidate clause");
+  else {
+    LOG ("candidate is the reason of %s", LOGLIT (unit));
+    const unsigned level = LEVEL (unit);
+    KISSAT_assert (level > 0);
+    LOG ("forced to backtrack to level %u", level - 1);
+    kissat_backtrack_without_updating_phases (solver, level - 1);
+  }
+
+  KISSAT_assert (EMPTY_STACK (solver->analyzed));
+  KISSAT_assert (EMPTY_STACK (solver->clause));
+
+  unsigned *counts = vivifier->counts;
+  vivify_sort_stack_by_counts (solver, sorted, counts);
+
+#ifdef LOGGING
+  if (candidate->redundant)
+    LOGCOUNTEDREFLITS (cand_ref, SIZE_STACK (*sorted), sorted->begin,
+                       counts, "vivifying sorted redundant glue %u",
+                       candidate->glue);
+  else
+    LOGCOUNTEDREFLITS (cand_ref, SIZE_STACK (*sorted), sorted->begin,
+                       counts, "vivifying sorted irredundant");
+#endif
+
+  vivify_mark_sorted_literals (vivifier);
+
+  unsigned implied = INVALID_LIT;
+  clause *conflict = 0;
+  unsigned level = 0;
+
+  for (all_stack (unsigned, lit, *sorted)) {
+    if (level++ < solver->level) {
+      frame *frame = &FRAME (level);
+      const unsigned not_lit = NOT (lit);
+      if (frame->decision == not_lit) {
+        LOG ("reusing assumption %s", LOGLIT (not_lit));
+        INC (vivify_reused);
+        INC (vivify_probes);
+        KISSAT_assert (VALUE (lit) < 0);
+        continue;
+      }
+
+      LOG ("forced to backtrack to decision level %u", level - 1);
+      kissat_backtrack_without_updating_phases (solver, level - 1);
+    }
+
+    const value value = VALUE (lit);
+    KISSAT_assert (!value || LEVEL (lit) <= level);
+
+    if (value < 0) {
+      KISSAT_assert (LEVEL (lit));
+      LOG ("literal %s already falsified", LOGLIT (lit));
+      continue;
+    }
+
+    if (value > 0) {
+      KISSAT_assert (LEVEL (lit));
+      LOG ("literal %s already initially satisfied", LOGLIT (lit));
+      implied = lit;
+      break;
+    }
+
+    KISSAT_assert (!value);
+
+    LOG ("literal %s unassigned", LOGLIT (lit));
+    const unsigned not_lit = NOT (lit);
+    INC (vivify_probes);
+
+    kissat_internal_assume (solver, not_lit);
+    KISSAT_assert (solver->level >= 1);
+
+    const unsigned *p = solver->propagate;
+    conflict = kissat_probing_propagate (solver, candidate, true);
+    if (conflict)
+      break;
+
+    const unsigned *end = END_ARRAY (solver->trail);
+    const signed char *const marks = solver->marks;
+    while (p != end) {
+      const unsigned other = *p++;
+      const signed char mark = marks[other];
+      if (mark > 0) {
+        LOG ("literal %s already implied satisfied", LOGLIT (other));
+        implied = other;
+        goto EXIT_ASSUMPTION_LOOP;
+      }
+    }
+  }
+EXIT_ASSUMPTION_LOOP:;
+
+#ifdef LOGGING
+  if (!conflict && implied == INVALID_LIT)
+    LOG ("vivification assumptions propagate without conflict nor "
+         "producing an implied literal");
+#endif
+  KISSAT_assert (!conflict || implied == INVALID_LIT);
+
+  if (implied != INVALID_LIT) {
+    unsigned better_implied = INVALID_LIT;
+    unsigned better_implied_trail = INVALID_TRAIL;
+    for (all_stack (unsigned, lit, *sorted)) {
+      if (VALUE (lit) <= 0)
+        continue;
+      unsigned lit_trail = TRAIL (lit);
+      if (lit_trail > better_implied_trail)
+        continue;
+      better_implied_trail = lit_trail;
+      better_implied = lit;
+    }
+    if (better_implied != implied) {
+      LOG ("better implied satisfied literal %s at level %u",
+           LOGLIT (better_implied), LEVEL (better_implied));
+      implied = better_implied;
+    }
+  }
+
+  unsigned level_after_assumptions = solver->level;
+  KISSAT_assert (level_after_assumptions);
+
+  clause *subsuming = 0;
+  bool redundant = false;
+  vivify_deduce (vivifier, candidate, conflict, implied, &subsuming,
+                 &redundant);
+
+  vivify_unmark_sorted_literals (vivifier);
+
+  bool res;
+
+  if (subsuming) {
+    KISSAT_assert (!subsuming->garbage);
+    if (candidate->redundant) {
+      LOGCLS (candidate, "vivification subsumed");
+      kissat_mark_clause_as_garbage (solver, candidate);
+      if (subsuming->redundant && candidate->glue < subsuming->glue) {
+        LOG ("vivify candidate with smaller glue than subsuming clause");
+        kissat_promote_clause (solver, subsuming, candidate->glue);
+      }
+      INC (vivified_subred);
+      INC (vivified_subsumed);
+      res = true;
+    } else if (!subsuming->redundant) {
+      KISSAT_assert (!candidate->redundant);
+      LOGCLS (candidate, "vivification subsumed");
+      kissat_mark_clause_as_garbage (solver, candidate);
+      INC (vivified_subirr);
+      INC (vivified_subsumed);
+      res = true;
+    } else {
+      KISSAT_assert (!candidate->redundant);
+      KISSAT_assert (subsuming->redundant);
+      LOGCLS (candidate, "vivification subsumed");
+      kissat_mark_clause_as_garbage (solver, candidate);
+      subsuming->redundant = false;
+      KISSAT_assert (solver->statistics_.clauses_redundant);
+      solver->statistics_.clauses_redundant--;
+      KISSAT_assert (solver->statistics_.clauses_irredundant < UINT64_MAX);
+      solver->statistics_.clauses_irredundant++;
+      INC (vivified_promoted);
+      LOGCLS (subsuming, "vivification promoted from redundant to");
+      kissat_update_last_irredundant (solver, subsuming);
+      kissat_mark_added_literals (solver, subsuming->size, subsuming->lits);
+      INC (vivified_subirr);
+      INC (vivified_subsumed);
+      res = true;
+    }
+  } else if (vivify_shrinkable (solver, sorted, conflict)) {
+    vivify_learn (solver, candidate, implied);
+    INC (vivified_shrunken);
+    if (candidate->redundant)
+      INC (vivified_shrunkred);
+    else
+      INC (vivified_shrunkirr);
+    res = true;
+  } else if (implied != INVALID_LIT && candidate->redundant) {
+    LOGCLS (candidate, "vivification implied");
+    kissat_mark_clause_as_garbage (solver, candidate);
+    INC (vivified_implied);
+    res = true;
+  } else if ((conflict || implied != INVALID_LIT) &&
+             !candidate->redundant && !redundant) {
+    LOGCLS (candidate, "vivification asymmetric tautology");
+    kissat_mark_clause_as_garbage (solver, candidate);
+    INC (vivified_asym);
+    res = true;
+  } else if (implied != INVALID_LIT) {
+    LOGCLS (candidate,
+            "no vivification instantiation with implied literal %s",
+            LOGLIT (implied));
+    KISSAT_assert (!candidate->redundant);
+    KISSAT_assert (redundant);
+    res = false;
+  } else {
+    KISSAT_assert (solver->level > 2);
+    KISSAT_assert (solver->level == SIZE_STACK (*sorted));
+    unsigned lit = TOP_STACK (*sorted);
+    KISSAT_assert (VALUE (lit) < 0);
+    KISSAT_assert (LEVEL (lit) == solver->level);
+    LOG ("trying vivification instantiation of %s#%u respectively %s#%u",
+         LOGLIT (lit), counts[lit], LOGLIT (NOT (lit)), counts[NOT (lit)]);
+    kissat_backtrack_without_updating_phases (solver, solver->level - 1);
+    conflict = 0;
+    KISSAT_assert (!VALUE (lit));
+    kissat_internal_assume (solver, lit);
+    LOGCLS (candidate, "vivification instantiation candidate");
+    conflict = kissat_probing_propagate (solver, candidate, true);
+    if (conflict) {
+      LOG ("vivification instantiation succeeded");
+      vivify_strengthen_after_instantiation (solver, candidate, lit);
+      INC (vivified_instantiated);
+      if (candidate->redundant)
+        INC (vivified_instred);
+      else
+        INC (vivified_instirr);
+      res = true;
+    } else {
+      LOG ("vivification instantiation failed");
+      kissat_backtrack_without_updating_phases (solver, solver->level - 2);
+      res = false;
+    }
+  }
+
+  reset_vivify_analyzed (vivifier);
+  if (conflict && solver->level == level_after_assumptions) {
+    LOG ("forcing backtracking at least one level after conflict");
+    kissat_backtrack_without_updating_phases (solver, solver->level - 1);
+  }
+  reestablish_watch_invariant_for_candidate (solver, candidate);
+
+  if (res) {
+    INC (vivified);
+    switch (vivifier->tier) {
+    case 1:
+      INC (vivified_tier1);
+      break;
+    case 2:
+      INC (vivified_tier2);
+      break;
+    case 3:
+      INC (vivified_tier3);
+      break;
+    default:
+      KISSAT_assert (vivifier->tier == 0);
+      INC (vivified_irredundant);
+      break;
+    }
+  }
+
+  LOG ("vivification %s", res ? "succeeded" : "failed");
+  return res;
+}
+
+static void vivify_round (vivifier *vivifier, uint64_t limit) {
+  int tier = vivifier->tier;
+  kissat *solver = vivifier->solver;
+
+  if (tier && !REDUNDANT_CLAUSES)
+    return;
+
+  KISSAT_assert (0 <= tier && tier <= 3);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (solver->probing);
+
+  kissat_flush_large_watches (solver);
+
+  schedule_vivification_candidates (vivifier);
+  if (GET_OPTION (vivifysort)) {
+    if (tier || IRREDUNDANT_CLAUSES / 10 <= REDUNDANT_CLAUSES)
+      sort_vivification_candidates (vivifier);
+    else
+      kissat_extremely_verbose (
+          solver, "not sorting %s vivification candidates", vivifier->name);
+  }
+
+  kissat_watch_large_clauses (solver);
+#ifndef KISSAT_QUIET
+  uint64_t start = solver->statistics_.probing_ticks;
+  uint64_t delta = limit - start;
+  kissat_very_verbose (solver,
+                       "vivification %s effort limit %" PRIu64 " = %" PRIu64
+                       " + %" PRIu64 " 'probing_ticks'",
+                       vivifier->name, limit, start, delta);
+  const size_t total = tier ? REDUNDANT_CLAUSES : IRREDUNDANT_CLAUSES;
+  const size_t scheduled = SIZE_STACK (vivifier->schedule);
+  kissat_phase (solver, vivifier->mode, GET (vivifications),
+                "scheduled %zu clauses %.0f%% of %zu", scheduled,
+                kissat_percent (scheduled, total), total);
+#endif
+  KISSAT_assert (!vivifier->vivified);
+  KISSAT_assert (!vivifier->tried);
+  while (!EMPTY_STACK (vivifier->schedule)) {
+    const uint64_t probing_ticks = solver->statistics_.probing_ticks;
+    if (probing_ticks > limit) {
+      kissat_extremely_verbose (solver,
+                                "vivification %s ticks limit %" PRIu64
+                                " hit after %" PRIu64 " 'probing_ticks'",
+                                vivifier->name, limit, probing_ticks);
+      break;
+    }
+    if (TERMINATED (vivify_terminated_1))
+      break;
+    const reference ref = POP_STACK (vivifier->schedule);
+    clause *candidate = kissat_dereference_clause (solver, ref);
+    KISSAT_assert (!candidate->garbage);
+    vivifier->tried++;
+    if (vivify_clause (vivifier, candidate))
+      vivifier->vivified++;
+    if (solver->inconsistent)
+      break;
+    candidate->vivify = false;
+  }
+  if (solver->level)
+    kissat_backtrack_without_updating_phases (solver, 0);
+#ifndef KISSAT_QUIET
+  kissat_phase (solver, vivifier->mode, GET (vivifications),
+                "vivified %zu clauses %.0f%% out of %zu tried",
+                vivifier->vivified,
+                kissat_percent (vivifier->vivified, vivifier->tried),
+                vivifier->tried);
+  if (!solver->inconsistent) {
+    size_t remain = SIZE_STACK (vivifier->schedule);
+    if (remain) {
+      kissat_phase (solver, vivifier->mode, GET (vivifications),
+                    "%zu clauses remain %.0f%% out of %zu scheduled",
+                    remain, kissat_percent (remain, scheduled), scheduled);
+
+      ward *const arena = BEGIN_STACK (solver->arena);
+      size_t prioritized = 0;
+      while (!EMPTY_STACK (vivifier->schedule)) {
+        const reference ref = POP_STACK (vivifier->schedule);
+        clause *c = (clause *) (arena + ref);
+        if (c->vivify)
+          prioritized++;
+      }
+      if (!prioritized)
+        kissat_phase (solver, vivifier->mode, GET (vivifications),
+                      "no remaining prioritized clauses");
+      else
+        kissat_phase (solver, vivifier->mode, GET (vivifications),
+                      "keeping all %zu remaining clauses "
+                      "prioritized %.0f%%",
+                      prioritized, kissat_percent (prioritized, remain));
+    } else
+      kissat_phase (solver, vivifier->mode, GET (vivifications),
+                    "no untried clauses remain");
+  }
+#endif
+  REPORT (!vivifier->vivified, vivifier->tag);
+}
+
+static void vivify_tier1 (vivifier *vivifier, uint64_t limit) {
+#ifndef KISSAT_QUIET
+  kissat *solver = vivifier->solver;
+#endif
+  START (vivify1);
+  set_vivifier_mode (vivifier, 1);
+  vivify_round (vivifier, limit);
+  STOP (vivify1);
+}
+
+static void vivify_tier2 (vivifier *vivifier, uint64_t limit) {
+#ifndef KISSAT_QUIET
+  kissat *solver = vivifier->solver;
+#endif
+  START (vivify2);
+  clear_vivifier (vivifier);
+  set_vivifier_mode (vivifier, 2);
+  vivify_round (vivifier, limit);
+  STOP (vivify2);
+}
+
+static void vivify_tier3 (vivifier *vivifier, uint64_t limit) {
+#ifndef KISSAT_QUIET
+  kissat *solver = vivifier->solver;
+#endif
+  START (vivify3);
+  clear_vivifier (vivifier);
+  set_vivifier_mode (vivifier, 3);
+  vivify_round (vivifier, limit);
+  STOP (vivify3);
+}
+
+static void vivify_irredundant (vivifier *vivifier, uint64_t limit) {
+#ifndef KISSAT_QUIET
+  kissat *solver = vivifier->solver;
+#endif
+  START (vivify0);
+  clear_vivifier (vivifier);
+  set_vivifier_mode (vivifier, 0);
+  vivify_round (vivifier, limit);
+  STOP (vivify0);
+}
+
+void kissat_vivify (kissat *solver) {
+  if (solver->inconsistent)
+    return;
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (solver->probing);
+  KISSAT_assert (solver->watching);
+  if (!GET_OPTION (vivify))
+    return;
+  if (TERMINATED (vivify_terminated_2))
+    return;
+  double irr_budget = DELAYING (vivifyirr) ? 0 : GET_OPTION (vivifyirr);
+  double tier1_budget = GET_OPTION (vivifytier1);
+  double tier2_budget = GET_OPTION (vivifytier2);
+  double tier3_buget = GET_OPTION (vivifytier3);
+  if (!REDUNDANT_CLAUSES)
+    tier1_budget = tier2_budget = tier3_buget = 0;
+  double sum = irr_budget + tier1_budget + tier2_budget + tier3_buget;
+  if (!sum)
+    return;
+
+  START (vivify);
+  INC (vivifications);
+#if !defined(KISSAT_NDEBUG) || defined(METRICS)
+  KISSAT_assert (!solver->vivifying);
+  solver->vivifying = true;
+#endif
+
+  SET_EFFORT_LIMIT (limit, vivify, probing_ticks);
+  const uint64_t total = limit - solver->statistics_.probing_ticks;
+  limit = solver->statistics_.probing_ticks;
+  unsigned tier1_limit = vivify_tier1_limit (solver);
+  unsigned tier2_limit = vivify_tier2_limit (solver);
+  if (tier1_budget && tier2_budget && tier1_limit == tier2_limit) {
+    tier1_budget += tier2_budget, tier2_budget = 0;
+    LOG ("vivification tier1 matches tier2 "
+         "thus using tier2 budget for tier1");
+  }
+
+  {
+    vivifier vivifier;
+    init_vivifier (solver, &vivifier);
+    if (tier1_budget) {
+      limit += (total * tier1_budget) / sum;
+      vivify_tier1 (&vivifier, limit);
+    }
+    if (tier2_budget && !solver->inconsistent &&
+        !TERMINATED (vivify_terminated_3)) {
+      limit += (total * tier2_budget) / sum;
+      vivify_tier2 (&vivifier, limit);
+    }
+    if (tier3_buget && !solver->inconsistent &&
+        !TERMINATED (vivify_terminated_4)) {
+      limit += (total * tier3_buget) / sum;
+      vivify_tier3 (&vivifier, limit);
+    }
+    if (irr_budget && !solver->inconsistent &&
+        !TERMINATED (vivify_terminated_5)) {
+      limit += (total * irr_budget) / sum;
+      vivify_irredundant (&vivifier, limit);
+      if (kissat_average (vivifier.vivified, vivifier.tried) < 0.01)
+        BUMP_DELAY (vivifyirr);
+      else
+        REDUCE_DELAY (vivifyirr);
+    }
+    release_vivifier (&vivifier);
+  }
+
+#ifndef KISSAT_QUIET
+  if (solver->statistics_.probing_ticks < limit) {
+    uint64_t delta = limit - solver->statistics_.probing_ticks;
+    kissat_phase (solver, "vivify-limit", GET (vivifications),
+                  "has %" PRIu64 " ticks left %.2f%%", delta,
+                  kissat_percent (delta, total));
+  } else {
+    uint64_t delta = solver->statistics_.probing_ticks - limit;
+    kissat_phase (solver, "vivify-limit", GET (vivifications),
+                  "exceeded by %" PRIu64 " ticks %.2f%%", delta,
+                  kissat_percent (delta, total));
+  }
+#endif
+#if !defined(KISSAT_NDEBUG) || defined(METRICS)
+  KISSAT_assert (solver->vivifying);
+  solver->vivifying = false;
+#endif
+  STOP (vivify);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/vivify.h b/src/sat/kissat/vivify.h
new file mode 100644
index 000000000..42ec2f2c3
--- /dev/null
+++ b/src/sat/kissat/vivify.h
@@ -0,0 +1,13 @@
+#ifndef _vivify_h_INCLUDED
+#define _vivify_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_vivify (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/walk.c b/src/sat/kissat/walk.c
new file mode 100644
index 000000000..72ce38a6c
--- /dev/null
+++ b/src/sat/kissat/walk.c
@@ -0,0 +1,970 @@
+#include "walk.h"
+#include "allocate.h"
+#include "decide.h"
+#include "dense.h"
+#include "inline.h"
+#include "phases.h"
+#include "print.h"
+#include "rephase.h"
+#include "report.h"
+#include "terminate.h"
+#include "warmup.h"
+
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+typedef struct tagged tagged;
+typedef struct counter counter;
+typedef struct walker walker;
+
+#define LD_MAX_WALK_REF 31
+#define MAX_WALK_REF ((1u << LD_MAX_WALK_REF) - 1)
+
+struct tagged {
+  unsigned ref : LD_MAX_WALK_REF;
+  bool binary : 1;
+};
+
+static inline tagged make_tagged (bool binary, unsigned ref) {
+  KISSAT_assert (ref <= MAX_WALK_REF);
+  tagged res = {.ref = ref, .binary = binary};
+  return res;
+}
+
+struct counter {
+  unsigned count;
+  unsigned pos;
+};
+
+// clang-format off
+typedef STACK (double) doubles;
+// clang-format on
+
+#define INVALID_BEST_TRAIL_POS UINT_MAX
+
+struct walker {
+  kissat *solver;
+
+  unsigned best_trail_pos;
+  unsigned clauses;
+  unsigned current;
+  unsigned exponents;
+  unsigned initial;
+  unsigned minimum;
+  unsigned offset;
+
+  generator random;
+
+  counter *counters;
+  litpairs *binaries;
+  tagged *refs;
+  double *table;
+
+  value *original_values;
+  value *best_values;
+
+  doubles scores;
+  unsigneds unsat;
+  unsigneds trail;
+
+  double size;
+  double epsilon;
+
+  uint64_t limit;
+  uint64_t flipped;
+#ifndef KISSAT_QUIET
+  uint64_t start;
+  struct {
+    uint64_t flipped;
+    unsigned minimum;
+  } report;
+#endif
+};
+
+static const unsigned *dereference_literals (kissat *solver, walker *walker,
+                                             unsigned counter_ref,
+                                             unsigned *size_ptr) {
+  KISSAT_assert (counter_ref < walker->clauses);
+  tagged tagged = walker->refs[counter_ref];
+  unsigned const *lits;
+  if (tagged.binary) {
+    const unsigned binary_ref = tagged.ref;
+    lits = PEEK_STACK (*walker->binaries, binary_ref).lits;
+    *size_ptr = 2;
+  } else {
+    const reference clause_ref = tagged.ref;
+    clause *c = kissat_dereference_clause (solver, clause_ref);
+    *size_ptr = c->size;
+    lits = c->lits;
+  }
+  return lits;
+}
+
+static void push_unsat (kissat *solver, walker *walker, counter *counters,
+                        unsigned counter_ref) {
+  KISSAT_assert (counter_ref < walker->clauses);
+  counter *counter = counters + counter_ref;
+  KISSAT_assert (SIZE_STACK (walker->unsat) <= UINT_MAX);
+  counter->pos = SIZE_STACK (walker->unsat);
+  PUSH_STACK (walker->unsat, counter_ref);
+#ifdef LOGGING
+  unsigned size;
+  const unsigned *const lits =
+      dereference_literals (solver, walker, counter_ref, &size);
+  LOGLITS (size, lits, "pushed unsatisfied[%u]", counter->pos);
+#endif
+}
+
+static bool pop_unsat (kissat *solver, walker *walker, counter *counters,
+                       unsigned counter_ref, unsigned pos) {
+  KISSAT_assert (walker->current);
+  KISSAT_assert (counter_ref < walker->clauses);
+  KISSAT_assert (counters[counter_ref].pos == pos);
+  KISSAT_assert (walker->current == SIZE_STACK (walker->unsat));
+  const unsigned other_counter_ref = POP_STACK (walker->unsat);
+  walker->current--;
+  bool res = false;
+  if (counter_ref != other_counter_ref) {
+    KISSAT_assert (other_counter_ref < walker->clauses);
+    counter *other_counter = counters + other_counter_ref;
+    KISSAT_assert (other_counter->pos == walker->current);
+    KISSAT_assert (pos < other_counter->pos);
+    other_counter->pos = pos;
+    POKE_STACK (walker->unsat, pos, other_counter_ref);
+    res = true;
+  }
+#ifdef LOGGING
+  unsigned size;
+  const unsigned *const lits =
+      dereference_literals (solver, walker, counter_ref, &size);
+  LOGLITS (size, lits, "popped unsatisfied[%u]", pos);
+#else
+  (void) solver;
+#endif
+  return res;
+}
+
+static double cbvals[][2] = {{0.0, 2.00}, {3.0, 2.50}, {4.0, 2.85},
+                             {5.0, 3.70}, {6.0, 5.10}, {7.0, 7.40}};
+
+static double fit_cbval (double size) {
+  const size_t num_cbvals = sizeof cbvals / sizeof *cbvals;
+  size_t i = 0;
+  while (i + 2 < num_cbvals &&
+         (cbvals[i][0] > size || cbvals[i + 1][0] < size))
+    i++;
+  const double x2 = cbvals[i + 1][0], x1 = cbvals[i][0];
+  const double y2 = cbvals[i + 1][1], y1 = cbvals[i][1];
+  const double dx = x2 - x1, dy = y2 - y1;
+  KISSAT_assert (dx);
+  const double res = dy * (size - x1) / dx + y1;
+  KISSAT_assert (res > 0);
+  return res;
+}
+
+static void init_score_table (walker *walker) {
+  kissat *solver = walker->solver;
+
+  const double cb = (GET (walks) & 1) ? fit_cbval (walker->size) : 2.0;
+  const double base = 1 / cb;
+
+  double next;
+  unsigned exponents = 0;
+  for (next = 1; next; next *= base)
+    exponents++;
+
+  walker->table = (double*)kissat_malloc (solver, exponents * sizeof (double));
+
+  unsigned i = 0;
+  double epsilon;
+  for (epsilon = next = 1; next; next = epsilon * base)
+    walker->table[i++] = epsilon = next;
+
+  KISSAT_assert (i == exponents);
+  walker->exponents = exponents;
+  walker->epsilon = epsilon;
+
+  kissat_phase (solver, "walk", GET (walks),
+                "CB %.2f with inverse %.2f as base", cb, base);
+  kissat_phase (solver, "walk", GET (walks), "table size %u and epsilon %g",
+                exponents, epsilon);
+}
+
+static unsigned currently_unsatified (walker *walker) {
+  return SIZE_STACK (walker->unsat);
+}
+
+static void import_decision_phases (walker *walker) {
+  kissat *solver = walker->solver;
+  INC (walk_decisions);
+  const flags *const flags = solver->flags;
+  value *values = solver->values;
+  walker->best_values = (value*)kissat_calloc (solver, VARS, 1);
+  value *best_values = walker->best_values;
+#ifndef KISSAT_QUIET
+  unsigned imported = 0;
+#endif
+  for (all_variables (idx)) {
+    if (!flags[idx].active)
+      continue;
+    value value = kissat_decide_phase (solver, idx);
+    KISSAT_assert (value);
+    best_values[idx] = value;
+    const unsigned lit = LIT (idx);
+    const unsigned not_lit = NOT (lit);
+    values[lit] = value;
+    values[not_lit] = -value;
+#ifndef KISSAT_QUIET
+    imported++;
+#endif
+    LOG ("copied %s decision phase %d", LOGVAR (idx), (int) value);
+  }
+  kissat_phase (solver, "walk", GET (walks),
+                "imported %u decision phases %.0f%%", imported,
+                kissat_percent (imported, solver->active));
+}
+
+static unsigned connect_binary_counters (walker *walker) {
+  kissat *solver = walker->solver;
+  value *values = solver->values;
+  tagged *refs = walker->refs;
+  watches *all_watches = solver->watches;
+  counter *counters = walker->counters;
+
+  KISSAT_assert (SIZE_STACK (*walker->binaries) <= UINT_MAX);
+  const unsigned size = SIZE_STACK (*walker->binaries);
+  litpair *binaries = BEGIN_STACK (*walker->binaries);
+  unsigned unsat = 0, counter_ref = 0;
+
+  for (unsigned binary_ref = 0; binary_ref < size; binary_ref++) {
+    const litpair *const litpair = binaries + binary_ref;
+    const unsigned first = litpair->lits[0];
+    const unsigned second = litpair->lits[1];
+    KISSAT_assert (first < LITS), KISSAT_assert (second < LITS);
+    const value first_value = values[first];
+    const value second_value = values[second];
+    if (!first_value || !second_value)
+      continue;
+    KISSAT_assert (counter_ref < walker->clauses);
+    refs[counter_ref] = make_tagged (true, binary_ref);
+    watches *first_watches = all_watches + first;
+    watches *second_watches = all_watches + second;
+    kissat_push_large_watch (solver, first_watches, counter_ref);
+    kissat_push_large_watch (solver, second_watches, counter_ref);
+    const unsigned count = (first_value > 0) + (second_value > 0);
+    counter *counter = counters + counter_ref;
+    counter->count = count;
+    if (!count) {
+      push_unsat (solver, walker, counters, counter_ref);
+      unsat++;
+    }
+    counter_ref++;
+  }
+  kissat_phase (solver, "walk", GET (walks),
+                "initially %u unsatisfied binary clauses %.0f%% out of %u",
+                unsat, kissat_percent (unsat, counter_ref), counter_ref);
+#ifdef KISSAT_QUIET
+  (void) unsat;
+#endif
+  walker->size += 2.0 * counter_ref;
+  return counter_ref;
+}
+
+static void connect_large_counters (walker *walker, unsigned counter_ref) {
+  kissat *solver = walker->solver;
+  KISSAT_assert (!solver->level);
+  const value *const original_values = walker->original_values;
+  const value *const local_search_values = solver->values;
+  ward *const arena = BEGIN_STACK (solver->arena);
+  counter *counters = walker->counters;
+  tagged *refs = walker->refs;
+
+  unsigned unsat = 0;
+  unsigned large = 0;
+
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+
+  for (all_clauses (c)) {
+    if (last_irredundant && c > last_irredundant)
+      break;
+    if (c->garbage)
+      continue;
+    if (c->redundant)
+      continue;
+    bool continue_with_next_clause = false;
+    for (all_literals_in_clause (lit, c)) {
+      const value value = original_values[lit];
+      if (value <= 0)
+        continue;
+      LOGCLS (c, "%s satisfied", LOGLIT (lit));
+      kissat_mark_clause_as_garbage (solver, c);
+      KISSAT_assert (c->garbage);
+      continue_with_next_clause = true;
+      break;
+    }
+    if (continue_with_next_clause)
+      continue;
+    large++;
+    KISSAT_assert (kissat_clause_in_arena (solver, c));
+    reference clause_ref = (ward *) c - arena;
+    KISSAT_assert (clause_ref <= MAX_WALK_REF);
+    KISSAT_assert (counter_ref < walker->clauses);
+    refs[counter_ref] = make_tagged (false, clause_ref);
+    unsigned count = 0, size = 0;
+    for (all_literals_in_clause (lit, c)) {
+      const value value = local_search_values[lit];
+      if (!value) {
+        KISSAT_assert (original_values[lit] < 0);
+        continue;
+      }
+      watches *watches = &WATCHES (lit);
+      kissat_push_large_watch (solver, watches, counter_ref);
+      size++;
+      if (value > 0)
+        count++;
+    }
+    counter *counter = walker->counters + counter_ref;
+    counter->count = count;
+
+    if (!count) {
+      push_unsat (solver, walker, counters, counter_ref);
+      unsat++;
+    }
+    counter_ref++;
+    walker->size += size;
+  }
+  kissat_phase (solver, "walk", GET (walks),
+                "initially %u unsatisfied large clauses %.0f%% out of %u",
+                unsat, kissat_percent (unsat, large), large);
+#ifdef KISSAT_QUIET
+  (void) large;
+  (void) unsat;
+#endif
+}
+
+#ifndef KISSAT_QUIET
+
+static void report_initial_minimum (kissat *solver, walker *walker) {
+  walker->report.minimum = walker->minimum;
+  kissat_very_verbose (solver, "initial minimum of %u unsatisfied clauses",
+                       walker->minimum);
+}
+
+static void report_minimum (const char *type, kissat *solver,
+                            walker *walker) {
+  KISSAT_assert (walker->minimum <= walker->report.minimum);
+  kissat_very_verbose (solver,
+                       "%s minimum of %u unsatisfied clauses after %" PRIu64
+                       " flipped literals",
+                       type, walker->minimum, walker->flipped);
+  walker->report.minimum = walker->minimum;
+}
+#else
+#define report_initial_minimum(...) \
+  do { \
+  } while (0)
+#define report_minimum(...) \
+  do { \
+  } while (0)
+#endif
+
+static void init_walker (kissat *solver, walker *walker,
+                         litpairs *binaries) {
+  uint64_t clauses = BINIRR_CLAUSES;
+  KISSAT_assert (clauses <= MAX_WALK_REF);
+
+  memset (walker, 0, sizeof *walker);
+
+  walker->solver = solver;
+  walker->clauses = clauses;
+  walker->binaries = binaries;
+  walker->random = solver->random ^ solver->statistics_.walks;
+
+  walker->original_values = solver->values;
+  solver->values = (value*)kissat_calloc (solver, LITS, 1);
+
+  import_decision_phases (walker);
+
+  walker->counters = (counter*)kissat_malloc (solver, clauses * sizeof (counter));
+  walker->refs = (tagged*)kissat_malloc (solver, clauses * sizeof (tagged));
+
+  KISSAT_assert (!walker->size);
+  const unsigned counter_ref = connect_binary_counters (walker);
+  connect_large_counters (walker, counter_ref);
+
+  walker->current = walker->initial = currently_unsatified (walker);
+
+  kissat_phase (solver, "walk", GET (walks),
+                "initially %u unsatisfied irredundant clauses %.0f%% "
+                "out of %" PRIu64,
+                walker->initial, kissat_percent (walker->initial, clauses),
+                clauses);
+
+  walker->size = kissat_average (walker->size, clauses);
+  kissat_phase (solver, "walk", GET (walks), "average clause size %.2f",
+                walker->size);
+
+  walker->minimum = walker->current;
+  init_score_table (walker);
+
+  report_initial_minimum (solver, walker);
+}
+
+static void init_walker_limit (kissat *solver, walker *walker) {
+  SET_EFFORT_LIMIT (limit, walk, walk_steps);
+  walker->limit = limit;
+  walker->flipped = 0;
+#ifndef KISSAT_QUIET
+  walker->start = solver->statistics_.walk_steps;
+  walker->report.minimum = UINT_MAX;
+  walker->report.flipped = 0;
+#endif
+}
+
+static void release_walker (walker *walker) {
+  kissat *solver = walker->solver;
+  kissat_dealloc (solver, walker->table, walker->exponents,
+                  sizeof (double));
+  unsigned clauses = walker->clauses;
+  kissat_dealloc (solver, walker->refs, clauses, sizeof (tagged));
+  kissat_dealloc (solver, walker->counters, clauses, sizeof (counter));
+  RELEASE_STACK (walker->unsat);
+  RELEASE_STACK (walker->scores);
+  RELEASE_STACK (walker->trail);
+  kissat_free (solver, solver->values, LITS);
+  kissat_free (solver, walker->best_values, VARS);
+  RELEASE_STACK (walker->unsat);
+  solver->values = walker->original_values;
+}
+
+static unsigned break_value (kissat *solver, walker *walker, value *values,
+                             unsigned lit) {
+  KISSAT_assert (values[lit] < 0);
+  const unsigned not_lit = NOT (lit);
+  watches *watches = &WATCHES (not_lit);
+  unsigned steps = 1;
+  unsigned res = 0;
+  for (all_binary_large_watches (watch, *watches)) {
+    steps++;
+    KISSAT_assert (!watch.type.binary);
+    reference counter_ref = watch.large.ref;
+    KISSAT_assert (counter_ref < walker->clauses);
+    counter *counter = walker->counters + counter_ref;
+    res += (counter->count == 1);
+  }
+  ADD (walk_steps, steps);
+#ifdef KISSAT_NDEBUG
+  (void) values;
+#endif
+  return res;
+}
+
+static double scale_score (walker *walker, unsigned breaks) {
+  if (breaks < walker->exponents)
+    return walker->table[breaks];
+  else
+    return walker->epsilon;
+}
+
+static unsigned pick_literal (kissat *solver, walker *walker) {
+  KISSAT_assert (walker->current == SIZE_STACK (walker->unsat));
+  const unsigned pos = walker->flipped++ % walker->current;
+  const unsigned counter_ref = PEEK_STACK (walker->unsat, pos);
+  unsigned size;
+  const unsigned *const lits =
+      dereference_literals (solver, walker, counter_ref, &size);
+
+  LOGLITS (size, lits, "picked unsatisfied[%u]", pos);
+  KISSAT_assert (EMPTY_STACK (walker->scores));
+
+  value *values = solver->values;
+
+  double sum = 0;
+  unsigned picked_lit = INVALID_LIT;
+
+  const unsigned *const end_of_lits = lits + size;
+  for (const unsigned *p = lits; p != end_of_lits; p++) {
+    const unsigned lit = *p;
+    if (!values[lit])
+      continue;
+    picked_lit = lit;
+    const unsigned breaks = break_value (solver, walker, values, lit);
+    const double score = scale_score (walker, breaks);
+    KISSAT_assert (score > 0);
+    LOG ("literal %s breaks %u score %g", LOGLIT (lit), breaks, score);
+    PUSH_STACK (walker->scores, score);
+    sum += score;
+  }
+  KISSAT_assert (picked_lit != INVALID_LIT);
+  KISSAT_assert (0 < sum);
+
+  const double random = kissat_pick_double (&walker->random);
+  KISSAT_assert (0 <= random), KISSAT_assert (random < 1);
+
+  const double threshold = sum * random;
+  LOG ("score sum %g and random threshold %g", sum, threshold);
+
+  // KISSAT_assert (threshold < sum); // NOT TRUE!!!!
+
+  double *scores = BEGIN_STACK (walker->scores);
+#ifdef LOGGING
+  double picked_score = 0;
+#endif
+
+  sum = 0;
+
+  for (const unsigned *p = lits; p != end_of_lits; p++) {
+    const unsigned lit = *p;
+    if (!values[lit])
+      continue;
+    const double score = *scores++;
+    sum += score;
+    if (threshold < sum) {
+      picked_lit = lit;
+#ifdef LOGGING
+      picked_score = score;
+#endif
+      break;
+    }
+  }
+  KISSAT_assert (picked_lit != INVALID_LIT);
+  LOG ("picked literal %s with score %g", LOGLIT (picked_lit),
+       picked_score);
+
+  CLEAR_STACK (walker->scores);
+
+  return picked_lit;
+}
+
+static void break_clauses (kissat *solver, walker *walker,
+                           const value *const values, unsigned flipped) {
+#ifdef LOGGING
+  unsigned broken = 0;
+#endif
+  const unsigned not_flipped = NOT (flipped);
+  KISSAT_assert (values[not_flipped] < 0);
+  LOG ("breaking one-satisfied clauses containing negated flipped literal "
+       "%s",
+       LOGLIT (not_flipped));
+  watches *watches = &WATCHES (not_flipped);
+  counter *counters = walker->counters;
+  unsigned steps = 1;
+  for (all_binary_large_watches (watch, *watches)) {
+    steps++;
+    KISSAT_assert (!watch.type.binary);
+    const unsigned counter_ref = watch.large.ref;
+    KISSAT_assert (counter_ref < walker->clauses);
+    counter *counter = counters + counter_ref;
+    KISSAT_assert (counter->count);
+    if (--counter->count)
+      continue;
+    push_unsat (solver, walker, counters, counter_ref);
+#ifdef LOGGING
+    broken++;
+#endif
+  }
+  LOG ("broken %u one-satisfied clauses containing "
+       "negated flipped literal %s",
+       broken, LOGLIT (not_flipped));
+  ADD (walk_steps, steps);
+#ifdef KISSAT_NDEBUG
+  (void) values;
+#endif
+}
+
+static void make_clauses (kissat *solver, walker *walker,
+                          const value *const values, unsigned flipped) {
+  KISSAT_assert (values[flipped] > 0);
+  LOG ("making unsatisfied clauses containing flipped literal %s",
+       LOGLIT (flipped));
+  watches *watches = &WATCHES (flipped);
+  counter *counters = walker->counters;
+  unsigned steps = 1;
+#ifdef LOGGING
+  unsigned made = 0;
+#endif
+  for (all_binary_large_watches (watch, *watches)) {
+    steps++;
+    KISSAT_assert (!watch.type.binary);
+    const unsigned counter_ref = watch.large.ref;
+    KISSAT_assert (counter_ref < walker->clauses);
+    counter *counter = counters + counter_ref;
+    KISSAT_assert (counter->count < UINT_MAX);
+    if (counter->count++)
+      continue;
+    if (pop_unsat (solver, walker, counters, counter_ref, counter->pos))
+      steps++;
+#ifdef LOGGING
+    made++;
+#endif
+  }
+  LOG ("made %u unsatisfied clauses containing flipped literal %s", made,
+       LOGLIT (flipped));
+  ADD (walk_steps, steps);
+#ifdef KISSAT_NDEBUG
+  (void) values;
+#endif
+}
+
+static void save_all_values (kissat *solver, walker *walker) {
+  KISSAT_assert (EMPTY_STACK (walker->trail));
+  KISSAT_assert (walker->best_trail_pos == INVALID_BEST_TRAIL_POS);
+  LOG ("copying all values as best phases since trail is invalid");
+  const value *const current_values = solver->values;
+  value *best_values = walker->best_values;
+  for (all_variables (idx)) {
+    const unsigned lit = LIT (idx);
+    const value value = current_values[lit];
+    if (value)
+      best_values[idx] = value;
+  }
+  LOG ("reset best trail position to 0");
+  walker->best_trail_pos = 0;
+}
+
+static void save_walker_trail (kissat *solver, walker *walker, bool keep) {
+#if defined(LOGGING) || !defined(KISSAT_NDEBUG)
+  KISSAT_assert (walker->best_trail_pos != INVALID_BEST_TRAIL_POS);
+  KISSAT_assert (SIZE_STACK (walker->trail) <= UINT_MAX);
+  const unsigned size_trail = SIZE_STACK (walker->trail);
+  KISSAT_assert (walker->best_trail_pos <= size_trail);
+  const unsigned kept = size_trail - walker->best_trail_pos;
+  LOG ("saving %u values of flipped literals on trail of size %u",
+       walker->best_trail_pos, size_trail);
+#else
+  (void) solver;
+#endif
+  value *best_values = walker->best_values;
+  unsigned *begin = BEGIN_STACK (walker->trail);
+  const unsigned *const best = begin + walker->best_trail_pos;
+  for (const unsigned *p = begin; p != best; p++) {
+    const unsigned lit = *p;
+    const value value = NEGATED (lit) ? -1 : 1;
+    const unsigned idx = IDX (lit);
+    best_values[idx] = value;
+  }
+  if (!keep) {
+    LOG ("no need to shift and keep remaining %u literals", kept);
+    return;
+  }
+  LOG ("flushed %u literals %.0f%% from trail", walker->best_trail_pos,
+       kissat_percent (walker->best_trail_pos, size_trail));
+  const unsigned *const end = END_STACK (walker->trail);
+  unsigned *q = begin;
+  for (const unsigned *p = best; p != end; p++)
+    *q++ = *p;
+  KISSAT_assert ((size_t) (end - q) == walker->best_trail_pos);
+  KISSAT_assert ((size_t) (q - begin) == kept);
+  SET_END_OF_STACK (walker->trail, q);
+  LOG ("keeping %u literals %.0f%% on trail", kept,
+       kissat_percent (kept, size_trail));
+  LOG ("reset best trail position to 0");
+  walker->best_trail_pos = 0;
+}
+
+static void push_flipped (kissat *solver, walker *walker,
+                          unsigned flipped) {
+  if (walker->best_trail_pos == INVALID_BEST_TRAIL_POS) {
+    LOG ("not pushing flipped %s to already invalid trail",
+         LOGLIT (flipped));
+    KISSAT_assert (EMPTY_STACK (walker->trail));
+  } else {
+    KISSAT_assert (SIZE_STACK (walker->trail) <= UINT_MAX);
+    const unsigned size_trail = SIZE_STACK (walker->trail);
+    KISSAT_assert (walker->best_trail_pos <= size_trail);
+    const unsigned limit = VARS / 4 + 1;
+    KISSAT_assert (limit < INVALID_BEST_TRAIL_POS);
+    if (size_trail < limit) {
+      PUSH_STACK (walker->trail, flipped);
+      LOG ("pushed flipped %s to trail which now has size %u",
+           LOGLIT (flipped), size_trail + 1);
+    } else if (walker->best_trail_pos) {
+      LOG ("trail reached limit %u but has best position %u", limit,
+           walker->best_trail_pos);
+      save_walker_trail (solver, walker, true);
+      PUSH_STACK (walker->trail, flipped);
+      KISSAT_assert (SIZE_STACK (walker->trail) <= UINT_MAX);
+      LOG ("pushed flipped %s to trail which now has size %zu",
+           LOGLIT (flipped), SIZE_STACK (walker->trail));
+    } else {
+      LOG ("trail reached limit %u without best position", limit);
+      CLEAR_STACK (walker->trail);
+      LOG ("not pushing %s to invalidated trail", LOGLIT (flipped));
+      walker->best_trail_pos = INVALID_BEST_TRAIL_POS;
+      LOG ("best trail position becomes invalid");
+    }
+  }
+}
+
+static void flip_literal (kissat *solver, walker *walker, unsigned flip) {
+  LOG ("flipping literal %s", LOGLIT (flip));
+  value *values = solver->values;
+  const value value = values[flip];
+  KISSAT_assert (value < 0);
+  values[flip] = -value;
+  values[NOT (flip)] = value;
+  make_clauses (solver, walker, values, flip);
+  break_clauses (solver, walker, values, flip);
+  walker->current = currently_unsatified (walker);
+}
+
+static void update_best (kissat *solver, walker *walker) {
+  KISSAT_assert (walker->current < walker->minimum);
+  walker->minimum = walker->current;
+#ifndef KISSAT_QUIET
+  int verbosity = kissat_verbosity (solver);
+  bool report = (verbosity > 2);
+  if (verbosity == 2) {
+    if (walker->flipped / 2 >= walker->report.flipped)
+      report = true;
+    else if (walker->minimum < 5 || walker->report.minimum == UINT_MAX ||
+             walker->minimum <= walker->report.minimum / 2)
+      report = true;
+    if (report) {
+      walker->report.minimum = walker->minimum;
+      walker->report.flipped = walker->flipped;
+    }
+  }
+  if (report)
+    report_minimum ("new", solver, walker);
+#endif
+  if (walker->best_trail_pos == INVALID_BEST_TRAIL_POS)
+    save_all_values (solver, walker);
+  else {
+    KISSAT_assert (SIZE_STACK (walker->trail) < INVALID_BEST_TRAIL_POS);
+    walker->best_trail_pos = SIZE_STACK (walker->trail);
+    LOG ("new best trail position %u", walker->best_trail_pos);
+  }
+}
+
+static void local_search_step (kissat *solver, walker *walker) {
+  KISSAT_assert (walker->current);
+  INC (flipped);
+  KISSAT_assert (walker->flipped < UINT64_MAX);
+  walker->flipped++;
+  LOG ("starting local search flip %" PRIu64 " with %u unsatisfied clauses",
+       GET (flipped), walker->current);
+  unsigned lit = pick_literal (solver, walker);
+  flip_literal (solver, walker, lit);
+  push_flipped (solver, walker, lit);
+  if (walker->current < walker->minimum)
+    update_best (solver, walker);
+  LOG ("ending local search step %" PRIu64 " with %u unsatisfied clauses",
+       GET (flipped), walker->current);
+}
+
+static void local_search_round (walker *walker) {
+  kissat *solver = walker->solver;
+#ifndef KISSAT_QUIET
+  const unsigned before = walker->minimum;
+#endif
+  statistics *statistics = &solver->statistics_;
+  while (walker->minimum && walker->limit > statistics->walk_steps) {
+    if (TERMINATED (walk_terminated_1))
+      break;
+    local_search_step (solver, walker);
+  }
+#ifndef KISSAT_QUIET
+  report_minimum ("last", solver, walker);
+  KISSAT_assert (statistics->walk_steps >= walker->start);
+  const uint64_t steps = statistics->walk_steps - walker->start;
+  // clang-format off
+  kissat_very_verbose (solver,
+    "walking ends with %u unsatisfied clauses", walker->current);
+  kissat_very_verbose (solver,
+    "flipping %" PRIu64 " literals took %" PRIu64 " steps (%.2f per flipped)",
+    walker->flipped, steps, kissat_average (steps, walker->flipped));
+  // clang-format on
+  const unsigned after = walker->minimum;
+  kissat_phase (
+      solver, "walk", GET (walks), "%s minimum %u after %" PRIu64 " flips",
+      after < before ? "new" : "unchanged", after, walker->flipped);
+#endif
+}
+
+static void export_best_values (walker *walker) {
+  kissat *const solver = walker->solver;
+  const value *const best = walker->best_values;
+  value *const saved = solver->phases.saved;
+  KISSAT_assert (sizeof *saved == 1);
+  KISSAT_assert (sizeof *best == 1);
+  memcpy (saved, best, VARS);
+}
+
+static bool save_final_minimum (walker *walker) {
+  kissat *solver = walker->solver;
+
+  KISSAT_assert (walker->minimum <= walker->initial);
+  if (walker->minimum == walker->initial) {
+    kissat_phase (solver, "walk", GET (walks),
+                  "no improvement thus keeping saved phases");
+    return false;
+  }
+
+  kissat_phase (solver, "walk", GET (walks),
+                "saving improved assignment of %u unsatisfied clauses",
+                walker->minimum);
+
+  if (!walker->best_trail_pos ||
+      walker->best_trail_pos == INVALID_BEST_TRAIL_POS)
+    LOG ("minimum already saved");
+  else
+    save_walker_trail (solver, walker, false);
+
+  export_best_values (walker);
+  INC (walk_improved);
+
+  return true;
+}
+
+#ifdef CHECK_WALK
+
+static void check_walk (kissat *solver, unsigned expected) {
+  unsigned unsatisfied = 0;
+  watches *all_watches = solver->watches;
+  const value *const saved = solver->phases.saved;
+  for (all_literals (lit)) {
+    KISSAT_assert (lit < LITS);
+    watches *watches = all_watches + lit;
+    if (kissat_empty_vector (watches))
+      continue;
+    value value = solver->values[lit];
+    if (!value) {
+      value = saved[IDX (lit)];
+      KISSAT_assert (value);
+      if (NEGATED (lit))
+        value = -value;
+    }
+    if (value > 0)
+      continue;
+    for (all_binary_blocking_watches (watch, *watches))
+      if (watch.type.binary) {
+        const unsigned other = watch.binary.lit;
+        if (other < lit)
+          continue;
+        value = solver->values[other];
+        if (!value) {
+          value = saved[IDX (other)];
+          KISSAT_assert (value);
+          if (NEGATED (other))
+            value = -value;
+        }
+        if (value > 0)
+          continue;
+        unsatisfied++;
+        LOGBINARY (lit, other, "unsat");
+      }
+  }
+  for (all_clauses (c)) {
+    if (c->redundant)
+      continue;
+    if (c->garbage)
+      continue;
+    bool satisfied = false;
+    for (all_literals_in_clause (lit, c)) {
+      value value = solver->values[lit];
+      if (!value) {
+        value = saved[IDX (lit)];
+        KISSAT_assert (value);
+        if (NEGATED (lit))
+          value = -value;
+      }
+      if (value > 0)
+        satisfied = true;
+    }
+    if (satisfied)
+      continue;
+    LOGCLS (c, "unsatisfied");
+    unsatisfied++;
+  }
+  LOG ("expected %u unsatisfied", expected);
+  LOG ("actually %u unsatisfied", unsatisfied);
+  KISSAT_assert (expected == unsatisfied);
+}
+
+#endif
+
+static void walking_phase (kissat *solver) {
+  INC (walks);
+  litpairs irredundant;
+  INIT_STACK (irredundant);
+  kissat_enter_dense_mode (solver, &irredundant);
+  walker walker;
+  init_walker (solver, &walker, &irredundant);
+  init_walker_limit (solver, &walker);
+  local_search_round (&walker);
+#ifdef CHECK_WALK
+  bool improved =
+#endif
+      save_final_minimum (&walker);
+#ifdef CHECK_WALK
+  unsigned expected = walker.minimum;
+#endif
+  release_walker (&walker);
+  kissat_resume_sparse_mode (solver, false, &irredundant);
+  RELEASE_STACK (irredundant);
+#if CHECK_WALK
+  if (improved)
+    check_walk (solver, expected);
+#endif
+}
+
+bool kissat_walking (kissat *solver) {
+  reference last_irredundant = solver->last_irredundant;
+  if (last_irredundant == INVALID_REF)
+    last_irredundant = SIZE_STACK (solver->arena);
+
+  if (last_irredundant > MAX_WALK_REF) {
+    kissat_extremely_verbose (solver,
+                              "can not walk since last "
+                              "irredundant clause reference %u too large",
+                              last_irredundant);
+    return false;
+  }
+
+  uint64_t clauses = BINIRR_CLAUSES;
+  if (clauses > MAX_WALK_REF) {
+    kissat_extremely_verbose (solver,
+                              "can not walk due to "
+                              "way too many irredundant clauses %" PRIu64,
+                              clauses);
+    return false;
+  }
+
+  return true;
+}
+
+void kissat_walk (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (kissat_propagated (solver));
+  KISSAT_assert (kissat_walking (solver));
+
+  reference last_irredundant = solver->last_irredundant;
+  if (last_irredundant == INVALID_REF)
+    last_irredundant = SIZE_STACK (solver->arena);
+
+  if (last_irredundant > MAX_WALK_REF) {
+    kissat_phase (solver, "walk", GET (walks),
+                  "last irredundant clause reference %u too large",
+                  last_irredundant);
+    return;
+  }
+
+  uint64_t clauses = BINIRR_CLAUSES;
+  if (clauses > MAX_WALK_REF) {
+    kissat_phase (solver, "walk", GET (walks),
+                  "way too many irredundant clauses %" PRIu64, clauses);
+    return;
+  }
+
+  if (GET_OPTION (warmup))
+    kissat_warmup (solver);
+
+  STOP_SEARCH_AND_START_SIMPLIFIER (walking);
+  walking_phase (solver);
+  STOP_SIMPLIFIER_AND_RESUME_SEARCH (walking);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/walk.h b/src/sat/kissat/walk.h
new file mode 100644
index 000000000..43e626091
--- /dev/null
+++ b/src/sat/kissat/walk.h
@@ -0,0 +1,16 @@
+#ifndef _walk_h_INCLUDED
+#define _walk_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+bool kissat_walking (struct kissat *);
+void kissat_walk (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/warmup.c b/src/sat/kissat/warmup.c
new file mode 100644
index 000000000..fe7b981f8
--- /dev/null
+++ b/src/sat/kissat/warmup.c
@@ -0,0 +1,58 @@
+#include "warmup.h"
+#include "backtrack.h"
+#include "decide.h"
+#include "internal.h"
+#include "print.h"
+#include "propbeyond.h"
+#include "terminate.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_warmup (kissat *solver) {
+  KISSAT_assert (!solver->level);
+  KISSAT_assert (solver->watching);
+  KISSAT_assert (!solver->inconsistent);
+  KISSAT_assert (GET_OPTION (warmup));
+  START (warmup);
+  KISSAT_assert (!solver->warming);
+  solver->warming = true;
+  INC (warmups);
+#ifndef KISSAT_QUIET
+  const statistics *stats = &solver->statistics;
+  uint64_t propagations = stats->warming_propagations;
+  uint64_t decisions = stats->warming_decisions;
+#endif
+  while (solver->unassigned) {
+    if (TERMINATED (warmup_terminated_1))
+      break;
+    kissat_decide (solver);
+    kissat_propagate_beyond_conflicts (solver);
+  }
+  KISSAT_assert (!solver->inconsistent);
+#ifndef KISSAT_QUIET
+  decisions = stats->warming_decisions - decisions;
+  propagations = stats->warming_propagations - propagations;
+
+  kissat_very_verbose (solver,
+                       "warming-up needed %" PRIu64
+                       " decisions and %" PRIu64 " propagations",
+                       decisions, propagations);
+
+  if (solver->unassigned)
+    kissat_verbose (solver,
+                    "reached decision level %u "
+                    "during warming-up saved phases",
+                    solver->level);
+  else
+    kissat_verbose (solver,
+                    "all variables assigned at decision level %u "
+                    "during warming-up saved phases",
+                    solver->level);
+#endif
+  kissat_backtrack_without_updating_phases (solver, 0);
+  KISSAT_assert (solver->warming);
+  solver->warming = false;
+  STOP (warmup);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/warmup.h b/src/sat/kissat/warmup.h
new file mode 100644
index 000000000..23cd6c7a7
--- /dev/null
+++ b/src/sat/kissat/warmup.h
@@ -0,0 +1,13 @@
+#ifndef _warmup_h_INCLUDED
+#define _warmup_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_warmup (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/watch.c b/src/sat/kissat/watch.c
new file mode 100644
index 000000000..78f9a69ce
--- /dev/null
+++ b/src/sat/kissat/watch.c
@@ -0,0 +1,227 @@
+#define INLINE_SORT
+
+#include "inline.h"
+#include "sort.c"
+
+ABC_NAMESPACE_IMPL_START
+
+void kissat_remove_binary_watch (kissat *solver, watches *watches,
+                                 unsigned lit) {
+  watch *const begin = BEGIN_WATCHES (*watches);
+  watch *const end = END_WATCHES (*watches);
+  watch *q = begin;
+  watch const *p = q;
+#ifndef KISSAT_NDEBUG
+  bool found = false;
+#endif
+  while (p != end) {
+    const watch watch = *q++ = *p++;
+    if (!watch.type.binary) {
+      *q++ = *p++;
+      continue;
+    }
+    const unsigned other = watch.binary.lit;
+    if (other != lit)
+      continue;
+#ifndef KISSAT_NDEBUG
+    KISSAT_assert (!found);
+    found = true;
+#endif
+    q--;
+  }
+  KISSAT_assert (found);
+#ifdef KISSAT_COMPACT
+  watches->size -= 1;
+#else
+  KISSAT_assert (begin + 1 <= end);
+  watches->end -= 1;
+#endif
+  const watch empty = {.raw = INVALID_VECTOR_ELEMENT};
+  end[-1] = empty;
+  KISSAT_assert (solver->vectors.usable < MAX_SECTOR - 1);
+  solver->vectors.usable += 1;
+  kissat_check_vectors (solver);
+}
+
+void kissat_remove_blocking_watch (kissat *solver, watches *watches,
+                                   reference ref) {
+  KISSAT_assert (solver->watching);
+  watch *const begin = BEGIN_WATCHES (*watches);
+  watch *const end = END_WATCHES (*watches);
+  watch *q = begin;
+  watch const *p = q;
+#ifndef KISSAT_NDEBUG
+  bool found = false;
+#endif
+  while (p != end) {
+    const watch head = *q++ = *p++;
+    if (head.type.binary)
+      continue;
+    const watch tail = *q++ = *p++;
+    if (tail.raw != ref)
+      continue;
+#ifndef KISSAT_NDEBUG
+    KISSAT_assert (!found);
+    found = true;
+#endif
+    q -= 2;
+  }
+  KISSAT_assert (found);
+#ifdef KISSAT_COMPACT
+  watches->size -= 2;
+#else
+  KISSAT_assert (begin + 2 <= end);
+  watches->end -= 2;
+#endif
+  const watch empty = {.raw = INVALID_VECTOR_ELEMENT};
+  end[-2] = end[-1] = empty;
+  KISSAT_assert (solver->vectors.usable < MAX_SECTOR - 2);
+  solver->vectors.usable += 2;
+  kissat_check_vectors (solver);
+}
+
+void kissat_substitute_large_watch (kissat *solver, watches *watches,
+                                    watch src, watch dst) {
+  KISSAT_assert (!solver->watching);
+  watch *const begin = BEGIN_WATCHES (*watches);
+  const watch *const end = END_WATCHES (*watches);
+#ifndef KISSAT_NDEBUG
+  bool found = false;
+#endif
+  for (watch *p = begin; p != end; p++) {
+    const watch head = *p;
+    if (head.raw != src.raw)
+      continue;
+#ifndef KISSAT_NDEBUG
+    found = true;
+#endif
+    *p = dst;
+    break;
+  }
+  KISSAT_assert (found);
+}
+
+void kissat_flush_all_connected (kissat *solver) {
+  KISSAT_assert (!solver->watching);
+  LOG ("flush all connected binaries and clauses");
+  watches *all_watches = solver->watches;
+  for (all_literals (lit))
+    RELEASE_WATCHES (all_watches[lit]);
+}
+
+void kissat_flush_large_watches (kissat *solver) {
+  KISSAT_assert (solver->watching);
+  LOG ("flush large clause watches");
+  watches *all_watches = solver->watches;
+  signed char *marks = solver->marks;
+  for (all_literals (lit)) {
+    watches *lit_watches = all_watches + lit;
+    watch *begin = BEGIN_WATCHES (*lit_watches), *q = begin;
+    const watch *const end = END_WATCHES (*lit_watches), *p = q;
+    while (p != end) {
+      const watch watch = *q++ = *p++;
+      if (!watch.type.binary)
+        p++, q--;
+      else {
+        const unsigned other = watch.binary.lit;
+        if (marks[other]) {
+          if (lit < other) {
+            LOGBINARY (lit, other, "flushing duplicated");
+            kissat_delete_binary (solver, lit, other);
+          }
+          q--;
+        } else
+          marks[other] = 1;
+      }
+    }
+    SET_END_OF_WATCHES (*lit_watches, q);
+    for (p = begin; p != q; p++) {
+      KISSAT_assert (p->type.binary);
+      marks[p->binary.lit] = 0;
+    }
+  }
+}
+
+void kissat_watch_large_clauses (kissat *solver) {
+  LOG ("watching all large clauses");
+  KISSAT_assert (solver->watching);
+
+  const value *const values = solver->values;
+  const assigned *const assigned = solver->assigned;
+  watches *watches = solver->watches;
+  ward *const arena = BEGIN_STACK (solver->arena);
+
+  for (all_clauses (c)) {
+    if (c->garbage)
+      continue;
+
+    unsigned *lits = c->lits;
+    kissat_sort_literals (solver, values, assigned, c->size, lits);
+    c->searched = 2;
+
+    const reference ref = (ward *) c - arena;
+    const unsigned l0 = lits[0];
+    const unsigned l1 = lits[1];
+
+    kissat_push_blocking_watch (solver, watches + l0, l1, ref);
+    kissat_push_blocking_watch (solver, watches + l1, l0, ref);
+  }
+}
+
+void kissat_connect_irredundant_large_clauses (kissat *solver) {
+  KISSAT_assert (!solver->watching);
+  LOG ("connecting all large irredundant clauses");
+
+  clause *last_irredundant = kissat_last_irredundant_clause (solver);
+
+  const value *const values = solver->values;
+  watches *all_watches = solver->watches;
+  ward *const arena = BEGIN_STACK (solver->arena);
+
+  for (all_clauses (c)) {
+    if (last_irredundant && c > last_irredundant)
+      break;
+    if (c->redundant)
+      continue;
+    if (c->garbage)
+      continue;
+    bool satisfied = false;
+    KISSAT_assert (!solver->level);
+    for (all_literals_in_clause (lit, c)) {
+      const value value = values[lit];
+      if (value <= 0)
+        continue;
+      satisfied = true;
+      break;
+    }
+    if (satisfied) {
+      kissat_mark_clause_as_garbage (solver, c);
+      continue;
+    }
+    const reference ref = (ward *) c - arena;
+    kissat_inlined_connect_clause (solver, all_watches, c, ref);
+  }
+}
+
+void kissat_flush_large_connected (kissat *solver) {
+  KISSAT_assert (!solver->watching);
+  LOG ("flushing large connected clause references");
+  size_t flushed = 0;
+  for (all_literals (lit)) {
+    watches *watches = &WATCHES (lit);
+    watch *begin = BEGIN_WATCHES (*watches), *q = begin;
+    const watch *const end_watches = END_WATCHES (*watches), *p = q;
+    while (p != end_watches) {
+      const watch head = *p++;
+      if (head.type.binary)
+        *q++ = head;
+      else
+        flushed++;
+    }
+    SET_END_OF_WATCHES (*watches, q);
+  }
+  LOG ("flushed %zu large clause references", flushed);
+  (void) flushed;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/watch.h b/src/sat/kissat/watch.h
new file mode 100644
index 000000000..901e489b7
--- /dev/null
+++ b/src/sat/kissat/watch.h
@@ -0,0 +1,181 @@
+#ifndef _watch_h_INCLUDED
+#define _watch_h_INCLUDED
+
+#include "keatures.h"
+#include "reference.h"
+#include "stack.h"
+#include "vector.h"
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+typedef union watch watch;
+
+typedef struct binary_tagged_literal watch_type;
+typedef struct binary_tagged_literal binary_watch;
+typedef struct binary_tagged_literal blocking_watch;
+typedef struct binary_tagged_reference large_watch;
+
+struct binary_tagged_literal {
+#ifdef KISSAT_IS_BIG_ENDIAN
+  bool binary : 1;
+  unsigned lit : 31;
+#else
+  unsigned lit : 31;
+  bool binary : 1;
+#endif
+};
+
+struct binary_tagged_reference {
+#ifdef KISSAT_IS_BIG_ENDIAN
+  bool binary : 1;
+  unsigned ref : 31;
+#else
+  unsigned ref : 31;
+  bool binary : 1;
+#endif
+};
+
+union watch {
+  watch_type type;
+  binary_watch binary;
+  blocking_watch blocking;
+  large_watch large;
+  unsigned raw;
+};
+
+typedef vector watches;
+
+typedef struct litwatch litwatch;
+typedef struct litpair litpair;
+typedef struct litriple litriple;
+
+typedef STACK (litwatch) litwatches;
+typedef STACK (litpair) litpairs;
+typedef STACK (litriple) litriples;
+
+struct litwatch {
+  unsigned lit;
+  watch watch;
+};
+
+struct litpair {
+  unsigned lits[2];
+};
+
+struct litriple {
+  unsigned lits[3];
+};
+
+static inline litpair kissat_litpair (unsigned lit, unsigned other) {
+  litpair res;
+  res.lits[0] = lit < other ? lit : other;
+  res.lits[1] = lit < other ? other : lit;
+  return res;
+}
+
+static inline watch kissat_binary_watch (unsigned lit) {
+  watch res;
+  res.binary.lit = lit;
+  res.binary.binary = true;
+  KISSAT_assert (res.type.binary);
+  return res;
+}
+
+static inline watch kissat_large_watch (reference ref) {
+  watch res;
+  res.large.ref = ref;
+  res.large.binary = false;
+  KISSAT_assert (!res.type.binary);
+  return res;
+}
+
+static inline watch kissat_blocking_watch (unsigned lit) {
+  watch res;
+  res.blocking.lit = lit;
+  res.blocking.binary = false;
+  KISSAT_assert (!res.type.binary);
+  return res;
+}
+
+#define EMPTY_WATCHES(W) kissat_empty_vector (&W)
+#define SIZE_WATCHES(W) kissat_size_vector (&W)
+
+#define PUSH_WATCHES(W, E) \
+  do { \
+    KISSAT_assert (sizeof (E) == sizeof (unsigned)); \
+    kissat_push_vectors (solver, &(W), (E).raw); \
+  } while (0)
+
+#define LAST_WATCH_POINTER(WS) \
+  (watch *) kissat_last_vector_pointer (solver, &WS)
+
+#define BEGIN_WATCHES(WS) \
+  ((union watch *) kissat_begin_vector (solver, &(WS)))
+
+#define END_WATCHES(WS) ((union watch *) kissat_end_vector (solver, &(WS)))
+
+#define BEGIN_CONST_WATCHES(WS) \
+  ((union watch *) kissat_begin_const_vector (solver, &(WS)))
+
+#define END_CONST_WATCHES(WS) \
+  ((union watch *) kissat_end_const_vector (solver, &(WS)))
+
+#define RELEASE_WATCHES(WS) kissat_release_vector (solver, &(WS))
+
+#define SET_END_OF_WATCHES(WS, P) \
+  do { \
+    size_t SIZE = (unsigned *) (P) - kissat_begin_vector (solver, &WS); \
+    kissat_resize_vector (solver, &WS, SIZE); \
+  } while (0)
+
+#define REMOVE_WATCHES(W, E) \
+  kissat_remove_from_vector (solver, &(W), (E).raw)
+
+#define WATCHES(LIT) (solver->watches[KISSAT_assert ((LIT) < LITS), (LIT)])
+
+// This iterator is currently only used in 'testreferences.c'.
+//
+#define all_binary_blocking_watch_ref(WATCH, REF, WATCHES) \
+  watch WATCH, \
+      *WATCH##_PTR = (KISSAT_assert (solver->watching), BEGIN_WATCHES (WATCHES)), \
+      *const WATCH##_END = END_WATCHES (WATCHES); \
+  WATCH##_PTR != WATCH##_END && \
+      ((WATCH = *WATCH##_PTR), \
+       (REF = WATCH.type.binary ? INVALID_REF : WATCH##_PTR[1].large.ref), \
+       true); \
+  WATCH##_PTR += 1u + !WATCH.type.binary
+
+#define all_binary_blocking_watches(WATCH, WATCHES) \
+  watch WATCH, \
+      *WATCH##_PTR = (KISSAT_assert (solver->watching), BEGIN_WATCHES (WATCHES)), \
+      *const WATCH##_END = END_WATCHES (WATCHES); \
+  WATCH##_PTR != WATCH##_END && ((WATCH = *WATCH##_PTR), true); \
+  WATCH##_PTR += 1u + !WATCH.type.binary
+
+#define all_binary_large_watches(WATCH, WATCHES) \
+  watch WATCH, \
+      *WATCH##_PTR = \
+          (KISSAT_assert (!solver->watching), BEGIN_WATCHES (WATCHES)), \
+      *const WATCH##_END = END_WATCHES (WATCHES); \
+  WATCH##_PTR != WATCH##_END && ((WATCH = *WATCH##_PTR), true); \
+  ++WATCH##_PTR
+
+void kissat_remove_binary_watch (struct kissat *, watches *, unsigned);
+void kissat_remove_blocking_watch (struct kissat *, watches *, reference);
+
+void kissat_substitute_large_watch (struct kissat *, watches *, watch src,
+                                    watch dst);
+
+void kissat_flush_all_connected (struct kissat *);
+void kissat_flush_large_watches (struct kissat *);
+void kissat_watch_large_clauses (struct kissat *);
+void kissat_flush_large_connected (struct kissat *);
+
+void kissat_connect_irredundant_large_clauses (struct kissat *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/weaken.c b/src/sat/kissat/weaken.c
new file mode 100644
index 000000000..5bd06371c
--- /dev/null
+++ b/src/sat/kissat/weaken.c
@@ -0,0 +1,64 @@
+#include "weaken.h"
+#include "inline.h"
+
+ABC_NAMESPACE_IMPL_START
+
+static void push_witness_literal (kissat *solver, unsigned ilit) {
+  KISSAT_assert (!VALUE (ilit));
+  int elit = kissat_export_literal (solver, ilit);
+  KISSAT_assert (elit);
+  LOG2 ("pushing external witness literal %d on extension stack", elit);
+  const extension ext = kissat_extension (true, elit);
+  PUSH_STACK (solver->extend, ext);
+}
+
+static void push_clause_literal (kissat *solver, unsigned ilit) {
+  const value value = VALUE (ilit);
+  KISSAT_assert (value <= 0);
+  if (value < 0)
+    LOG ("not pushing internal falsified clause literal %s "
+         "on extension stack",
+         LOGLIT (ilit));
+  else {
+    int elit = kissat_export_literal (solver, ilit);
+    KISSAT_assert (elit);
+    LOG2 ("pushing external clause literal %d on extension stack", elit);
+    const extension ext = kissat_extension (false, elit);
+    PUSH_STACK (solver->extend, ext);
+  }
+}
+
+#define LOGPUSHED(SIZE) \
+  do { \
+    LOGEXT ((SIZE), END_STACK (solver->extend) - (SIZE), \
+            "pushed size %zu witness labelled clause at", \
+            (size_t) (SIZE)); \
+  } while (0)
+
+void kissat_weaken_clause (kissat *solver, unsigned lit, clause *c) {
+  INC (weakened);
+  LOGCLS (c, "blocking on %s and weakening", LOGLIT (lit));
+  push_witness_literal (solver, lit);
+  for (all_literals_in_clause (other, c))
+    if (lit != other)
+      push_clause_literal (solver, other);
+  LOGPUSHED (c->size);
+}
+
+void kissat_weaken_binary (kissat *solver, unsigned lit, unsigned other) {
+  INC (weakened);
+  LOGBINARY (lit, other, "blocking on %s and weakening", LOGLIT (lit));
+  push_witness_literal (solver, lit);
+  push_clause_literal (solver, other);
+  LOGPUSHED (2);
+}
+
+void kissat_weaken_unit (kissat *solver, unsigned lit) {
+  INC (weakened);
+  LOG ("blocking and weakening unit %s", LOGLIT (lit));
+  push_witness_literal (solver, lit);
+  LOGEXT (1, END_STACK (solver->extend) - 1,
+          "pushed witness labelled unit clause at");
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/sat/kissat/weaken.h b/src/sat/kissat/weaken.h
new file mode 100644
index 000000000..8cd3dbbd8
--- /dev/null
+++ b/src/sat/kissat/weaken.h
@@ -0,0 +1,16 @@
+#ifndef _weaken_h_INCLUDED
+#define _weaken_h_INCLUDED
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct clause;
+struct kissat;
+
+void kissat_weaken_unit (struct kissat *, unsigned lit);
+void kissat_weaken_binary (struct kissat *, unsigned lit, unsigned other);
+void kissat_weaken_clause (struct kissat *, unsigned lit, struct clause *);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/sat/kissat/witness.h b/src/sat/kissat/witness.h
new file mode 100644
index 000000000..dffeaaabe
--- /dev/null
+++ b/src/sat/kissat/witness.h
@@ -0,0 +1,15 @@
+#ifndef _witness_h_INCLUDED
+#define _witness_h_INCLUDED
+
+#include <stdbool.h>
+
+#include "global.h"
+ABC_NAMESPACE_HEADER_START
+
+struct kissat;
+
+void kissat_print_witness (struct kissat *, int max_var, bool partial);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/test.ps b/test.ps
deleted file mode 100644
index 7634275b2..000000000
--- a/test.ps
+++ /dev/null
@@ -1,388 +0,0 @@
-%!PS-Adobe-3.0
-%%Creator: graphviz version 2.43.0 (0)
-%%Title: network
-%%Pages: (atend)
-%%BoundingBox: (atend)
-%%EndComments
-save
-%%BeginProlog
-/DotDict 200 dict def
-DotDict begin
-
-/setupLatin1 {
-mark
-/EncodingVector 256 array def
- EncodingVector 0
-
-ISOLatin1Encoding 0 255 getinterval putinterval
-EncodingVector 45 /hyphen put
-
-% Set up ISO Latin 1 character encoding
-/starnetISO {
-        dup dup findfont dup length dict begin
-        { 1 index /FID ne { def }{ pop pop } ifelse
-        } forall
-        /Encoding EncodingVector def
-        currentdict end definefont
-} def
-/Times-Roman starnetISO def
-/Times-Italic starnetISO def
-/Times-Bold starnetISO def
-/Times-BoldItalic starnetISO def
-/Helvetica starnetISO def
-/Helvetica-Oblique starnetISO def
-/Helvetica-Bold starnetISO def
-/Helvetica-BoldOblique starnetISO def
-/Courier starnetISO def
-/Courier-Oblique starnetISO def
-/Courier-Bold starnetISO def
-/Courier-BoldOblique starnetISO def
-cleartomark
-} bind def
-
-%%BeginResource: procset graphviz 0 0
-/coord-font-family /Times-Roman def
-/default-font-family /Times-Roman def
-/coordfont coord-font-family findfont 8 scalefont def
-
-/InvScaleFactor 1.0 def
-/set_scale {
-       dup 1 exch div /InvScaleFactor exch def
-       scale
-} bind def
-
-% styles
-/solid { [] 0 setdash } bind def
-/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
-/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
-/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
-/bold { 2 setlinewidth } bind def
-/filled { } bind def
-/unfilled { } bind def
-/rounded { } bind def
-/diagonals { } bind def
-/tapered { } bind def
-
-% hooks for setting color 
-/nodecolor { sethsbcolor } bind def
-/edgecolor { sethsbcolor } bind def
-/graphcolor { sethsbcolor } bind def
-/nopcolor {pop pop pop} bind def
-
-/beginpage {	% i j npages
-	/npages exch def
-	/j exch def
-	/i exch def
-	/str 10 string def
-	npages 1 gt {
-		gsave
-			coordfont setfont
-			0 0 moveto
-			(\() show i str cvs show (,) show j str cvs show (\)) show
-		grestore
-	} if
-} bind def
-
-/set_font {
-	findfont exch
-	scalefont setfont
-} def
-
-% draw text fitted to its expected width
-/alignedtext {			% width text
-	/text exch def
-	/width exch def
-	gsave
-		width 0 gt {
-			[] 0 setdash
-			text stringwidth pop width exch sub text length div 0 text ashow
-		} if
-	grestore
-} def
-
-/boxprim {				% xcorner ycorner xsize ysize
-		4 2 roll
-		moveto
-		2 copy
-		exch 0 rlineto
-		0 exch rlineto
-		pop neg 0 rlineto
-		closepath
-} bind def
-
-/ellipse_path {
-	/ry exch def
-	/rx exch def
-	/y exch def
-	/x exch def
-	matrix currentmatrix
-	newpath
-	x y translate
-	rx ry scale
-	0 0 1 0 360 arc
-	setmatrix
-} bind def
-
-/endpage { showpage } bind def
-/showpage { } def
-
-/layercolorseq
-	[	% layer color sequence - darkest to lightest
-		[0 0 0]
-		[.2 .8 .8]
-		[.4 .8 .8]
-		[.6 .8 .8]
-		[.8 .8 .8]
-	]
-def
-
-/layerlen layercolorseq length def
-
-/setlayer {/maxlayer exch def /curlayer exch def
-	layercolorseq curlayer 1 sub layerlen mod get
-	aload pop sethsbcolor
-	/nodecolor {nopcolor} def
-	/edgecolor {nopcolor} def
-	/graphcolor {nopcolor} def
-} bind def
-
-/onlayer { curlayer ne {invis} if } def
-
-/onlayers {
-	/myupper exch def
-	/mylower exch def
-	curlayer mylower lt
-	curlayer myupper gt
-	or
-	{invis} if
-} def
-
-/curlayer 0 def
-
-%%EndResource
-%%EndProlog
-%%BeginSetup
-14 default-font-family set_font
-% /arrowlength 10 def
-% /arrowwidth 5 def
-
-% make sure pdfmark is harmless for PS-interpreters other than Distiller
-/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
-% make '<<' and '>>' safe on PS Level 1 devices
-/languagelevel where {pop languagelevel}{1} ifelse
-2 lt {
-    userdict (<<) cvn ([) cvn load put
-    userdict (>>) cvn ([) cvn load put
-} if
-
-%%EndSetup
-setupLatin1
-%%Page: 1 1
-%%PageBoundingBox: 37 212 575 580
-%%PageOrientation: Portrait
-0 0 1 beginpage
-gsave
-37 212 538 368 boxprim clip newpath
-1 1 set_scale 0 rotate 41 216 translate
-% LevelTitle1
-gsave
-grestore
-% LevelTitle2
-gsave
-grestore
-% LevelTitle1->LevelTitle2
-% Level2
-gsave
-grestore
-% LevelTitle2->Level2
-% Level1
-gsave
-grestore
-% Level2->Level1
-% Level0
-gsave
-grestore
-% Level1->Level0
-% title1
-gsave
-0 0 0 nodecolor
-20 /Times-Roman set_font
-151.5 340 moveto 299 (Network structure visualized by ABC) alignedtext
-0 0 0 nodecolor
-20 /Times-Roman set_font
-80 318 moveto 442 (Benchmark "test". Time was Fri Sep  6 06:13:38 2024. ) alignedtext
-grestore
-% title2
-gsave
-0 0 0 nodecolor
-18 /Times-Roman set_font
-119 249.6 moveto 364 (The network contains 1 logic nodes and 0 latches.) alignedtext
-grestore
-% title1->title2
-% Node4
-gsave
-1 setlinewidth
-0.043137 0.68627 1 nodecolor
-newpath 263 154 moveto
-290.0966 188.5 lineto
-235.9034 188.5 lineto
-closepath stroke
-0 0 0 nodecolor
-14 /Times-Roman set_font
-260.5 173.3 moveto 5 (f) alignedtext
-grestore
-% title2->Node4
-% Node5
-gsave
-1 setlinewidth
-0.043137 0.68627 1 nodecolor
-newpath 338 154 moveto
-367.795 188.5 lineto
-308.205 188.5 lineto
-closepath stroke
-0 0 0 nodecolor
-14 /Times-Roman set_font
-334.5 173.3 moveto 7 (g) alignedtext
-grestore
-% title2->Node5
-% Node4->Node5
-% Node6
-gsave
-1 setlinewidth
-0 0 0 nodecolor
-300 100 27 18 ellipse_path stroke
-0 0 0 nodecolor
-14 /Times-Roman set_font
-296.5 96.3 moveto 7 (6) alignedtext
-grestore
-% Node4->Node6
-gsave
-1 setlinewidth
-solid
-0 0 0 edgecolor
-newpath 274.2701 153.1552 moveto
-279.9849 141.5712 286.7919 127.7731 291.9687 117.2797 curveto
-stroke
-0 0 0 edgecolor
-newpath 271.0718 151.7273 moveto
-269.7864 162.2438 lineto
-277.3495 154.8243 lineto
-closepath fill
-1 setlinewidth
-solid
-0 0 0 edgecolor
-newpath 271.0718 151.7273 moveto
-269.7864 162.2438 lineto
-277.3495 154.8243 lineto
-closepath stroke
-grestore
-% Node5->Node6
-gsave
-1 setlinewidth
-solid
-0 0 0 edgecolor
-newpath 326.2775 152.8634 moveto
-320.4603 141.3822 313.571 127.785 308.3062 117.3939 curveto
-stroke
-0 0 0 edgecolor
-newpath 323.2107 154.5546 moveto
-330.8525 161.8931 lineto
-329.4549 151.3908 lineto
-closepath fill
-1 setlinewidth
-solid
-0 0 0 edgecolor
-newpath 323.2107 154.5546 moveto
-330.8525 161.8931 lineto
-329.4549 151.3908 lineto
-closepath stroke
-grestore
-% Node1
-gsave
-1 setlinewidth
-0.043137 0.68627 1 nodecolor
-newpath 261 46 moveto
-231.205 11.5 lineto
-290.795 11.5 lineto
-closepath stroke
-0 0 0 nodecolor
-14 /Times-Roman set_font
-257.5 19.3 moveto 7 (a) alignedtext
-grestore
-% Node6->Node1
-gsave
-1 setlinewidth
-solid
-0 0 0 edgecolor
-newpath 286.8586 73.7282 moveto
-280.7027 61.8898 273.5973 48.2257 268.3944 38.2199 curveto
-stroke
-0 0 0 edgecolor
-newpath 283.8187 75.4687 moveto
-291.5376 82.7261 lineto
-290.0293 72.2392 lineto
-closepath fill
-1 setlinewidth
-solid
-0 0 0 edgecolor
-newpath 283.8187 75.4687 moveto
-291.5376 82.7261 lineto
-290.0293 72.2392 lineto
-closepath stroke
-grestore
-% Node2
-gsave
-1 setlinewidth
-0.043137 0.68627 1 nodecolor
-newpath 339 46 moveto
-309.205 11.5 lineto
-368.795 11.5 lineto
-closepath stroke
-0 0 0 nodecolor
-14 /Times-Roman set_font
-335.5 19.3 moveto 7 (b) alignedtext
-grestore
-% Node6->Node2
-gsave
-1 setlinewidth
-solid
-0 0 0 edgecolor
-newpath 313.1414 73.7282 moveto
-319.2973 61.8898 326.4027 48.2257 331.6056 38.2199 curveto
-stroke
-0 0 0 edgecolor
-newpath 309.9707 72.2392 moveto
-308.4624 82.7261 lineto
-316.1813 75.4687 lineto
-closepath fill
-1 setlinewidth
-solid
-0 0 0 edgecolor
-newpath 309.9707 72.2392 moveto
-308.4624 82.7261 lineto
-316.1813 75.4687 lineto
-closepath stroke
-grestore
-% Node3
-gsave
-1 setlinewidth
-0.043137 0.68627 1 nodecolor
-newpath 417 46 moveto
-387.205 11.5 lineto
-446.795 11.5 lineto
-closepath stroke
-0 0 0 nodecolor
-14 /Times-Roman set_font
-413.5 19.3 moveto 7 (c) alignedtext
-grestore
-endpage
-showpage
-grestore
-%%PageTrailer
-%%EndPage: 1
-%%Trailer
-%%Pages: 1
-%%BoundingBox: 37 212 575 580
-end
-restore
-%%EOF