From 03b4860d14016f42213ea271014f2f13d181f504 Mon Sep 17 00:00:00 2001
From: Armin Biere <biere@jku.at>
Date: Thu, 17 May 2018 12:00:15 +0200
Subject: [PATCH] imported first MIT release (almost SAT Competition 2018)
 version

---
 COPYING       |    21 +
 README        |    33 +
 VERSION       |     1 +
 blimc.c       |   677 ++
 configure.sh  |   281 +
 ilingeling.c  |   967 ++
 lglbnr.c      |    54 +
 lglconst.h    |    41 +
 lglddtrace.c  |   843 ++
 lgldimacs.c   |   272 +
 lgldimacs.h   |    32 +
 lglib.c       | 26717 ++++++++++++++++++++++++++++++++++++++++++++++++
 lglib.h       |   349 +
 lglmain.c     |   587 ++
 lglmbt.c      |   768 ++
 lgloptl.h     |   355 +
 lglopts.c     |    30 +
 lglopts.h     |    39 +
 lgluntrace.c  |   187 +
 makefile.in   |    89 +
 mkconfig.sh   |    25 +
 plingeling.c  |  1364 +++
 treengeling.c |  2358 +++++
 23 files changed, 36090 insertions(+)
 create mode 100644 COPYING
 create mode 100644 README
 create mode 100644 VERSION
 create mode 100644 blimc.c
 create mode 100755 configure.sh
 create mode 100644 ilingeling.c
 create mode 100644 lglbnr.c
 create mode 100644 lglconst.h
 create mode 100644 lglddtrace.c
 create mode 100644 lgldimacs.c
 create mode 100644 lgldimacs.h
 create mode 100644 lglib.c
 create mode 100644 lglib.h
 create mode 100644 lglmain.c
 create mode 100644 lglmbt.c
 create mode 100644 lgloptl.h
 create mode 100644 lglopts.c
 create mode 100644 lglopts.h
 create mode 100644 lgluntrace.c
 create mode 100644 makefile.in
 create mode 100755 mkconfig.sh
 create mode 100644 plingeling.c
 create mode 100644 treengeling.c

diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..9e299be
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2010-2018 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/README b/README
new file mode 100644
index 0000000..66f861c
--- /dev/null
+++ b/README
@@ -0,0 +1,33 @@
+These are the sources of the SAT solver Lingeling.
+The file VERSION contains the current version number.
+
+To build everything issue
+
+  ./configure.sh && make
+  
+This will build the library 'liblgl.o', the sequential solver 'lingeling',
+its parallel version 'plingeling', and the cube & conquer solvers
+'treengeling' and 'ilingeling'.
+
+If you have a compiled copy of the AIGER library in '../aiger/', which
+can be obtained from 'http://fmv.jku.at/aiger' then the bounded
+model checker 'blimc' will also be build.
+
+If you need proof support add and compile the 'druplig' library in
+'../druplig/' from 'http://fmv.jku.at/druplig'.
+
+If you want to add local search (particularly useful for 'treengeling') add
+and compile 'yalsat' in '../yalsat/' from 'http://fmv.jku.at/yalsat'.
+
+Copyright, authors and license are described in COPYING.
+
+With release 'bcj', which in essence is the version submitted
+to the SAT Competition 2018, we moved to an MIT style license.
+
+A more recent version of Lingeling might be found at
+
+  http://fmv.jku.at/lingeling
+
+and this site might also contain more documentation.
+
+Thu May 17 11:45:27 CEST 2018
diff --git a/VERSION b/VERSION
new file mode 100644
index 0000000..a9014c1
--- /dev/null
+++ b/VERSION
@@ -0,0 +1 @@
+bcj
diff --git a/blimc.c b/blimc.c
new file mode 100644
index 0000000..8ef38b7
--- /dev/null
+++ b/blimc.c
@@ -0,0 +1,677 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include "lglib.h"
+#include "aiger.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct Clause { int * lits; } Clause;
+
+static aiger * model;
+static unsigned num_bad;
+static aiger_symbol * badsyms;
+static FILE *outfile, *msgfile, *errfile, *apitrace;
+static int verbose, xstim, plain, nowitness, noclone;
+static LGL * lgl, * clone;
+static int * coi, opt = 3;
+static int cloned;
+
+static Clause * clauses;
+static int nclauses, szclauses;
+
+static int * lits;
+static int nlits, szlits;
+
+static int maxvar;
+static int * litmap;
+static int k;
+
+static size_t maxbytes, curbytes;
+
+static int catchedsig;
+static void (*sig_int_handler)(int);
+static void (*sig_segv_handler)(int);
+static void (*sig_abrt_handler)(int);
+static void (*sig_term_handler)(int);
+
+static void resetsighandlers (void) {
+  (void) signal (SIGINT, sig_int_handler);
+  (void) signal (SIGSEGV, sig_segv_handler);
+  (void) signal (SIGABRT, sig_abrt_handler);
+  (void) signal (SIGTERM, sig_term_handler);
+}
+
+static void msg (int level, const char * fmt, ...) {
+  va_list ap;
+  if (verbose < level) return;
+  fprintf (msgfile, "c [blimc] %.2f ", lglprocesstime ());
+  va_start (ap, fmt);
+  vfprintf (msgfile, fmt, ap);
+  va_end (ap);
+  fputc ('\n', msgfile);
+  fflush (msgfile);
+}
+
+static void caughtsigmsg (int sig) {
+  if (!verbose) return;
+  fprintf (errfile, "c [blimc]\nc [blimc] CAUGHT SIGNAL %d\nc [blimc]\n", sig);
+  fflush (errfile);
+}
+
+static void stats (void) {
+  if (verbose) {
+    if (clone) lglstats (clone);
+    if (lgl) lglstats (lgl);
+  }
+  msg (1, "reached k = %d", k);
+  msg (1, "cloned %d solvers", cloned);
+  msg (1, "max %.1f MB", maxbytes/(double)(1<<20));
+}
+
+static void catchsig (int sig) {
+  if (!catchedsig) {
+    fputs ("s UNKNOWN\n", errfile);
+    fflush (errfile);
+    catchedsig = 1;
+    caughtsigmsg (sig);
+    if (verbose) stats (), caughtsigmsg (sig);
+  }
+  resetsighandlers ();
+  if (!getenv ("LGLNABORT")) raise (sig); else exit (1);
+}
+
+static void setsighandlers (void) {
+  sig_int_handler = signal (SIGINT, catchsig);
+  sig_segv_handler = signal (SIGSEGV, catchsig);
+  sig_abrt_handler = signal (SIGABRT, catchsig);
+  sig_term_handler = signal (SIGTERM, catchsig);
+}
+
+static void die (const char * fmt, ...) {
+  va_list ap;
+  fputs ("*** blimc: ", errfile);
+  va_start (ap, fmt);
+  vfprintf (errfile, fmt, ap);
+  va_end (ap);
+  fputc ('\n', errfile);
+  fflush (errfile);
+  exit (1);
+}
+
+static void * new (void * state, size_t bytes) {
+  char * res;
+  (void) state;
+  res = malloc (bytes);
+  if (!res) die ("out of memory");
+  curbytes += bytes;
+  if (curbytes > maxbytes) maxbytes = curbytes;
+  return res;
+}
+
+static void del (void * state, void * ptr, size_t bytes) {
+  (void) state;
+  assert (curbytes >= bytes);
+  curbytes -= bytes;
+  free (ptr);
+}
+
+static void * rsz (void * state, void * ptr, size_t o, size_t n) {
+  char * res;
+  (void) state;
+  assert (curbytes >= o);
+  curbytes -= o;
+  res = realloc (ptr, n);
+  if (!res) die ("out of memory");
+  curbytes += n;
+  if (curbytes > maxbytes) maxbytes = curbytes;
+  return res;
+}
+
+static int prepilit (unsigned ulit) {
+  int res;
+  assert (aiger_lit2var (ulit) <= model->maxvar);
+  assert (coi[aiger_lit2var (ulit)]);
+  assert (ulit <= 2*model->maxvar + 1);
+  res = (ulit>>1) + 1;
+  if (ulit & 1) res = -res;
+  return res;
+}
+
+static unsigned aiginput (unsigned idx) {
+  assert (0 <= idx && idx < model->num_inputs);
+  return model->inputs[idx].lit;
+}
+
+static int prepinput (unsigned idx) { return prepilit (aiginput (idx)); }
+
+static unsigned aiglatch (unsigned idx) {
+  assert (0 <= idx && idx < model->num_latches);
+  return model->latches[idx].lit;
+}
+
+static unsigned aigreset (unsigned idx) {
+  assert (0 <= idx && idx < model->num_latches);
+  return model->latches[idx].reset;
+}
+
+static int preplatch (unsigned idx) { return prepilit (aiglatch (idx)); }
+
+static unsigned aignext (unsigned idx) {
+  assert (0 <= idx && idx < model->num_latches);
+  return model->latches[idx].next;
+}
+
+static int prepnext (unsigned idx) { return prepilit (aignext (idx)); }
+
+static unsigned aigbad (unsigned idx) {
+  assert (idx < num_bad);
+  return badsyms[idx].lit;
+}
+
+static int prepbad (unsigned idx) { return prepilit (aigbad (idx)); }
+
+static int preplhs (unsigned idx) {
+  assert (0 <= idx && idx < model->num_ands);
+  return prepilit (model->ands[idx].lhs);
+}
+
+static int prepleft (unsigned idx) {
+  assert (0 <= idx && idx < model->num_ands);
+  return prepilit (model->ands[idx].rhs0);
+}
+
+static int prepright (unsigned idx) {
+  assert (0 <= idx && idx < model->num_ands);
+  return prepilit (model->ands[idx].rhs1);
+}
+
+static void unit (int ilit) { lgladd (lgl, ilit); lgladd (lgl, 0); }
+
+static void binary (int a, int b) {
+  lgladd (lgl, a); 
+  lgladd (lgl, b);
+  lgladd (lgl, 0); 
+}
+
+static void ternary (int a, int b, int c) {
+  lgladd (lgl, a); 
+  lgladd (lgl, b);
+  lgladd (lgl, c);
+  lgladd (lgl, 0); 
+}
+
+static int ulitincoi (unsigned ulit) {
+  unsigned idx;
+  assert (ulit <= 2*model->maxvar + 1);
+  idx = aiger_lit2var (ulit);
+  assert (idx <= model->maxvar);
+  return coi[idx];
+}
+
+static void prepfreeze (void) {
+  unsigned i;
+  msg (2, "freeze");
+  for (i = 0; i < model->num_inputs; i++)
+    if (!nowitness && ulitincoi (aiginput (i)))
+      lglfreeze (lgl, prepinput (i));
+  for (i = 0; i < model->num_latches; i++) {
+    if (!ulitincoi (aiglatch (i))) continue;
+    lglfreeze (lgl, preplatch (i));
+    lglfreeze (lgl, prepnext (i));
+  }
+  for (i = 0; i < num_bad; i++) {
+    assert (ulitincoi (badsyms[i].lit));
+    lglfreeze (lgl, prepbad (i));
+  }
+  if (ulitincoi (0)) lglfreeze (lgl, 1);
+}
+
+static void and (int lhs, int rhs0, int rhs1) {
+  binary (-lhs, rhs0);
+  binary (-lhs, rhs1);
+  ternary (-rhs0, -rhs1, lhs);
+}
+
+static void logic (void) {
+  unsigned i;
+  msg (2, "logic");
+  if (ulitincoi (0)) unit (-1);
+  for (i = 0; i < model->num_ands; i++)
+    if (ulitincoi (model->ands[i].lhs))
+      and (preplhs (i), prepleft (i), prepright (i));
+}
+
+static const char * usage = 
+"usage: blimc [-h][-v][-x][-n][-p][-O[0123]][--no-clone][<maxk>][<aiger>]\n"
+;
+
+static int isnumstr (const char * str) {
+  const char * p = str;
+  int ch;
+  if (!isdigit (*p++)) return 0;
+  while (isdigit ((ch = *p))) p++;
+  return !ch;
+}
+
+static double percent (double a, double b) {
+  return b ? 100.0 * (a / b) : 0.0;
+}
+
+static void coimsg (const char * name, unsigned remaining, unsigned all) {
+  msg (1, "%-9s in COI: %10u = %3.0f%% out of %u",
+       name, remaining, percent (remaining, all), all);
+}
+
+static void travcoi (void) {
+  unsigned next, top, size, latches, inputs, ands, constants;
+  unsigned lit, * stack, idx, stripped;
+  aiger_symbol * s;
+  aiger_and * a;
+  size = model->maxvar + 1;
+  stack = new (0, size * sizeof *stack);
+  latches = inputs = ands = constants = 0;
+  assert (num_bad == 1);
+  lit = badsyms[0].lit;
+  idx = aiger_lit2var (lit);
+  coi[idx] = top = next = 1;
+  for (;;) {
+    assert (idx <= model->maxvar);
+    assert (coi[idx]);
+    stripped = aiger_strip (lit);
+    if (aiger_is_input (model, stripped)) inputs++;
+    else if ((s = aiger_is_latch (model, stripped))) {
+      latches++;
+      lit = s->next;
+      idx = aiger_lit2var (lit);
+      assert (idx <= model->maxvar);
+      if (!coi[idx]) stack[top++] = lit, coi[idx] = top;
+    } else if ((a = aiger_is_and (model, stripped))) {
+      ands++;
+      lit = a->rhs0;
+      idx = aiger_lit2var (lit);
+      assert (idx <= model->maxvar);
+      if (!coi[idx]) stack[top++] = lit, coi[idx] = top;
+      lit = a->rhs1;
+      idx = aiger_lit2var (lit);
+      assert (idx <= model->maxvar);
+      if (!coi[idx]) stack[top++] = lit, coi[idx] = top;
+    } else assert (!stripped), constants++;
+    if (next == top) break;
+    lit = stack[next++];
+  } 
+  del (0, stack, size * sizeof * stack);
+  coimsg ("literals", top, model->maxvar);
+  coimsg ("inputs", inputs, model->num_inputs);
+  coimsg ("latches", latches, model->num_latches);
+  coimsg ("constants", constants, 1);
+  coimsg ("ands", ands, model->num_ands);
+}
+
+static void newlgl (int setapitrace) {
+  const char * apitracename = getenv ("BLIMCLGLAPITRACE");
+  lgl = lglminit (0,new,rsz,del);
+  if (setapitrace && apitracename) {
+    assert (!apitrace);
+    apitrace = fopen (apitracename, "w");
+    if (!apitrace)
+      die ("can write to API trace file '%s'", apitracename);
+    lglwtrapi (lgl, apitrace);
+  }
+  lglsetout (lgl, msgfile);
+  if (verbose >= 2) lglsetopt (lgl, "verbose", verbose - 1);
+  if (plain) lglsetopt (lgl, "plain", 1);
+}
+
+static void extract (void * dummy, int lit) {
+  size_t oldbytes, newbytes;
+  Clause * c;
+  int i;
+  (void) dummy;
+  if (lit) {
+    if (nlits == szlits) {
+      oldbytes = szlits * sizeof *lits;
+      szlits = szlits ? 2*szlits : 1;
+      newbytes = szlits * sizeof *lits;
+      lits = rsz (0, lits, oldbytes, newbytes);
+    }
+    lits[nlits++] = lit;
+  } else {
+    if (nclauses == szclauses) {
+      oldbytes = szclauses * sizeof *clauses;
+      szclauses = szclauses ? 2*szclauses : 1;
+      newbytes = szclauses * sizeof *clauses;
+      clauses = rsz (0, clauses, oldbytes, newbytes);
+    }
+    c = clauses + nclauses++;
+    newbytes = (nlits + 1) * sizeof *c->lits;
+    c->lits = new (0, newbytes);
+    for (i = 0; i < nlits; i++) c->lits[i] = lits[i];
+    c->lits[i] = 0;
+    nlits = 0;
+  }
+}
+
+static int mapuntimedlit (int lit) {
+  int idx = abs (lit), res;
+  assert (1 <= idx && idx <= model->maxvar + 1);
+  if (!(res = litmap[idx])) litmap[idx] = res = ++maxvar;
+  if (lit < 0) res = -res;
+  return res;
+}
+
+static void mapcnf (void) {
+  int * p, lit;
+  Clause * c;
+  for (c = clauses; c < clauses + nclauses; c++)
+    for (p = c->lits; (lit = *p); p++)
+      *p = mapuntimedlit (lit);
+}
+
+static int mainilit (unsigned ulit) {
+  int tmp = prepilit (ulit), idx = abs (tmp), res;
+  assert (1 <= idx && idx <= model->maxvar+1);
+  res = litmap[idx];
+  if (tmp < 0) res = -res;
+  return res;
+}
+
+static int shift (int ilit, int time) {
+  int idx = abs (ilit), res;
+  assert (1 <= idx && idx <= maxvar);
+  res = idx + time * maxvar;
+  if (ilit < 0) res = -res;
+  return res;
+}
+
+static void equiv (int a, int b) { binary (-a, b); binary (a, -b); }
+
+static void shiftcnf (int time) {
+  int * p, lit, prev;
+  unsigned i;
+  Clause * c;
+  assert (0 <= time);
+  if (time > 0) {
+    for (i = 0; i < model->num_latches; i++) {
+      if (!ulitincoi (aiglatch (i))) continue;
+      prev = shift (mainilit (aignext (i)), time-1);
+      lit = shift (mainilit (aiglatch (i)), time);
+      equiv (prev, lit);
+      lglmelt (lgl, prev);
+    }
+  }
+  for (c = clauses; c < clauses + nclauses; c++) {
+    for (p = c->lits; (lit = *p); p++) lgladd (lgl, shift (lit, time));
+    lgladd (lgl, 0);
+  }
+  for (i = 0; i < model->num_latches; i++)
+    if (ulitincoi (aiglatch (i)))
+      lglfreeze (lgl, shift (mainilit (aignext (i)), time));
+}
+
+static void bad (LGL * whichlgl, int time) {
+  lglassume (whichlgl, shift (mainilit (aigbad (0)), time));
+}
+
+static void init (void) {
+  size_t bytes;
+  unsigned i;
+  int lit;
+  bytes = (model->maxvar + 2) * sizeof *litmap;
+  litmap = new (0, bytes);
+  memset (litmap, 0, bytes);
+  assert (!maxvar);
+  maxvar = 0;			// true lit
+  for (i = 0; i < model->num_latches; i++) {
+    if (!ulitincoi (aiglatch (i))) continue;
+    lit = ++maxvar;
+    litmap[preplatch (i)] = lit;
+  }
+  for (i = 0; i < model->num_inputs; i++) {
+    if (!ulitincoi (aiginput (i))) continue;
+    lit = ++maxvar;
+    litmap[prepinput (i)] = lit;
+  }
+  mapcnf ();
+  for (i = 0; i < model->num_latches; i++)
+    if (ulitincoi (aiglatch (i)))
+      (void) mapuntimedlit (prepnext (i));
+  msg (1, "mapped %d variables", maxvar);
+#ifndef NDEBUG
+  for (i = 0; i < num_bad; i++)
+    if (ulitincoi (aigbad (i)))
+      assert (litmap[abs (prepbad (i))]);
+#endif
+  for (i = 0; i < model->num_latches; i++) {
+    if (!ulitincoi (aiglatch (i))) continue;
+    if (aiglatch (i) == aigreset (i)) continue;
+    if (aiger_false == aigreset (i)) unit (-mainilit (aiglatch (i)));
+    if (aiger_true == aigreset (i)) unit (mainilit (aiglatch (i)));
+  }
+}
+
+static int length (const int * p) {
+  const int * q;
+  for (q = p; *q; q++)
+    ;
+  return q - p;
+}
+
+int main (int argc, char ** argv) {
+  int res, i, lit, maxk, val;
+  unsigned j, init0, init1, initx;
+  const char * iname, * err;
+  size_t coibytes;
+  char prefix[80];
+#ifndef NDEBUG
+  int fres;
+#endif
+  LGL * tmp;
+  char vch;
+  outfile = stdout, msgfile = errfile = stderr;
+  iname = 0;
+  maxk = 0;
+  for (i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h")) { fputs (usage, outfile); exit (0);}
+    else if (!strcmp (argv[i], "-v")) verbose++;
+    else if (!strcmp (argv[i], "-x")) xstim = 1;
+    else if (!strcmp (argv[i], "-n")) nowitness = 1;
+    else if (!strcmp (argv[i], "-p")) plain = 1;
+    else if (!strcmp (argv[i], "-O")) opt = 1;
+    else if (!strcmp (argv[i], "-O0")) opt = 0;
+    else if (!strcmp (argv[i], "-O1")) opt = 1;
+    else if (!strcmp (argv[i], "-O2")) opt = 2;
+    else if (!strcmp (argv[i], "-O3")) opt = 3;
+    else if (!strcmp (argv[i], "--no-clone")) noclone = 1;
+    else if (argv[i][0] == '-')
+      die ("invalid command line option '%s'", argv[i]);
+    else if (isnumstr (argv[i])) maxk = atoi (argv[i]);
+    else if (iname) 
+      die ("two files specified '%s' and '%s'", iname, argv[i]);
+    else iname = argv[i];
+  }
+  if (verbose) 
+    lglbnr ("BLIMC Bounded Lingeling Model Checker",
+            "c [blimc] ", msgfile);
+  setsighandlers ();
+  msg (1, "reading %s", iname ? iname : "<stdin>");
+  model = aiger_init ();
+  if (iname) err = aiger_open_and_read_from_file (model, iname);
+  else err = aiger_read_from_file (model, stdin);
+  if (err) die ("parse error in '%s' at %s",
+                iname ? iname : "<stdin>", err);
+  msg (1, "MILOA %u %u %u %u %u",
+       model->maxvar,
+       model->num_inputs,
+       model->num_latches,
+       model->num_outputs,
+       model->num_ands);
+
+  msg (1, "BCJK %u %u %u %u %u",
+       model->num_bad,
+       model->num_constraints,
+       model->num_justice,
+       model->num_fairness);
+
+  if (!model->num_outputs && !model->num_bad)
+    die ("model contains no output nor bad state property");
+
+  if (model->num_bad > 1)
+    die ("can not handle multiple bad state properties");
+
+  if (!model->num_bad && model->num_outputs > 1)
+    die ("can not handle multiple outputs (without bad state property)");
+
+  if (model->num_constraints > 0)
+    die ("can not handle environment constraints");
+
+  if (model->num_justice)
+    msg (1, "ignoring %d justice properties", model->num_justice);
+
+  if (model->num_fairness)
+    msg (1, "ignoring %d fairness constraints", model->num_fairness);
+
+  if (model->num_bad) num_bad = model->num_bad, badsyms = model->bad;
+  else num_bad = model->num_outputs, badsyms = model->outputs;
+  assert (num_bad == 1);
+
+  init0 = init1 = initx = 0;
+  for (j = 0; j < model->num_latches; j++) {
+    unsigned rst = aigreset (j);
+    if (rst == aiger_false) init0++;
+    if (rst == aiger_true) init1++;
+    if (rst == aiglatch (j)) initx++;
+  }
+  if (model->num_latches) {
+    msg (1, "%u latches initialized to 0", init0);
+    msg (1, "%u latches initialized to 1", init1);
+    msg (1, "%u latches uninitialized", initx);
+  } else msg (1, "no latches, so purely combinational");
+  coibytes = (model->maxvar+1) * sizeof *coi;
+  coi = new (0, coibytes);
+  memset (coi, 0, coibytes);
+  travcoi ();
+  newlgl (0);
+  lglsetprefix (lgl, "c [lglopt] ");
+  logic ();
+  prepfreeze ();
+  msg (1, "encoded");
+  (void) lglsimp (lgl, opt);
+  msg (1, "simplified");
+  if (lglfixed (lgl, prepbad (0)) < 0) {
+    res = 20;
+    fprintf (outfile, "0\nb0\n.\n");
+  } else {
+    res = 0;
+    lgltravall (lgl, 0, extract);
+    msg (1, "extracted");
+    if (verbose >= 1) lglstats (lgl);
+    tmp = lgl, lgl = 0;
+    lglrelease (tmp);
+    newlgl (1);
+    lglsetopt (lgl, "flipping", 0);
+    lglsetopt (lgl, "boost", 0);
+    lglsetopt (lgl, "simpdelay", 100);
+    lglsetprefix (lgl, "c [lgl0] ");
+    init ();
+    msg (1, "maxk %d", maxk);
+    for (k = 0; k <= maxk; k++) {
+      msg (1, "bound %d", k);
+      sprintf (prefix, "c [lgl%d] ", k);
+      lglsetprefix (lgl, prefix);
+      shiftcnf (k);
+      bad (lgl, k);
+      if (!noclone) lglsetopt (lgl, "clim", 1000);
+      res = lglsat (lgl);
+      if (!res) {
+	assert (!clone);
+	assert (!noclone);
+	clone = lglclone (lgl);
+	sprintf (prefix, "c [lgl%dclone%d] ", k, cloned++);
+	lglsetprefix (clone, prefix);
+	lglfixate (clone);
+	lglmeltall (clone);
+#if 0
+	if (cloned & (cloned-1)) res = 0;
+	else 
+#endif
+	  res = lglsimp (clone, 1);
+	if (!res) {
+	  lglsetopt (clone, "clim", -1);
+	  res = lglsat (clone);
+	  assert (res == 10 || res == 20);
+	}
+	if (verbose >= 3) lglstats (clone);
+	tmp = clone, clone = 0;
+#ifndef NDEBUG
+	fres = 
+#endif
+	lglunclone (lgl, tmp);
+	assert (fres == res);
+	lglrelease (tmp);
+      }
+      assert (res);
+      if (res == 10) break;
+      assert (res == 20);
+      printf ("u%d\n", k);
+      fflush (stdout);
+      if (!model->num_latches) break;
+      if (k < maxk && !((k + 1) & k)) (void) lglsimp (lgl, 0);
+    }
+    if (res == 10) {
+      fprintf (outfile, "1\nb0\n");
+      if (!nowitness) {
+	for (i = 0; i < model->num_latches; i++) {
+	  if (ulitincoi (aiglatch (i))) {
+	    lit = shift (mainilit (aiglatch (i)), 0);
+	    val = lglderef (lgl, lit);
+	  } else val = 0;
+	  if (val > 0) vch = '1';
+	  else if (!val && xstim) vch = 'x';
+	  else vch = '0';
+	  fputc (vch, stdout);
+	}
+	fputc ('\n', stdout);
+	for (i = 0; i <= k; i++) {
+	  for (j = 0; j < model->num_inputs; j++) {
+	    if (ulitincoi (aiginput (j))) {
+	      lit = shift (mainilit (aiginput (j)), i);
+	      val = lglderef (lgl, lit);
+	    } else val = 0;
+	    if (val > 0) vch = '1';
+	    else if (!val && xstim) vch = 'x';
+	    else vch = '0';
+	    fputc (vch, stdout);
+	  }
+	  fputc ('\n', stdout);
+	}
+      }
+      printf (".\n");
+    } else if (res == 20 && !model->num_latches) 
+      fprintf (outfile, "0\nb0\n.\n");
+    else fprintf (outfile, "2\nb0\n.\n");
+    del (0, litmap, (model->maxvar + 2) * sizeof *litmap);
+  }
+  fflush (outfile);
+  del (0, coi, (model->maxvar+1) * sizeof *coi);
+  aiger_reset (model);
+  for (i = 0; i < nclauses; i++)
+    del (0, clauses[i].lits,
+         (length (clauses[i].lits) + 1) * sizeof *clauses[i].lits);
+  del (0, clauses, szclauses * sizeof *clauses);
+  del (0, lits, szlits * sizeof *lits);
+  resetsighandlers ();
+  stats ();
+  lglrelease (lgl);
+  if (apitrace) fflush (apitrace), fclose (apitrace);
+  msg (1, "exit %d", res);
+  return res;
+}
diff --git a/configure.sh b/configure.sh
new file mode 100755
index 0000000..097f446
--- /dev/null
+++ b/configure.sh
@@ -0,0 +1,281 @@
+#!/bin/sh
+
+dema=no
+check=undefined
+chksol=undefined
+coverage=undefined
+debug=no
+log=undefined
+lto=no
+olevel=none
+other=none
+druplig=undefined
+profile=undefined
+static=no
+classify=no
+aiger=undefined
+yalsat=undefined
+files=no
+
+##########################################################################
+
+die () {
+  echo "*** configure.sh: $*" 1>&2
+  exit 1
+}
+
+##########################################################################
+
+while [ $# -gt 0 ]
+do
+  case $1 in
+    -h|--help) 
+       echo "usage: configure.sh [<option> ...]"
+       echo
+       echo "where <option> is one of the following"
+       echo
+       echo "-h | --help"
+       echo "-g | --debug    include debugging code and symbols"
+       echo "-l | --log      include logging code (default with '-g')"
+       echo "-c | --check    include checking code (default with '-g')"
+       echo "-p | --profile  compile with '-pg' for profiling"
+       echo "--coverage      compile with coverage options"
+       echo "--no-check      no checking code (overwrite default for '-g')"
+       echo "--chksol        always check solution (default for '-c')"
+       echo "--no-chksol     do not check solution"
+       echo "--softfloats    use software floats"
+       echo "--no-log        no logging code (overwrite default for '-g')"
+       echo "--dema"
+       echo "--no-dema"
+       echo "-O[0-4]         set optimization level unless '-g' specified"
+       echo "-flto           enable link time optimization"
+       echo "-f...|-m...     add other compiler options"
+       echo "--aiger=<dir>   specify AIGER directory (default '../aiger')"
+       echo "--no-aiger      no targets requiring AIGER library"
+       echo "--yalsat=<dir>  specify YalSAT directory (default '../yalsat')"
+       echo "--no-yalsat     do not include YalSAT code"
+       echo "--druplig       specify Druplig directory (default '../druplig')"
+       echo "--no-druplig    do not include Druplig code"
+       echo "--files         generate statistics files"
+       echo
+       echo "--classify      use classifier for automatic parameter setting"
+       exit 0
+       ;;
+    -g|--debug) debug=yes;;
+    -l|--log) log=yes;;
+    -c|--check) check=yes;;
+    --chksol) chksol=yes;;
+    --no-chksol|--nchksol) chksol=no;;
+    --no-check) check=no;;
+    --no-log) log=no;;
+    -p|--profile) profile=yes;;
+    --coverage) coverage=yes;;
+    -O) debug=no;;
+    --dema) dema=yes;;
+    --no-dema) dema=no;;
+    -O0|-O1|-O2|-O3|-O4) olevel=$1;;
+    -lto|-flto|--lto|--flto) lto=yes;;
+    -static|--static|-s) static=yes;;
+    --aiger=*) aiger=`echo "$1"|sed -e 's,^--aiger=,,'`;;
+    --no-aiger) aiger=no;;
+    --yalsat=*) yalsat=`echo "$1"|sed -e 's,^--yalsat=,,'`;;
+    --no-yalsat) yalsat=no;;
+    --druplig) druplig=`echo "$1"|sed -e 's,^--druplig=,,'`;;
+    --no-druplig) druplig=no;;
+    --files) files=yes;;
+    --classify) classify=yes;;
+    -f*|-m*) if [ $other = none ]; then other=$1; else other="$other $1"; fi;;
+    *) echo "*** configure.sh: invalid command line option '$1'"; exit 1;;
+  esac
+  shift
+done
+
+##########################################################################
+
+if [ x"$aiger" = xundefined ]
+then
+  if [ -d ../aiger ]
+  then
+    aiger="../aiger"
+    echo "found and using $aiger"
+  fi
+fi
+
+if [ x"$aiger" = xundefined ]
+then
+  aiger=no
+elif [ ! x"$aiger" = xno ]
+then
+  if [ ! -d "$aiger" ]
+  then
+    die "'$aiger' not a directory (use '--aiger' or '--no-aiger')"
+  elif [ ! -f "$aiger/aiger.h" ]
+  then
+    die "can not find '$aiger/aiger.h'"
+  elif [ ! -f "$aiger/aiger.o" ]
+  then
+    die "can not find '$aiger/aiger.o'"
+  fi
+fi
+
+##########################################################################
+
+if [ x"$yalsat" = xundefined ]
+then
+  if [ -d ../yalsat ]
+  then
+    yalsat="../yalsat"
+    echo "found and using $yalsat"
+  fi
+fi
+
+if [ x"$yalsat" = xundefined ]
+then
+  yalsat=no
+elif [ ! x"$yalsat" = xno ]
+then
+  if [ ! -d "$yalsat" ]
+  then
+    die "'$yalsat' not a directory (use '--yalsat' or '--no-yalsat')"
+  elif [ ! -f "$yalsat/yals.h" ]
+  then
+    die "can not find '$yalssat/yals.h'"
+  elif [ ! -f "$yalsat/libyals.a" ]
+  then
+    die "can not find '$yalsat/libyals.a'"
+  fi
+fi
+
+##########################################################################
+
+if [ x"$druplig" = xundefined ]
+then
+  if [ -d ../druplig ]
+  then
+    druplig="../druplig"
+    echo "found and using $druplig"
+  fi
+fi
+
+if [ x"$druplig" = xundefined ]
+then
+  druplig=no
+elif [ ! x"$druplig" = xno ]
+then
+  if [ ! -d "$druplig" ]
+  then
+    die "'$druplig' not a directory (use '--druplig' or '--no-druplig')"
+  elif [ ! -f "$druplig/druplig.h" ]
+  then
+    die "can not find '$yalssat/druplig.h'"
+  elif [ ! -f "$druplig/libdruplig.a" ]
+  then
+    die "can not find '$druplig/libdruplig.a'"
+  fi
+fi
+
+##########################################################################
+
+[ $log = undefined ] && log=$debug
+[ $check = undefined ] && check=$debug
+
+##########################################################################
+
+[ x"$CC" = x ] && CC=gcc
+
+CFLAGS="-Wall"
+if [ $debug = yes ]
+then
+  CFLAGS="$CFLAGS -g3"
+  [ $olevel = none ] || CFLAGS="$CFLAGS $olevel"
+else
+  [ $olevel = none ] && olevel=-O3
+  CFLAGS="$CFLAGS $olevel"
+  [ $lto = yes ] && CFLAGS="$CFLAGS -flto -fwhole-program"
+fi
+
+LIBS="-lm"
+HDEPS=""
+LDEPS=""
+
+if [ "$aiger" = no ]
+then
+  AIGERTARGETS=""
+  AIGER=""
+else
+  AIGERTARGETS="blimc"
+  AIGER="$aiger"
+fi
+
+if [ ! "$yalsat" = no ]
+then
+  [ x"$HDEPS" = x ] || HDEPS="${HDEPS} "
+  HDEPS="${HDEPS}$yalsat/yals.h"
+  [ x"$LDEPS" = x ] || LDEPS="${LDEPS} "
+  LDEPS="${LDEPS}$yalsat/libyals.a"
+  [ x"$LIBS" = x ] || LIBS="${LIBS} "
+  LIBS="${LIBS}-L$yalsat -lyals"
+  [ x"$CFLAGS" = x ] || CFLAGS="${CFLAGS} "
+  CFLAGS="${CFLAGS}-I$yalsat"
+fi
+
+if [ ! "$druplig" = no ]
+then
+  [ x"$HDEPS" = x ] || HDEPS="${HDEPS} "
+  HDEPS="${HDEPS}$druplig/druplig.h"
+  [ x"$LDEPS" = x ] || LDEPS="${LDEPS} "
+  LDEPS="${LDEPS}$druplig/libdruplig.a"
+  [ x"$LIBS" = x ] || LIBS="${LIBS} "
+  LIBS="${LIBS}-L$druplig -ldruplig"
+  [ x"$CFLAGS" = x ] || CFLAGS="${CFLAGS} "
+  CFLAGS="${CFLAGS}-I$druplig"
+fi
+
+[ $chksol = undefined ] && chksol=$check
+[ $static = yes ] && CFLAGS="$CFLAGS -static"
+[ $profile = yes ] && CFLAGS="$CFLAGS -pg"
+[ $coverage = yes ] && CFLAGS="$CFLAGS -ftest-coverage -fprofile-arcs"
+[ $other = none ] || CFLAGS="$CFLAGS $other"
+[ $log = no ] && CFLAGS="$CFLAGS -DNLGLOG"
+[ $check = no ] && CFLAGS="$CFLAGS -DNDEBUG"
+[ $chksol = no ] && CFLAGS="$CFLAGS -DNCHKSOL"
+[ $druplig = no ] && CFLAGS="$CFLAGS -DNLGLDRUPLIG"
+[ $yalsat = no ] && CFLAGS="$CFLAGS -DNLGLYALSAT"
+[ $files = no ] && CFLAGS="$CFLAGS -DNLGLFILES"
+[ $dema = no ] && CFLAGS="$CFLAGS -DNLGLDEMA"
+
+if [ $classify = yes -a -d sc14classify ]
+then
+  cd sc14classify
+  if [ $debug = yes ]
+  then
+    echo "calling 'configure.sh -g' in sub-directory 'sc14classify'"
+    ./configure.sh -g || exit 1
+  else
+    echo "calling 'configure.sh' in sub-directory 'sc14classify'"
+    ./configure.sh || exit 1
+  fi
+  echo "calling 'make sc14classify.o' in sub-directory 'sc14classify'"
+  make sc14classify.o || exit 1
+  cd ..
+  [ x"$CFLAGS" = x ] || CFLAGS="${CFLAGS} "
+  CFLAGS="$CFLAGS -DLGLSC14CLASSIFY"
+  [ x"$EXTRAOBJS" = x ] || EXTRAOBJS="${EXTRAOBJS} "
+  EXTRAOBJS="sc14classify/sc14classify.o"
+fi
+
+echo "$CC $CFLAGS"
+
+##########################################################################
+
+rm -f makefile
+sed \
+  -e "s,@CC@,$CC," \
+  -e "s,@CFLAGS@,$CFLAGS," \
+  -e "s,@HDEPS@,$HDEPS," \
+  -e "s,@LDEPS@,$LDEPS," \
+  -e "s,@EXTRAOBJS@,$EXTRAOBJS," \
+  -e "s,@AIGERTARGETS@,$AIGERTARGETS," \
+  -e "s,@AIGER@,$AIGER," \
+  -e "s,@LIBS@,$LIBS," \
+  makefile.in > makefile
diff --git a/ilingeling.c b/ilingeling.c
new file mode 100644
index 0000000..975094a
--- /dev/null
+++ b/ilingeling.c
@@ -0,0 +1,967 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include "lglib.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <math.h>
+#include <limits.h>
+#include <unistd.h>
+
+#define CLONELIMIT		20000
+
+#define INC(BYTES) \
+do { \
+  allocated += (BYTES); \
+  if (allocated > maxallocated) maxallocated = allocated; \
+} while (0)
+
+#define DEC(BYTES) \
+do { \
+  assert (allocated >= (BYTES)); \
+  allocated -= (BYTES); \
+} while (0)
+
+#define NEW(PTR,N) \
+do { \
+  size_t BYTES = (N) * sizeof *(PTR); \
+  (PTR) = malloc (BYTES); \
+  if(!(PTR)) { die ("out of memory"); exit (1); } \
+  memset ((PTR), 0, BYTES); \
+  INC (BYTES); \
+} while (0)
+
+#define DEL(PTR,N) \
+do { \
+  size_t BYTES = (N) * sizeof *(PTR); \
+  DEC (BYTES); \
+  free (PTR); \
+  (PTR) = 0; \
+} while (0);
+
+#define RSZ(PTR,O,N) \
+do { \
+  size_t OBYTES = (O) * sizeof *(PTR); \
+  size_t NBYTES = (N) * sizeof *(PTR); \
+  DEC (OBYTES); \
+  (PTR) = realloc ((PTR), NBYTES); \
+  if (!(PTR)) die ("out of memory"); \
+  INC (NBYTES); \
+} while (0)
+
+#define ENLARGE(STACK) \
+do { \
+  size_t oldbytes, newbytes; \
+  oldbytes = sz ## STACK * sizeof *STACK; \
+  DEC (oldbytes); \
+  sz ## STACK = sz ## STACK ? 2*sz ## STACK : 1; \
+  newbytes = sz ## STACK * sizeof *STACK; \
+  STACK = realloc (STACK, newbytes); \
+  if (!(STACK)) die ("out of memory"); \
+  INC (newbytes); \
+} while (0)
+
+#define PUSH(STACK,ELEM) \
+do { \
+  if (n ## STACK >= sz ## STACK) ENLARGE (STACK); \
+  STACK[n ## STACK++] = ELEM; \
+} while (0)
+
+#define WID(W) \
+  (assert (workers <= (W) && (W) < workers + nworkers), (int)((W) - workers))
+
+typedef struct Worker { 
+  LGL * lgl;
+  struct { 
+    LGL * lgl;
+    int count, bcount;
+    int64_t decs, confs, props;
+    pthread_mutex_t lock;
+  } cloned;
+  int last, res;
+  pthread_t thread;
+  FILE * proof, * post;
+  int * failed, nfailed;
+} Worker;
+
+static double startime;
+static size_t allocated, maxallocated;
+static FILE * statsfile, * histfile;
+
+static Worker * workers;
+static int nworkers;
+
+static int nassumptions, queue, szassumptions;
+static int maxassumptionsize, sumassumptions, redassumptions;
+static double * times, sumtimes;
+static int ** assumptions;
+
+static int nvars, szvars, nclauses, nused, * used;
+static signed char * vals;
+static int nlits, szlits;
+static int * lits;
+
+static int verbose, bar, nowitness, plain, clone, deterministic;
+static int noreverse, addassumptions = 1, noflush, reduce, nomelt;
+
+static const char * druptraceprefix;
+
+static int lineno = 1;
+static char * inputname;
+static FILE * inputfile;
+
+static int done;
+
+static pthread_mutex_t msgmutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t donemutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t queuemutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t finishedmutex = PTHREAD_MUTEX_INITIALIZER;
+
+static int finished;
+
+static void msglock (void * voidptr) {
+  (void) voidptr;
+  pthread_mutex_lock (&msgmutex);
+}
+
+static void msgunlock (void * voidptr) {
+  (void) voidptr;
+  pthread_mutex_unlock (&msgmutex);
+}
+
+static void msg (Worker * w, int level, const char * fmt, ...) {
+  va_list ap;
+  if (verbose < level) return;
+  msglock (0);
+  if (w) printf ("c %d ", WID (w)); else printf ("c - ");
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  msgunlock (0);
+}
+
+static void die (const char * fmt, ...) {
+  va_list ap;
+  fputs ("*** [ilingeling] ", stderr);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  exit (1);
+}
+
+static void warn (const char * fmt, ...) {
+  va_list ap;
+  fputs ("*** [ilingeling] warning: ", stderr);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+}
+
+static double currentime (void) {
+  double res = 0;
+  struct timeval tv;
+  if (!gettimeofday (&tv, 0)) res = 1e-6 * tv.tv_usec, res += tv.tv_sec;
+  return res;
+}
+
+static double getime () { return currentime () - startime; }
+
+static int isnum (const char * str) {
+  const char * p = str;
+  if (!isdigit ((int)*p++)) return 0;
+  while (*p && isdigit ((int)*p)) p++;
+  return !*p;
+}
+
+static int term (void * voidptr) {
+  Worker * w = voidptr;
+  int res;
+  msg (w, 3, "checking early termination");
+  if (pthread_mutex_lock (&donemutex))
+    warn ("failed to lock 'done' mutex in termination check");
+  res = done;
+  if (pthread_mutex_unlock (&donemutex)) 
+    warn ("failed to unlock 'done' mutex in termination check");
+  msg (w, 3, "early termination check %s", res ? "succeeded" : "failed");
+  return res;
+}
+
+static void progress (int pmille, int total, int max, double avg, int nl) {
+  int ch, i, lim, eta;
+  char fmt[10];
+  double rem;
+  msglock (0);
+  if (isatty (1)) fputc ('\r', stdout);
+
+  lim = 10;
+  for (i = 1; lim < max && i < 11; i++) lim *= 10;
+  sprintf (fmt, "c %%0%dd", i);
+  printf (fmt, total);
+  printf (" / %d |", max);
+
+  for (i = 0; i < pmille/50; i++) fputc ('=', stdout);
+  if (total == max) ch = '=';
+  else switch (pmille % 4) {
+    case 1 : ch = '\\'; break;
+    case 2 : ch = '|'; break;
+    case 3 : ch = '/'; break;
+    default: ch = '-'; break;
+  }
+  if (i++ < 20) fputc (ch, stdout);
+  while (i++ < 20) fputc ('-', stdout);
+
+  printf ("| %3d%%", pmille/10);
+
+  printf (" %.4f sec/cube", avg);
+
+  if (max <= total) eta = 0;
+  else {
+    rem = (max - total) * avg;
+    if (rem >= 100*3600) eta = INT_MAX;
+    else { eta = rem; assert (eta < INT_MAX); }
+  }
+  if (eta < INT_MAX) {
+    if (eta > 3600) printf (" %02d:", eta / 3600), eta %= 3600;
+    else printf ("    ");
+    printf ("%02d:%02d ETS", eta/60, eta%60);
+  } else printf ("   --:-- ETS");
+  if (nl || !isatty (1)) fputc ('\n', stdout);
+  fflush (stdout);
+  msgunlock (0);
+}
+
+static void initlgl (LGL * lgl, Worker * w, int opts) {
+  lglsetid (lgl, WID (w), nworkers);
+  lglsetime (lgl, getime);
+  lglseterm (lgl, term, w);
+  lglsetmsglock (lgl, msglock, msgunlock, w);
+  if (!opts) return;
+  if (verbose) lglsetopt (lgl, "verbose", verbose-1);
+  if (plain) lglsetopt (lgl, "plain", 1);
+  lglsetopt (lgl, "reduceinc", 1000);
+  lglsetopt (lgl, "reduceinit", 1000);
+  lglsetopt (lgl, "reusetrail", 1);
+  lglsetopt (lgl, "gluekeep", 3);
+  lglsetopt (lgl, "scincinc", 50);
+  lglsetopt (lgl, "scincincmode", 0);
+  if (druptraceprefix) {
+    char * name = malloc (strlen (druptraceprefix) + 30);
+    sprintf (name, "%s%d.proof", druptraceprefix, WID (w));
+    if (!(w->proof = fopen (name, "w")))
+      die ("worker %d can not write DRUP proof to '%s'", WID (w), name);
+    lglsetout (lgl, w->proof);
+    sprintf (name, "%s%d.cnf", druptraceprefix, WID (w));
+    if (!(w->post = fopen (name, "w")))
+      die ("worker %d can not write post CNF cubes to '%s'", WID (w), name);
+    free (name);
+    lglsetopt (lgl, "druplig", 1);
+    lglsetopt (lgl, "drupligtrace", 1);
+  } else w->post = w->proof = 0;
+}
+
+static int justreturn (Worker * w) {
+  int res;
+  if (pthread_mutex_lock (&donemutex))
+    warn ("worker %d failed to lock 'done' mutex", WID (w));
+  res = done;
+  if (pthread_mutex_unlock (&donemutex))
+    warn ("worker %d failed to unlock 'done' mutex", WID (w));
+  return res;
+}
+
+static int sat (Worker * w) {
+#ifndef NDEBUG
+  int oldres;
+#endif
+  int res;
+  char name[100];
+  LGL * cloned;
+  if (!druptraceprefix && clone) lglsetopt (w->lgl, "clim", CLONELIMIT);
+  else lglsetopt (w->lgl, "clim", -1),
+       lglsetopt (w->lgl, "plim", -1),
+       lglsetopt (w->lgl, "dlim", -1);
+  if (!noflush) lglflushcache (w->lgl);
+  res = lglsat (w->lgl);
+  assert (!druptraceprefix || !clone || res);
+  if (!res && !justreturn (w)) {
+    msg (w, 1, "cloning after %d conflicts", CLONELIMIT);
+    cloned = lglclone (w->lgl);
+    lglfixate (cloned);
+    lglmeltall (cloned);
+    initlgl (cloned, w, 0);
+    lglsetopt (cloned, "clim", -1);
+    sprintf (name, "c F%d ", w->cloned.count++);
+    lglsetprefix (cloned, name);
+    if (pthread_mutex_lock (&w->cloned.lock))
+      warn ("worker %d failed to lock 'cloned' mutex", WID (w));
+    assert (!w->cloned.lgl);
+    w->cloned.lgl = cloned;
+    if (pthread_mutex_unlock (&w->cloned.lock))
+      warn ("worker %d failed to unlock 'cloned' mutex", WID (w));
+    res = lglsat (cloned);
+    if (pthread_mutex_lock (&w->cloned.lock))
+      warn ("worker %d failed to lock 'cloned' mutex", WID (w));
+    assert (cloned == w->cloned.lgl);
+    w->cloned.lgl = 0;
+    w->cloned.decs += lglgetdecs (cloned);
+    w->cloned.confs += lglgetconfs (cloned);
+    w->cloned.props += lglgetprops (cloned);
+    w->cloned.decs -= lglgetdecs (w->lgl);
+    w->cloned.confs -= lglgetconfs (w->lgl);
+    w->cloned.props -= lglgetprops (w->lgl);
+    if (pthread_mutex_unlock (&w->cloned.lock))
+      warn ("worker %d failed to unlock 'cloned' mutex", WID (w));
+    if (verbose >=2 && statsfile) {
+      lglsetout (cloned, statsfile);
+      lglstats (cloned);
+      lglsetout (cloned, stdout);
+    }
+    msg (w, 1, "joining cloned solver");
+#ifndef NDEBUG
+    oldres = 
+#else
+    (void)
+#endif
+    lglunclone (w->lgl, cloned);
+    assert (!oldres || res == oldres);
+    assert (res);
+  }
+  return res;
+}
+
+static void * work (void * voidptr) {
+  int i, last, pm, lm, count, lit, idx, *a, * p, size, red, fin;
+  double start, end, delta, avg;
+  Worker * w = voidptr;
+  msg (w, 1, "running");
+  for (;;) {
+    if (pthread_mutex_lock (&queuemutex))
+      die ("worker %d failed to lock 'queue' mutex", WID (w));
+    assert (queue <= nassumptions);
+    if (deterministic && (queue % nworkers) != WID (w)) {
+      if (pthread_mutex_unlock (&queuemutex))
+	die ("worker %d failed to unlock 'queue' mutex", WID (w));
+      usleep (1000);
+      continue;
+    }
+    if ((last = queue) < nassumptions) queue++;
+    if (pthread_mutex_unlock (&queuemutex))
+      die ("worker %d failed to unlock 'queue' mutex", WID (w));
+    if (last == nassumptions) {
+DONE:
+      if (!bar) msg (w, 1, "done");
+      return 0;
+    }
+    msg (w, 2, "got job %d", last);
+    count = 0;
+    for(i = w->last + 1; i <= last; i++) {
+      a = assumptions[i];
+      if (addassumptions > 1 && i < last) {
+	for (p = a; (lit = *p); p++) lgladd (w->lgl, -lit);
+	lgladd (w->lgl, 0);
+      }
+    if (!nomelt)
+      for (p = a; (lit = *p); p++)
+	if (used [idx = abs (lit)] == i)
+	  lglmelt (w->lgl, idx), count++;
+    }
+    msg (w, 2, "melted %d variables", count);
+    a = assumptions[w->last = last];
+    if (noreverse) {
+      for (p = a; (lit = *p); p++)
+	lglassume (w->lgl, lit);
+    } else {
+      for (i = 0; a[i]; i++)
+	;
+      for (p = a + i - 1; p >= a; p--)
+	lglassume (w->lgl, *p);
+    }
+    start = getime ();
+    w->res = sat (w);
+    end = getime ();
+    delta = end - start;
+    delta = (delta <= 0) ? 0 : delta;
+    times[last] = delta;
+    if (bar) {
+      (void) pthread_mutex_lock (&finishedmutex);
+      fin = ++finished;
+      sumtimes += delta;
+      avg = sumtimes / fin;
+      (void) pthread_mutex_unlock (&finishedmutex);
+      pm = (1000*(fin-1))/nassumptions;
+      lm = (1000*fin)/nassumptions;
+      if (pm < lm) progress (lm, fin, nassumptions, avg, 0);
+    }
+    if (w->res == 10) {
+      if (!bar) msg (w, 1, "job %d SATISFIABLE", last);
+      if (pthread_mutex_lock (&donemutex))
+	warn ("worker %d failed to lock 'done' mutex", WID (w));
+      done = 1;
+      if (pthread_mutex_unlock (&donemutex))
+	warn ("worker %d failed to unlock 'done' mutex", WID (w));
+      goto DONE;
+    } else if (w->res == 20) {
+      w->nfailed = 0;
+      if (!w->failed) NEW (w->failed, maxassumptionsize);
+      for (p = a; (lit = *p); p++)
+	if (lglfailed (w->lgl, lit)) {
+	  assert (w->nfailed < maxassumptionsize);
+	  w->failed[w->nfailed++] = lit;
+	}
+      if (druptraceprefix) {
+	assert (w->proof);
+	for (i = 0; i < w->nfailed; i++)
+	  fprintf (w->proof, "%d ", -w->failed[i]);
+	fputs ("0\n", w->proof);
+	for (i = 0; i < w->nfailed; i++)
+	  fprintf (w->proof, "%d ", -w->failed[i]);
+	fputs ("0\n", w->proof);
+      }
+      if (addassumptions) {
+	for (i = 0; i < w->nfailed; i++)
+	  lgladd (w->lgl, -w->failed[i]);
+        lgladd (w->lgl, 0);
+      }
+      if (druptraceprefix) {
+	assert (w->post);
+	for (i = 0; i < w->nfailed; i++)
+	  fprintf (w->post, "%d ", -w->failed[i]);
+	fputs ("0\n", w->post);
+      }
+      red = w->nfailed;
+      sumassumptions += (size = p - a);
+      redassumptions += red;
+      if (!bar)
+        msg (w, 1, "job %d UNSATISFIABLE (%d failed / %d) in %.3f seconds",
+	     last, red, size, delta);
+      if (!red && !deterministic) {
+	if (!bar) msg (w, 1, "job %d ACTUALLY FOUND EMPTY CLAUSE", last);
+	if (pthread_mutex_lock (&donemutex))
+	  warn ("worker %d failed to lock 'done' mutex", WID (w));
+	done = 1;
+	if (pthread_mutex_unlock (&donemutex))
+	  warn ("worker %d failed to unlock 'done' mutex", WID (w));
+	goto DONE;
+      }
+      if (reduce) lglreducecache (w->lgl);
+    } else {
+      if (!bar) msg (w, 1, "job %d UNKNOWN", last);
+      goto DONE;
+    }
+  }
+}
+
+static void init (void) {
+  Worker * w;
+  assert (nworkers > 0);
+  NEW (workers, nworkers);
+  for (w = workers; w < workers + nworkers; w++) {
+    w->last = -1;
+    w->lgl = lglinit ();
+    pthread_mutex_init (&w->cloned.lock, 0);
+    initlgl (w->lgl, w, 1);
+  }
+  msg (0, 1, "allocated %d workers", nworkers);
+}
+
+static void reset (void) {
+  int i, * p, * a;
+  if (vals) DEL (vals, nvars);
+  for (i = 0; i < nworkers; i++) {
+    Worker * w = workers + i;
+    lglrelease (w->lgl);
+    if (w->proof) {
+      assert (druptraceprefix);
+      assert (w->proof);
+      w->proof = 0;
+      assert (w->post);
+      fclose (w->post);
+      w->post = 0;
+    } else assert (!w->post);
+    if (w->failed) DEL (w->failed, maxassumptionsize);
+  }
+  DEL (workers, nworkers);
+  for (i = 0; i < nassumptions; i++) {
+    for (p = (a = assumptions[i]); *p; p++)
+      ;
+    DEL (a, (p - a) + 1);
+  }
+  DEL (assumptions, szassumptions);
+  DEL (times, nassumptions);
+  DEL (lits, szlits);
+  DEL (used, szvars);
+  if (allocated) 
+    warn ("internal memory leak of %lld bytes", (long long) allocated);
+}
+
+static void perr (const char * fmt, ...) {
+  va_list ap;
+  fprintf (stderr, "%s:%d: ", inputname, lineno);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  exit (1);
+}
+
+static int next (void) {
+  int res;
+  res = getc (inputfile);
+  if (res == '\n') lineno++;
+  return res;
+}
+
+static void add (int lit) {
+  int i;
+  for (i = 0; i < nworkers; i++) lgladd (workers[i].lgl, lit);
+}
+
+static void parse (void) {
+  int ch, lit, sign, * assumption, i;
+HEADER:
+  ch = next ();
+  if (ch == EOF) perr ("unexpected end-of-file in header");
+  if (ch == 'c') {
+    while ((ch = next ()) != '\n')
+      if (ch == EOF)
+	perr ("unexpected end-of-file in header comment");
+    goto HEADER;
+  }
+  if (ch != 'p' ||
+      next () != ' ' ||
+      next () != 'i' ||
+      next () != 'n' ||
+      next () != 'c' ||
+      next () != 'c' ||
+      next () != 'n' ||
+      next () != 'f') perr ("invalid header (expected 'p inccnf')");
+  ch = next ();
+CLAUSES:
+  if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') {
+    ch = next (); goto CLAUSES;
+  }
+  if (ch == 'c') {
+    while ((ch = next ()) != '\n')
+      if (ch == EOF)
+	perr ("unexpected end-of-file in body comment");
+    goto CLAUSES;
+  }
+  if (ch == EOF && nlits) perr ("unexpected end-of-file in clause");
+  if (ch == 'a' && nlits) perr ("unexpected 'a' in clause");
+  if (ch == 'a') goto ASSUMPTIONS;
+  if (ch == EOF) goto DONE;
+  if (ch == 'a') goto ASSUMPTIONS;
+  if (ch == '-') {
+    sign = -1;
+    ch = next ();
+    if (!isdigit (ch)) perr ("expected digit after '-'");
+  } else sign = 1;
+  if (!isdigit (ch)) perr ("expected literal");
+  lit = ch - '0';
+  while (isdigit (ch = next ())) lit = 10*lit + ch - '0';
+  if (lit > nvars) {
+    if (lit >= szvars) {
+      int oldszvars = szvars;
+      szvars = szvars ? 2*szvars : 1;
+      while (szvars <= lit) szvars *= 2;
+      RSZ (used, oldszvars, szvars);
+      for (i = oldszvars; i < szvars; i++) used[i] = -1;
+    }
+    assert (lit < szvars);
+    nvars = lit;
+  }
+  lit *= sign;
+  if (lit) nlits++; else nlits = 0, nclauses++;
+  add (lit);
+  goto CLAUSES;
+ASSUMPTIONS:
+  assert (!nlits);
+  assert (ch == 'a');
+  ch = next ();
+  if (ch != ' ') perr ("expected space after 'a'");
+LITS:
+  ch = next ();
+  if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') goto LITS;
+  if (ch == EOF && nlits) perr ("unexpected end-of-file in assumptions");
+  if (ch == '-') {
+    sign = -1;
+    ch = next ();
+    if (!isdigit (ch)) perr ("expected digit after '-'");
+  } else sign = 1;
+  if (!isdigit (ch)) perr ("expected literal");
+  lit = ch - '0';
+  while (isdigit (ch = next ())) lit = 10*lit + ch - '0';
+  if (lit > nvars)
+    perr ("assumption %d exceeds maximum variables %d", lit, nvars);
+  assert (0 <= lit && lit < szvars);
+  if (used[lit] < 0) nused++;
+  used[lit] = nassumptions;
+  lit *= sign;
+  if (ch != ' ' && ch != '\t' && ch != '\r' && ch != '\n')
+    perr ("expected white space after '%l'", lit);
+  if (lit) { PUSH (lits, lit); goto LITS; }
+  NEW (assumption, nlits + 1);
+  for (i = 0; i < nlits; i++) assumption[i] = lits[i];
+  assert (!assumption[nlits]);
+  PUSH (assumptions, assumption);
+  if (nlits > maxassumptionsize) maxassumptionsize = nlits;
+  nlits = 0;
+NEXT:
+  ch = next ();
+  if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') goto NEXT;
+  if (ch == EOF) goto DONE;
+  if (ch == '-' || isdigit (ch))
+#if 1
+    goto CLAUSES;
+  if (ch != 'a') perr ("expected literal, 'a' or end-of-file");
+#else
+    perr ("can not handle clauses after assumptions yet");
+  if (ch != 'a') perr ("expected 'a' or end-of-file");
+#endif
+  goto ASSUMPTIONS;
+DONE:
+  msg (0, 1, "maximum variable %d in %d clauses", nvars, nclauses);
+  msg (0, 1, "parsed %d assumptions", nassumptions);
+  nvars++;
+  NEW (times, nassumptions);
+  for (i = 0; i < nassumptions; i++) times[i] = -1;
+}
+
+static void freeze (void) {
+  int idx, i;
+  for (idx = 1; idx < nvars; idx++)
+    if (used[idx] >= 0)
+      for (i = 0; i < nworkers; i++)
+	lglfreeze (workers[i].lgl, idx);
+}
+
+static void start (void) {
+  Worker * w;
+  for (w = workers; w < workers + nworkers; w++) {
+    if (pthread_create (&w->thread, 0, work, w))
+      die ("failed to create worker thread %d", WID (w));
+  }
+}
+
+static void stop (void) {
+  Worker * w;
+  double avg;
+  for (w = workers; w < workers + nworkers; w++)
+    if (pthread_join (w->thread, 0))
+      die ("failed to join worker %d", WID (w));
+  if (bar) {
+    avg = finished ? sumtimes / finished : 0.0;
+    progress ((1000*finished)/nassumptions, finished, nassumptions, avg, 1);
+  }
+  msg (0, 1, "joined all %d workers", nworkers);
+}
+
+static void statsps (FILE * file,
+                     const char * name, long long stats, double time) {
+  const char * scale;
+  if (stats > 10000000) scale = " million", stats /= 1000000;
+  else if (stats > 10000) scale = " thousand", stats /= 1000;
+  else scale = "";
+  fprintf (file, 
+           "c %lld%s %s, %.1f%s per second\n",
+           stats, scale, name, (time > 0 ? stats/time : 0.0), scale);
+}
+
+static int cmpdblptr (const void * p, const void * q) {
+  double a = *(double*)p;
+  double b = *(double*)q;
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+static void stats (void) {
+  int64_t decs = 0, confs = 0, props = 0;;
+  double mb  = maxallocated / (double)(1<<20);
+  double wct = getime (), prt = lglprocesstime ();
+  FILE * file = statsfile ? statsfile : stdout;
+  double sum, t, min, max, avg, std;
+  int i, n, cloned = 0;
+  for (i = 0; i < nworkers; i++) lglflushtimers (workers[i].lgl);
+  for (i = 0; i < nworkers; i++) {
+    lglflushtimers (workers[i].lgl);
+    fprintf (file, "c\n");
+    fprintf (file, "c ---------[worker %d stats]------------------\n", i);
+    fprintf (file, "c\n");
+    lglsetout (workers[i].lgl, file);
+    lglstats (workers[i].lgl);
+    lglsetout (workers[i].lgl, stdout);
+    mb += lglmb (workers[i].lgl);
+    decs += lglgetdecs (workers[i].lgl);
+    confs += lglgetconfs (workers[i].lgl);
+    props += lglgetprops (workers[i].lgl);
+    if (pthread_mutex_lock (&workers[i].cloned.lock))
+      warn ("worker failed to lock 'cloned' mutex");
+    if (workers[i].cloned.lgl) {
+      fprintf (file, "c ---------[cloned worker %d dstats]----------\n", i);
+      fprintf (file, "c\n");
+      lglsetout (workers[i].cloned.lgl, file);
+      lglstats (workers[i].cloned.lgl);
+      lglsetout (workers[i].cloned.lgl, stdout);
+      mb += lglmb (workers[i].cloned.lgl);
+      decs += lglgetdecs (workers[i].cloned.lgl);
+      confs += lglgetconfs (workers[i].cloned.lgl);
+      props += lglgetprops (workers[i].cloned.lgl);
+      mb -= lglmb (workers[i].lgl);
+      decs -= lglgetdecs (workers[i].lgl);
+      confs -= lglgetconfs (workers[i].lgl);
+      props -= lglgetprops (workers[i].lgl);
+    }
+    decs += workers[i].cloned.decs;
+    confs += workers[i].cloned.confs;
+    props += workers[i].cloned.props;
+    cloned += workers[i].cloned.count;
+    if (pthread_mutex_unlock (&workers[i].cloned.lock))
+      warn ("worker failed to lock 'cloned' mutex");
+  }
+  fprintf (file, "c\n");
+  fprintf (file, "c ---------[global-stats]-------------------------\n");
+  fprintf (file, "c\n");
+  statsps (file, "scheduled jobs", queue, wct);
+  fprintf (file, "c %d failed assumptions %.0f%% out of %d\n",
+	   redassumptions,
+	   sumassumptions ? (100.0*redassumptions)/sumassumptions : 0,
+           sumassumptions);
+  fprintf (file, "c\n");
+  fprintf (file, "c %d cloned\n", cloned);
+  fprintf (file, "c\n");
+  statsps (file, "conflicts", confs, wct);
+  statsps (file, "decisions", decs, wct);
+  statsps (file, "propagations", props, wct);
+  fprintf (file, "c wall clock time %.1f seconds\n", wct);
+  fprintf (file, "c process time %.1f seconds\n", prt);
+  fprintf (file, "c utilization %.0f%%\n", 
+           wct > 0 ? 100.0 * (prt / wct / nworkers) : 0.0);
+  fflush (file);
+  n = 0;
+  sum = 0;
+  max = min = -1;
+  for (i = 0; i < nassumptions; i++) {
+    if ((t = times[i]) < 0) continue;
+    sum += t;
+    times[n++] = t;
+    if (min < 0 || (t < min)) min = t;
+    if (max < 0 || (t > max)) max = t;
+  }
+  if (n) {
+    fprintf (file, "c\n");
+    avg = sum/n;
+    fprintf (file, "c %d finished jobs in average time %.3f\n", n, avg);
+    fprintf (file, "c time: sum %.3f, min %.3f, max %.3f\n", sum, min, max);
+    std = 0;
+    for (i = 0; i < n; i++) {
+      t = times[i] - avg;
+      std += t*t;
+    }
+    std = sqrt (std);
+    qsort (times, n, sizeof times, cmpdblptr);
+    fprintf (file, "c time: median %.3f, std dve %.3f\n", times[n/2], std);
+  }
+  fflush (file);
+}
+
+static void hist (void) {
+  FILE * file = histfile ? histfile : stdout;
+  int i;
+  for (i = 0; i < nassumptions; i++)
+    fprintf (file, "%.3f\n", times[i]);
+  fflush (file);
+}
+
+static int catchedsig;
+static void (*sig_int_handler)(int);
+static void (*sig_segv_handler)(int);
+static void (*sig_abrt_handler)(int);
+static void (*sig_term_handler)(int);
+
+static void resetsighandlers (void) {
+  (void) signal (SIGINT, sig_int_handler);
+  (void) signal (SIGSEGV, sig_segv_handler);
+  (void) signal (SIGABRT, sig_abrt_handler);
+  (void) signal (SIGTERM, sig_term_handler);
+}
+
+static void caughtsigmsg (int sig) {
+  if (!verbose) return;
+  printf ("c\nc CAUGHT SIGNAL %d\nc\n", sig);
+  fflush (stdout);
+}
+
+static void catchsig (int sig) {
+  if (!catchedsig) {
+    fputs ("s UNKNOWN\n", stdout);
+    fflush (stdout);
+    catchedsig = 1;
+    caughtsigmsg (sig);
+    if (statsfile) stats ();
+    if (histfile) hist ();
+    if (statsfile || histfile) caughtsigmsg (sig);
+  }
+  resetsighandlers ();
+  if (!getenv ("LGLNABORT")) raise (sig); else exit (1);
+}
+
+static void setsighandlers (void) {
+  sig_int_handler = signal (SIGINT, catchsig);
+  sig_segv_handler = signal (SIGSEGV, catchsig);
+  sig_abrt_handler = signal (SIGABRT, catchsig);
+  sig_term_handler = signal (SIGTERM, catchsig);
+}
+
+int main (int argc, char ** argv) {
+  const char * statsfilename = 0, * histfilename = 0;
+  int i, closeinputfile, res = 0;
+  Worker * winner, * w;
+  startime = currentime ();
+  for (i = 1; i < argc; i++) { if (!strcmp (argv[i], "-h")) {
+      printf (
+"usage: ilingeling [<option> ...][<inccnf>][<nworkers>]\n"
+"\n"
+"where <option> is one of the following:\n"
+"\n"
+"  -h  print this command line option summary\n"
+"\n"
+"  -v  increase verbose level\n"
+"  -q  do not print 'c job ...' lines (requires verbosity < 2)\n"
+"  -b  progress bar (implies '-q')\n"
+"\n"
+"  --version\n"
+"\n"
+"  -s  <stats> output statistics to separate file\n"
+"  -t  <hist> output job run time histogram to separate file\n"
+"\n"
+"  --clone       use cloning for hard cubes\n"
+"  --reduce      reduce learned clause cache after each job\n"
+"  --no-melt     do not melt unused assumption variables\n"
+"  --no-flush    do not flush learned clause cache before every job\n"
+"  --no-reverse  do not reverse assumptions\n"
+"\n"
+"  --deterministic | --det\n"
+"\n"
+"            jobs are mapped deterministically to workers\n"
+"\n"
+"  --no-add    do not add failed assumptions as don't care\n"
+"  -A  add all assumptions as don't care\n"
+"\n"
+"  <inccnf>    'p inccnf' + '<lit*> 0' clauses + 'a <lit>* 0' assumptions\n"
+"  <nworkers>  number of workers defaults to 1\n"
+"\n"
+"  -d|--drup   <path-prefix-for-traces>\n");
+      exit (0);
+    } else if (!strcmp (argv[i], "--version")) {
+      printf ("%s\n", lglversion ());
+      exit (0);
+    } else if (!strcmp (argv[i], "-v")) verbose++;
+    else if (!strcmp (argv[i], "-b")) bar = 1;
+    else if (!strcmp (argv[i], "-n")) nowitness = 1;
+    else if (!strcmp (argv[i], "--no-reverse")) noreverse = 1;
+    else if (!strcmp (argv[i], "--no-add")) addassumptions = 0;
+    else if (!strcmp (argv[i], "--no-melt")) nomelt = 1;
+    else if (!strcmp (argv[i], "--reduce")) reduce = 1;
+    else if (!strcmp (argv[i], "--deterministic") ||
+             !strcmp (argv[i], "--det"))
+      deterministic = 1;
+    else if (!strcmp (argv[i], "-A")) addassumptions = 2;
+    else if (!strcmp (argv[i], "-p")) plain = 1;
+    else if (!strcmp (argv[i], "-s")) {
+      if (statsfilename) die ("two '-s' options");
+      if (++i == argc) die ("argument to '-s' missing");
+      statsfilename = argv[i];
+    } else if (!strcmp (argv[i], "-t")) {
+      if (histfilename) die ("two '-t' options");
+      if (++i == argc) die ("argument to '-t' missing");
+      histfilename = argv[i];
+    } else if (!strcmp (argv[i], "--clone")) clone = 1;
+    else if (!strcmp (argv[i], "--no-flush")) noflush = 1;
+    else if (!strcmp (argv[i], "-d") || !strcmp (argv[i], "--drup")) {
+      if (++i == argc) die ("argument to '%s' missing", argv[i]);
+      if (druptraceprefix) die ("DRUP path prefix set twice");
+      druptraceprefix = argv[i];
+    }
+    else if (argv[i][0] == '-') die ("invalid option '%s'", argv[i]);
+    else if (isnum (argv[i])) {
+      if (nworkers) die ("number of workers specified twice: '%d' and '%s'",
+	                 nworkers, argv[i]);
+      if ((nworkers = atoi (argv[i])) <= 0)
+	die ("invalid number of workers argument: '%s'", argv[i]);
+    } else if (inputname)
+      die ("two files given: '%s' and '%s'", inputname, argv[i]);
+    else inputname = argv[i];
+  }
+  if (bar && !isatty (1)) 
+    die ("progress bar requested but <stdout> not connected to terminal");
+  if (verbose >= 2 && bar) die ("verbosity %d > 1 with '-b'", verbose);
+  if (statsfilename && !(statsfile = fopen (statsfilename, "w")))
+    die ("can not write to stats file '%s'", statsfilename);
+  if (histfilename && !(histfile = fopen (histfilename, "w")))
+    die ("can not write to job run time histogram file '%s'", histfilename);
+  if (verbose && !statsfile) statsfile = stdout;
+  if (verbose)
+    lglbnr ("iLingeling Incremental Parallel Lingeling", "c ", stdout),
+    printf ("c\n"), fflush (stdout);
+  if (!nworkers) nworkers = 1;
+  msg (0, 1, "using %d workers", nworkers);
+  if (inputname) {
+    if (!(inputfile = fopen (inputname, "r"))) 
+      die ("can not read '%s'", inputname);
+    closeinputfile = 1;
+  } else inputname = "<stdin>", inputfile = stdin, closeinputfile = 0;
+  init ();
+  setsighandlers ();
+  msg (0, 1, "parsing %s", inputname);
+  parse ();
+  if (closeinputfile) fclose (inputfile);
+  msg (0, 1, "%d variables out of %d used in assumptions which is %.0f%%",
+       nused, nvars, nvars ? 100.0 * (nused /(double)nvars) : 0.0);
+  freeze ();
+  start ();
+  stop ();
+  winner = 0;
+  for (w = workers; w < workers + nworkers; w++)
+    if (w->res) { winner = w;  if (w->res == 10) break; }
+  if (winner && (res = winner->res) == 10 && !nowitness) {
+      NEW (vals, nvars);
+      for (i = 1; i < nvars; i++)
+	vals[i] = lglderef (winner->lgl, i);
+  }
+  assert (winner || !nassumptions);
+  resetsighandlers ();
+  if (statsfile) stats ();
+  if (statsfilename) fclose (statsfile);
+  if (histfile) hist ();
+  if (histfile) fclose (histfile);
+  if (res == 10) printf ("s SATISFIABLE\n");
+  else if (res == 20) printf ("s UNSATISFIABLE\n");
+  else printf ("s UNKNOWN\n");
+  fflush (stdout);
+  if (vals) {
+    for (i = 1; i < nvars; i++) {
+      fputs ("v ", stdout);
+      if (vals[i] < 0) fputc ('-', stdout);
+      printf ("%d\n", i);
+    }
+    fputs ("v 0\n", stdout);
+    fflush (stdout);
+  }
+  reset ();
+  return res;
+}
diff --git a/lglbnr.c b/lglbnr.c
new file mode 100644
index 0000000..ee44b04
--- /dev/null
+++ b/lglbnr.c
@@ -0,0 +1,54 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include "lglib.h"
+#include "lglcfg.h"
+#include "lglcflags.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+void lglbnr (const char * name, const char * prefix, FILE * file) {
+  const char * p = LGL_CFLAGS, * q, * n;
+  int len = 78 - strlen (prefix);
+  fprintf (file, "%s%s\n", prefix, name);
+  fprintf (file, "%s\n", prefix);
+  fprintf (file, "%sVersion %s %s\n", prefix, LGL_VERSION, LGL_ID);
+  fprintf (file, "%s\n", prefix);
+  fprintf (file, 
+     "%sCopyright (C) 2010-2016 Armin Biere JKU Linz Austria.\n",
+      prefix);
+  fprintf (file, "%sAll rights reserved.\n", prefix);
+  fprintf (file, "%s\n", prefix);
+  fprintf (file, "%sreleased %s\n", prefix, LGL_RELEASED);
+  fprintf (file, "%scompiled %s\n", prefix, LGL_COMPILED);
+  fprintf (file, "%s\n", prefix);
+  fprintf (file, "%s%s\n", prefix, LGL_CC);
+  assert (*p);
+  for (;;) {
+    fputs (prefix, file);
+    for (q = p; *q && *q != ' '; q++)
+      ;
+    if (*q && q - p < len) {
+      for (;;) {
+	for (n = q + 1; *n && *n != ' '; n++)
+	  ;
+	if (n - p >= len) break;
+	q = n;
+	if (!*n) break;
+      }
+    }
+    while (p < q) fputc (*p++, file);
+    fputc ('\n', file);
+    if (!*p) break;
+    assert(*p == ' ');
+    p++;
+  }
+  fprintf (file, "%s%s\n", prefix, LGL_OS);
+  fprintf (file, "%s\n", prefix);
+  fflush (file);
+}
+
+const char * lglversion (void) { return LGL_VERSION " " LGL_ID; }
diff --git a/lglconst.h b/lglconst.h
new file mode 100644
index 0000000..6491bb1
--- /dev/null
+++ b/lglconst.h
@@ -0,0 +1,41 @@
+#ifndef lglconst_h_INCLUDED
+#define lglconst_h_INCLUDED
+
+#include <limits.h>
+
+#define REMOVED		INT_MAX
+#define NOTALIT		((INT_MAX >> RMSHFT))
+#define MAXVAR		((INT_MAX >> RMSHFT) - 2)
+
+#define GLUESHFT	4
+#define POW2GLUE	(1 << GLUESHFT)
+#define MAXGLUE		(POW2GLUE - 1)
+#define GLUEMASK	(POW2GLUE - 1)
+#define MAXREDLIDX	((1 << (31 - GLUESHFT)) - 2)
+#define MAXIRRLIDX	((1 << (31 - RMSHFT)) - 2)
+
+#define MAXLDFW		31	
+#define REPMOD 		22
+
+#define FUNVAR		12
+#define FUNQUADS	(1<<(FUNVAR - 6))
+#define FALSECNF	(1ll<<32)
+#define TRUECNF		0ll
+
+#define FLTPRC 		32
+#define EXPMIN 		(0x0000 ## 0000)
+#define EXPZRO 		(0x1000 ## 0000)
+#define EXPMAX		(0x7fff ## ffff)
+#define MNTBIT		(0x0000 ## 0001 ## 0000 ## 0000 ## ull)
+#define MNTMAX		(0x0000 ## 0001 ## ffff ## ffff ## ull)
+#define FLTMIN		(0x0000 ## 0000 ## 0000 ## 0000 ## ll)
+#define FLTMAX		(0x7fff ## ffff ## ffff ## ffff ## ll)
+
+#define DEFSCOREXP	500
+
+#define LLMAX		(0x7fff ## ffff ## ffff ## ffff ## ll)
+
+#define MAXFLTSTR	6
+#define MAXPHN		10
+
+#endif
diff --git a/lglddtrace.c b/lglddtrace.c
new file mode 100644
index 0000000..6e10a8f
--- /dev/null
+++ b/lglddtrace.c
@@ -0,0 +1,843 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <assert.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "lglib.h"
+
+void lglchkclone (LGL *);
+
+static int runs, golden, timelimit;
+static int lineno, verbose, checkreturn, ddopts;
+static int nmap = -1, szmap, * map, prevents;
+static const char * iname, * oname;
+
+typedef enum Type {
+  ADD,ASSUME,DEREF,FAILED,FREEZE,INIT,
+  MELT,REUSE,OPTION,PHASE,RELEASE,RETURN,SAT,SIMP,REPR,SETIMPORTANT,
+  SETPHASE,RESETPHASE,SETPHASES,FLUSH,REDUCE,FROZEN,USABLE,REUSABLE,
+  MAXVAR,INCVAR,FIXED,FIXATE,CHKCLONE,CHANGED,INCONSISTENT,LKHD
+} Type;
+
+struct Event;
+
+typedef struct Event {
+  Type type;
+  int removed, arg;
+  char * opt;
+} Event;
+
+typedef struct Opt {
+  char * name;
+  int val, min, max;
+} Opt;
+
+static Event * events;
+static int nevents, szevents;
+
+static Opt * opts;
+static int nopts, szopts;
+static long long sumoptvals;
+
+typedef struct Range { int from, to, removed; } Range;
+
+static void event (Type type, int arg, const char * opt) {
+  Event * e;
+  int idx;
+  if (nevents == szevents) {
+    szevents = szevents ? 2*szevents : 1;
+    events = realloc (events, szevents * sizeof *events);
+  }
+  e = events + nevents++;
+  e->type = type;
+  e->arg = arg;
+  e->opt = opt ? strdup (opt) : 0;
+  e->removed = INT_MAX;
+
+  switch (type) {
+    case ADD:
+    case ASSUME:
+    case DEREF:
+    case FAILED:
+    case FREEZE:
+    case SETIMPORTANT:
+    case SETPHASE:
+    case RESETPHASE:
+    case MELT:
+    case REUSE:
+    case PHASE:
+    case FIXED:
+    case FROZEN:
+    case REUSABLE:
+    case USABLE:
+    case REPR:
+      idx = abs (e->arg);
+      if (idx > nmap) {
+	if (idx >= szmap) {
+	  do { szmap = szmap ? 2*szmap : 2; } while (szmap <= idx);
+	  map = realloc (map, szmap * sizeof *map);
+	}
+	nmap = idx;
+      }
+      map[idx] = idx;
+      break;
+    default:
+      break;
+  }
+}
+
+static void die (const char * fmt, ...) {
+  va_list ap;
+  fputs ("*** lglddtrace: ", stderr);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  exit (1);
+}
+
+static void perr (const char * fmt, ...) {
+  va_list ap;
+  fprintf (stderr,
+           "*** lglddtrace: parse error in '%s' line %d: ", iname, lineno);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  exit (1);
+}
+
+static void rep (const char * fmt, ...) {
+  va_list ap;
+  if (!verbose) return;
+  if (!isatty (1)) return;
+  fputs ("c [lglddtrace] ", stdout);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputs ("       \r", stdout);
+  fflush (stdout);
+}
+
+static void msg (const char * fmt, ...) {
+  va_list ap;
+  if (!verbose) return;
+  fputs ("c [lglddtrace] ", stdout);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+static int isnumstr (const char * str) {
+  const char * p;
+  int ch;
+  if (*(p = str) == '-') p++;
+  if (!isdigit ((int)*p++)) return 0;
+  while (isdigit (ch = *p)) p++;
+  return !ch;
+}
+
+static int intarg (char * op) {
+  const char * tok;
+  if (!(tok = strtok (0, " ")) || !isnumstr (tok) || strtok (0, " "))
+    perr ("expected integer argument for '%s'", op);
+  assert (tok);
+  return atoi (tok);
+}
+
+static int remr (Range * r) { return r->removed <= runs; }
+static int reme (Event * e) { return e->removed <= runs; }
+
+static void onabort (void * d) { (void) d; exit (0); }
+
+static void process (void) {
+  int saved1, saved2, null, tmp, res;
+  struct rlimit rlim;
+  LGL * lgl;
+  Event * e;
+  Opt * o;
+  rlim.rlim_max = (rlim.rlim_cur = timelimit) + 10;
+  setrlimit (RLIMIT_CPU, &rlim);
+  saved1 = dup (1);
+  saved2 = dup (2);
+  null = open ("/dev/null", O_WRONLY);
+  close (1);
+  close (2);
+  tmp = dup (null);
+  assert (tmp == 1);
+  tmp = dup (null);
+  assert (tmp == 2);
+  lgl = 0;
+  res = 0;
+  for (e = events; e < events + nevents; e++) {
+    if (reme (e)) continue;
+    switch (e->type) {
+      case ADD: lgladd (lgl, e->arg); break;
+      case ASSUME: lglassume (lgl, e->arg); break;
+      case CHKCLONE: lglchkclone (lgl); break;
+      case DEREF: res = lglderef (lgl, e->arg); break; 
+      case FIXED: res = lglfixed (lgl, e->arg); break;
+      case FROZEN: res = lglfrozen (lgl, e->arg); break;
+      case REUSABLE: res = lglreusable (lgl, e->arg); break;
+      case USABLE: res = lglusable (lgl, e->arg); break;
+      case REPR: res = lglrepr (lgl, e->arg); break;
+      case FAILED: res = lglfailed (lgl, e->arg); break;
+      case FIXATE: lglfixate (lgl); break;
+      case REDUCE: lglreducecache (lgl); break;
+      case FLUSH: lglflushcache (lgl); break;
+      case SETIMPORTANT: lglsetimportant (lgl, e->arg); break;
+      case SETPHASES: lglsetphases (lgl); break;
+      case SETPHASE: lglsetphase (lgl, e->arg); break;
+      case RESETPHASE: lglresetphase (lgl, e->arg); break;
+      case FREEZE: lglfreeze (lgl, e->arg); break;
+      case INCONSISTENT: res = lglinconsistent (lgl); break;
+      case LKHD: res = lglookahead (lgl); break;
+      case INCVAR: res = lglincvar (lgl); break;
+      case MAXVAR: res = lglincvar (lgl); break;
+      case CHANGED: res = lglchanged (lgl); break;
+      case INIT: 
+        lgl = lglinit ();
+	lglonabort (lgl, 0, onabort); 
+	if (opts) {
+	  assert (ddopts);
+	  for (o = opts; o < opts + nopts; o++)
+	    lglsetopt (lgl, o->name, o->val);
+	}
+	break;
+      case MELT: lglmelt (lgl, e->arg); break;
+      case REUSE: lglreuse (lgl, e->arg); break;
+      case OPTION: if (!opts) lglsetopt (lgl, e->opt, e->arg); break;
+      case SIMP: res = lglsimp (lgl, e->arg); break;
+      case RELEASE: lglrelease (lgl); break;
+      case RETURN: 
+	if (checkreturn) assert (e->arg == res);
+        break;
+      case SAT: default:
+	assert (e->type == SAT);
+	res = lglsat (lgl);
+	break;
+    }
+  }
+  close (null);
+  close (2);// TODO necessary?
+  close (1);// TODO necessary?
+  tmp = dup (saved1);
+  assert (tmp == 1);
+  tmp = dup (saved2);
+  assert (tmp == 2);
+}
+
+static int run (void) {
+  int status = 0, id, tmp;
+  // TODO cache
+  if ((id = fork ())) {
+    if (id < 0) die ("can not generate child process");
+    tmp = wait (&status);
+    if (tmp != id) die ("'wait' did not return child process");
+  } else { process (); exit (0); }
+  runs++;
+  return status;
+}
+
+static int lit (int lit) {
+  int idx, res;
+  if (!lit) return 0;
+  idx = abs (lit);
+  assert (0 < idx && idx <= nmap);
+  res = map [idx];
+  if (lit < 0) res = -res;
+  return res;
+}
+
+static void print (Event * e, FILE * file) {
+  Opt * o;
+  switch (e->type) {
+    case ADD: fprintf (file, "add %d\n", lit (e->arg)); break;
+    case ASSUME: fprintf (file, "assume %d\n", lit (e->arg)); break;
+    case CHANGED: fprintf (file, "changed\n"); break;
+    case CHKCLONE: fprintf (file, "chkclone\n"); break;
+    case DEREF: fprintf (file, "deref %d\n", lit (e->arg)); break;
+    case FAILED: fprintf (file, "failed %d\n", lit (e->arg)); break;
+    case FIXED: fprintf (file, "fixed %d\n", lit (e->arg)); break;
+    case FROZEN: fprintf (file, "frozen %d\n", lit (e->arg)); break;
+    case REUSABLE: fprintf (file, "reusable %d\n", lit (e->arg)); break;
+    case USABLE: fprintf (file, "usable %d\n", lit (e->arg)); break;
+    case REPR: fprintf (file, "repr %d\n", lit (e->arg)); break;
+    case FIXATE: fprintf (file, "fixate\n"); break;
+    case REDUCE: fprintf (file, "reduce\n"); break;
+    case FLUSH: fprintf (file, "flush\n"); break;
+    case SETIMPORTANT: fprintf (file, "setimportant %d\n", lit (e->arg)); break;
+    case SETPHASES: fprintf (file, "setphases\n"); break;
+    case SETPHASE: fprintf (file, "setphase %d\n", lit (e->arg)); break;
+    case RESETPHASE: fprintf (file, "resetphase %d\n", lit (e->arg)); break;
+    case FREEZE: fprintf (file, "freeze %d\n", lit (e->arg)); break;
+    case INCONSISTENT: fprintf (file, "inconsistent\n"); break;
+    case LKHD: fprintf (file, "lkhd\n"); break;
+    case INCVAR: fprintf (file, "incvar\n"); break;
+    case INIT: 
+      fprintf (file, "init\n");
+      if (opts) {
+	assert (ddopts);
+	for (o = opts; o < opts + nopts; o++)
+	  fprintf (file, "option %s %d\n", o->name, o->val);
+      }
+      break;
+    case MAXVAR: fprintf (file, "maxvar\n"); break;
+    case MELT: fprintf (file, "melt %d\n", lit (e->arg)); break;
+    case REUSE: fprintf (file, "reuse %d\n", lit (e->arg)); break;
+    case OPTION: fprintf (file, "option %s %d\n", e->opt, e->arg); break;
+    case PHASE: fprintf (file, "phase %d\n", lit (e->arg)); break;
+    case RELEASE: fprintf (file, "release\n"); break;
+    case RETURN: fprintf (file, "return %d\n", e->arg); break;
+    case SIMP: fprintf (file, "simp %d\n", e->arg); break;
+    case SAT: default:
+      assert (e->type == SAT);
+      fprintf (file, "sat\n");
+      break;
+  }
+}
+
+static const char * type2str (Type type) {
+  switch (type) {
+    case ADD: return "add";
+    case ASSUME: return "assume";
+    case CHANGED: return "changed";
+    case CHKCLONE: return "chkclone";
+    case DEREF: return "deref";
+    case FAILED: return "failed";
+    case FIXED: return "fixed";
+    case FROZEN: return "frozen";
+    case REUSABLE: return "reusable";
+    case USABLE: return "usable";
+    case REPR: return "repr";
+    case FIXATE: return "fixate";
+    case REDUCE: return "reduce";
+    case FLUSH: return "flush";
+    case FREEZE: return "freeze";
+    case SETIMPORTANT: return "setimportant";
+    case SETPHASES: return "setphases";
+    case SETPHASE: return "setphase";
+    case RESETPHASE: return "resetphase";
+    case INCVAR: return "incvar";
+    case INCONSISTENT: return "inconsistent";
+    case LKHD: return "lkhd";
+    case INIT: return "init";
+    case MAXVAR: return "maxvar";
+    case MELT: return "melt";
+    case REUSE: return "REUSE";
+    case OPTION: return "option";
+    case PHASE: return "phase";
+    case RELEASE: return "release";
+    case RETURN: return "return";
+    case SIMP: return "simp";
+    case SAT: default:
+      assert (type == SAT);
+      return "sat";
+      break;
+  }
+}
+
+static void noarg (Type op) {
+  if (strtok (0, " ")) 
+    perr ("argument after '%s'", type2str (op));
+  event (op, 0, 0);
+}
+
+static void newline (void) {
+  int i;
+  if (!verbose) return;
+  if (!isatty (1)) return;
+  printf ("\r");
+  for (i = 0; i < 78; i++) fputc (' ', stdout);
+  printf ("\r");
+  fflush (stdout);
+}
+
+static void prt (int final) {
+  int close = 0, i, len;
+  FILE * file; 
+  char * cmd;
+  unlink (oname);
+  len = strlen (oname);
+  if (len >= 3 && !strcmp (oname + len - 3, ".gz")) {
+    cmd = malloc (len + 20);
+    sprintf (cmd, "gzip -c > %s", oname);
+    file = popen (cmd, "w");
+    if (file) close = 2;
+    free (cmd);
+  } else {
+    file = fopen (oname, "w");
+    if (file) close = 1;
+  }
+  if (!file) die ("can not write to '%s'", oname);
+  prevents = 0;
+  for (i = 0; i < nevents; i++) {
+    if (reme (events + i)) continue;
+    print (events + i, file);
+    prevents++;
+  }
+  if (close == 2) pclose (file);
+  if (close == 1) fclose (file);
+  if (verbose && isatty (1)) {
+    fputc ('\r', stdout);
+    for (i = 0; i < 78; i++) fputc (' ', stdout);
+    fputc ('\r', stdout);
+  }
+  msg ("written %s with %d events", oname, prevents);
+}
+
+static void dd (void) {
+  int from, to, rgran, nranges, i, width, j, res, found, pos, changed;
+  Range * ranges = calloc (nevents, sizeof *ranges), * r;
+  int * smap, idx, moved, mapto, nused;
+  Type cluster;
+  char * used;
+  Event * e;
+RESTART:
+  prt (0);
+  changed = 0;
+  nused = 0;
+  used = malloc (nmap + 1);
+  memset (used, 0, nmap + 1);
+  for (e = events; e < events + nevents; e++) {
+    if (reme (e)) continue;
+    idx = 0;
+    switch (e->type) {
+      case ADD: 
+      case ASSUME: 
+      case DEREF:
+      case FAILED:
+      case FIXED:
+      case FROZEN:
+      case REUSABLE:
+      case USABLE:
+      case REPR:
+      case SETIMPORTANT:
+      case SETPHASE:
+      case RESETPHASE:
+      case FREEZE:
+      case MELT:
+      case REUSE:
+      case PHASE:
+	idx = e->arg;
+	break;
+      case INIT:
+      case OPTION:
+      case RELEASE:
+      case RETURN: 
+      case SAT:
+      case SIMP:
+      case CHANGED:
+      case MAXVAR:
+      case INCVAR:
+      case INCONSISTENT:
+      case LKHD:
+      case FIXATE:
+      case FLUSH:
+      case REDUCE:
+      case CHKCLONE:
+      case SETPHASES:
+        break;
+    }
+    if (!idx) continue;
+    idx = abs (idx);
+    if (used [idx]) continue;
+    used[idx] = 1;
+    nused++;
+  }
+  if (nused < nmap) {
+    smap = map;
+    moved = 0;
+    mapto = 1;
+    map = malloc (szmap * sizeof *map);
+    for (idx = 1; idx <= nmap; idx++) {
+      if (used[idx]) {
+	if (smap[idx] != mapto) {
+	  assert (mapto < smap[idx]);
+	  moved++;
+	}
+	map[idx] = mapto++;
+      } else map[idx] = 0;
+    }
+    if (!moved) goto DONOTMOVE;
+    res = run ();
+    if (res == golden) { 
+      if (verbose > 1) {
+	newline ();
+	msg ("moved %d variables", moved);
+      }
+      free (smap);
+      changed = 1;
+    } else {
+DONOTMOVE:
+      free (map);
+      map = smap;
+    }
+  }
+  free (used);
+  for (rgran = 2; rgran >= 0; rgran--) {
+    from = to = 0;
+    r = ranges;
+    for (;;) {
+      while (from < nevents && reme (events + from))
+	from++;
+      if (from == nevents) break;
+      to = from;
+      if (rgran == 2) {
+	cluster = events[from].type;
+	while (to + 1 < nevents) {
+	  e = events + to + 1;
+	  if (e->type != cluster) {
+	    if (cluster == DEREF && e->type == RETURN) ;
+	    else if (cluster == SAT && e->type == RETURN) { to++; break; }
+	    else break;
+	  } else if (cluster == INIT ||
+	             cluster == SAT ||
+		     cluster == RELEASE) break;
+	  to++;
+	}
+      } else if (rgran == 1) {
+	if (to + 1 < nevents && events[to].type == ADD) {
+	  while (to + 1 < nevents &&
+		 (reme (e = events + to) || (e->type == ADD && e->arg)))
+	    to++;
+	}
+      } else  {
+	if (to + 1 < nevents) {
+	  while (to + 1 < nevents && reme (events + to))
+	    to++;
+	}
+      }
+      assert (r < ranges + nevents);
+      r->from = from;
+      r->to = to;
+      r->removed = INT_MAX;
+      if (verbose > 1) msg ("range %d [%d,%d]", r - ranges, from, to);
+      if (verbose > 2) {
+	for (i = from; i <= to; i++) {
+	  e = events + i;
+	  if (reme (e) && verbose < 4) continue;
+	  if (e->type == OPTION)
+	    msg ("range %d [%d] %s %s %d%s", 
+	         r - ranges, i, type2str (e->type), e->opt, e->arg,
+		 reme (e) ? " (removed)" : "");
+	  else
+	    msg ("range %d [%d] %s %d%s", 
+		 r - ranges, i, type2str (e->type), e->arg,
+		 reme (e) ? " (removed)" : "");
+	}
+      }
+      r++;
+      from = to + 1;
+      if (from == nevents) break;
+    }
+    nranges = r - ranges;
+    if (verbose > 1)
+      msg ("found %d ranges of range granularity %d", nranges, rgran);
+    width = nranges / 2;
+    while (width > 0) {
+      pos = 0;
+      do {
+	rep ("g%d w%d : %6d .. %-6d / %d %lld",
+	     rgran, width, pos, 
+	     (pos + width <= nranges) ? pos + width - 1 : nranges - 1,
+	     nranges,
+	     sumoptvals);
+	found = 0;
+	for (i = pos; i < nranges && i < pos + width; i++) {
+	  r = ranges + i;
+	  if (remr (r)) continue;
+	  r->removed = runs;
+	  found = 0;
+	  for (j = r->from; j <= r->to; j++) {
+	    e = events + j;
+	    if (reme (e)) continue;
+	    found++;
+	    e->removed = runs;
+	  }
+	  assert (found);
+	}
+	res = run ();
+	if (res == golden) { 
+	  if (verbose > 1) {
+	    newline ();
+	    msg ("removed %d events", found);
+	  }
+	  changed = 1;
+	} else {
+	  for (i = pos; i < nranges && i < pos + width; i++) {
+	    r = ranges + i;
+	    if (r->removed < runs - 1) continue;
+	    assert (r->removed == runs - 1);
+	    r->removed = INT_MAX;
+	    for (j = r->from; j <= r->to; j++) {
+	      e = events + j;
+	      assert (e->removed < runs);
+	      if (e->removed == runs - 1) e->removed = INT_MAX;
+	    }
+	  }
+	}
+	pos += width;
+      } while (pos < nranges);
+      width = (width > 4) ? width/2 : width - 1;
+    }
+    if (verbose > 1) newline ();
+  }
+  if (ddopts) {
+    int reported = 0;
+    Opt * o;
+    if (!opts) {
+      void * it;
+      const char * name;
+      Opt opt;
+      LGL * lgl = lglinit ();
+      it = lglfirstopt (lgl); 
+      while ((it = lglnextopt (lgl, it, 
+	                       &name, &opt.val, &opt.min, &opt.max))) {
+	if (!strcmp (name, "log")) continue;
+	if (!strcmp (name, "check")) continue;
+	if (!strcmp (name, "verbose")) continue;
+	if (!strcmp (name, "witness")) continue;
+	if (!strcmp (name, "exitonabort")) continue;
+	if (!strcmp (name, "sleeponabort")) continue;
+	if (nopts == szopts) {
+	  szopts = szopts ? 2*szopts : 1;
+	  opts = realloc (opts, szopts * sizeof *opts);
+	}
+	opt.name = strdup (name);
+	opts[nopts++] = opt;
+      }
+      for (e = events; e < events + nevents; e++) {
+	if (e->type != OPTION) continue;
+	for (o = opts; o < opts + nopts; o++)
+	  if (!strcmp (e->opt, o->name)) {
+	    o->val = e->arg;
+	    sumoptvals += o->val - (long long) o->min;
+	  }
+      }
+      lglrelease (lgl);
+    }
+    for (o = opts; o < opts + nopts; o++) {
+      long long delta = o->val - (long long) o->min;
+      rep ("o %d / %d %lld                            ",
+           o - opts, nopts, sumoptvals);
+      reported++;
+      if (o->val > o->min) {
+	int oldval = o->val;
+	o->val = o->min;
+	res = run ();
+	if (res == golden) {
+	  if (verbose > 1) {
+	    if (reported) newline ();
+	    msg ("reduced option %s from %d to %d by one", 
+		 o->name, oldval, o->val);
+	    reported = 0;
+	  }
+	  changed = 1;
+	  sumoptvals--;
+	} else o->val = oldval;
+      }
+      if (delta < 10) {
+	while (o->val > o->min) {
+	  int oldval = o->val, newval = oldval - 1;
+	  assert (newval >= o->min);
+	  o->val = newval;
+	  res = run ();
+	  if (res != golden) { o->val = oldval; break; }
+	  if (verbose > 1) {
+	    if (reported) newline ();
+	    msg ("reduced option %s from %d to %d by one", 
+		 o->name, oldval, newval);
+	    reported = 0;
+	  }
+	  changed = 1;
+	  assert (oldval - newval == 1);
+	  sumoptvals--;
+	  //assert (sumoptvals >= 0);
+	}
+      } else {
+	int upper = o->val;
+	int lower = o->min;
+	assert (lower <= upper);
+	while (upper > lower) {
+	  int oldval = o->val;
+	  long longnewval = lower + ((long)upper - (long)lower)/2;
+	  int newval = (int) longnewval;
+	  o->val = newval;
+	  res = run ();
+	  if (res == golden) {
+	    if (verbose > 1) {
+	      if (reported) newline ();
+	      msg ("reduced %s from %d to %d", o->name, oldval, newval);
+	      reported = 0;
+	    }
+	    changed = 1;
+	    assert (newval < upper);
+	    upper = newval;
+	    sumoptvals -= oldval - newval;
+	    // assert (sumoptvals >= 0);
+	  } else {
+	    o->val = oldval;
+	    if (lower == newval) break;
+	    assert (lower < newval);
+	    lower = newval;
+	  }
+	}
+	assert (lower <= upper);
+      }
+      if (verbose > 1) {
+	if (reported) newline ();
+	msg ("final option %s set to %d", o->name, o->val);
+	reported = 0;
+      }
+    }
+    if (reported && verbose > 1) newline ();
+  }
+  if (changed) goto RESTART;
+  if (verbose) newline ();
+  free (ranges);
+}
+
+static double getime (void) {
+  double res = 0;
+  struct timeval tv;
+  if (!gettimeofday (&tv, 0)) res = 1e-6 * tv.tv_usec, res += tv.tv_sec;
+  return res;
+}
+
+int main (int argc, char ** argv) {
+  int i, len, ch, close = 0, count;
+  char buffer[80], * tok, * opt;
+  double start, delta;
+  FILE * file;
+  start = getime ();
+  char * cmd;
+  for (i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h")) {
+      printf (
+        "usage: lglddtrace [-h][-v][-s][-d][-f][-O] <in>[.gz] <out>[.gz]\n");
+      exit (0);
+    } else if (!strcmp (argv[i], "-v")) verbose++;
+    else if (!strcmp (argv[i], "-c")) checkreturn++;
+    else if (!strcmp (argv[i], "-O")) ddopts++;
+    else if (argv[i][0] == '-')
+      die ("invalid command line option '%s' (try '-h')", argv[i]);
+    else if (oname) die ("two many options pecified (try '-h')");
+    else if (iname) oname = argv[i];
+    else iname = argv[i];
+  }
+  if (!iname) die ("input file missing");
+  if (!oname) die ("output file missing");
+  len = strlen (iname);
+  if (len >= 3 && !strcmp (iname + len - 3, ".gz")) {
+    cmd = malloc (len + 20);
+    sprintf (cmd, "gunzip -c %s", iname);
+    file = popen (cmd, "r");
+    free (cmd);
+    if (file) close = 2;
+  } else {
+    file = fopen (iname, "r");
+    if (file) close = 1;
+  }
+  if (!file) die ("can not read '%s'", iname);
+  msg ("reading %s", iname);
+  buffer[len = 0] = 0;
+  lineno = 1;
+  count = 0;
+NEXT:
+  ch = getc (file);
+  if (ch == EOF) goto DONE;
+  if (ch == '\r') goto NEXT;
+  if (ch != '\n') {
+    if (len + 1 >= sizeof (buffer)) perr ("line buffer exceeded");
+    buffer[len++] = ch;
+    buffer[len] = 0;
+    goto NEXT;
+  }
+  if (verbose > 2) msg ("line %d : %s", lineno, buffer);
+  if (!(tok = strtok (buffer, " "))) perr ("empty line");
+  else if (!strcmp (tok, "add")) event (ADD, intarg ("add"), 0);
+  else if (!strcmp (tok, "return")) event (RETURN, intarg ("return"), 0);
+  else if (!strcmp (tok, "deref")) event (DEREF, intarg ("deref"), 0);
+  else if (!strcmp (tok, "fixed")) event (FIXED, intarg ("fixed"), 0);
+  else if (!strcmp (tok, "frozen")) event (FROZEN, intarg ("frozen"), 0);
+  else if (!strcmp (tok, "reusable")) event (REUSABLE, intarg ("reusable"), 0);
+  else if (!strcmp (tok, "usable")) event (USABLE, intarg ("usable"), 0);
+  else if (!strcmp (tok, "repr")) event (REPR, intarg ("repr"), 0);
+  else if (!strcmp (tok, "failed")) event (FAILED, intarg ("failed"), 0);
+  else if (!strcmp (tok, "assume")) event (ASSUME, intarg ("assume"), 0);
+  else if (!strcmp (tok, "phase")) event (PHASE, intarg ("phase"), 0);
+  else if (!strcmp (tok, "init")) noarg (INIT);
+  else if (!strcmp (tok, "sat")) noarg (SAT);
+  else if (!strcmp (tok, "simp")) event (SIMP, intarg ("simp"), 0);
+  else if (!strcmp (tok, "setphases")) noarg (SETPHASES);
+  else if (!strcmp (tok, "freeze")) event (FREEZE, intarg ("freeze"), 0);
+  else if (!strcmp (tok, "setimportant"))
+    event (SETIMPORTANT, intarg ("setimportant"), 0);
+  else if (!strcmp (tok, "setphase")) event (SETPHASE, intarg ("setphase"), 0);
+  else if (!strcmp (tok, "resetphase"))
+    event (SETPHASE, intarg ("resetphase"), 0);
+  else if (!strcmp (tok, "melt")) event (MELT, intarg ("melt"), 0);
+  else if (!strcmp (tok, "reuse")) event (REUSE, intarg ("reuse"), 0);
+  else if (!strcmp (tok, "option")) {
+    if (!(opt = strtok (0, " "))) perr ("option iname missing");
+    event (OPTION, intarg ("option"), opt);
+  } else if (!strcmp (tok, "release")) noarg (RELEASE);
+  else if (!strcmp (tok, "incvar")) noarg (INCVAR);
+  else if (!strcmp (tok, "maxvar")) noarg (MAXVAR);
+  else if (!strcmp (tok, "inconsistent")) noarg (INCONSISTENT);
+  else if (!strcmp (tok, "lkhd")) noarg (LKHD);
+  else if (!strcmp (tok, "fixate")) noarg (FIXATE);
+  else if (!strcmp (tok, "reduce")) noarg (REDUCE);
+  else if (!strcmp (tok, "flush")) noarg (FLUSH);
+  else if (!strcmp (tok, "chkclone")) noarg (CHKCLONE);
+  else if (!strcmp (tok, "changed")) noarg (CHANGED);
+  else perr ("invalid command '%s'", tok);
+  lineno++;
+  count++;
+  len = 0;
+  goto NEXT;
+DONE:
+  if(close == 1) fclose (file);
+  if(close == 2) pclose (file);
+  msg ("parsed %d events in %s", count, iname);
+  golden = run ();
+  timelimit = 
+  delta = getime () - start;
+  if (delta < 0) delta = 0;
+  msg ("golden exit code %d in %.3f seconds", golden, delta);
+  timelimit = delta;
+  if (timelimit <= 0) timelimit = 1;
+  timelimit *= 100;
+  msg ("time limit %d seconds", timelimit);
+  dd ();
+  prt (1);
+  for (i = 0; i < nevents; i++) free (events[i].opt);
+  free (events);
+  for (i = 0; i < nopts; i++) free (opts[i].name);
+  free (opts);
+  msg ("executed %d runs in %.3f seconds", runs, getime () - start);
+  return 0;
+}
diff --git a/lgldimacs.c b/lgldimacs.c
new file mode 100644
index 0000000..2aaa518
--- /dev/null
+++ b/lgldimacs.c
@@ -0,0 +1,272 @@
+#include "lgldimacs.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <limits.h>
+
+struct LDR {
+  struct { 
+    void * state;
+    ldralloc alloc;
+    ldrdealloc dealloc;
+  } mem;
+  struct { void * state; ldropt fun; } opt;
+  struct { void * state; ldrheader fun; } header;
+  struct { void * state; ldradd fun; } add;
+  char * path;
+  char * errmsg;
+  int closefile;
+  FILE * file;
+  int lineno;
+};
+
+static void * ldrstdalloc (void * mem, size_t bytes) {
+  (void) mem;
+  return malloc (bytes);
+}
+
+static void ldrstdealloc (void * mem, void * ptr, size_t bytes) {
+  (void) mem;
+  (void) bytes;
+  free (ptr);
+}
+
+static void * ldrstdrealloc (void * mem, void * ptr, size_t ob, size_t nb) {
+  (void) mem;
+  (void) ob;
+  return realloc (ptr, nb);
+}
+
+LDR * ldrinit () {
+  return ldrminit (0, ldrstdalloc, ldrstdrealloc, ldrstdealloc);
+}
+
+LDR * ldrminit (void * state, 
+                ldralloc alloc, ldrealloc realloc, ldrdealloc dealloc) {
+  LDR * res = alloc (state, sizeof *res);
+  if (!res) return res;
+  memset (res, 0, sizeof *res);
+  res->mem.state = state;
+  res->mem.alloc = alloc;
+  res->mem.dealloc = dealloc;
+  return res;
+}
+
+static void ldrdelstr (LDR * ldr, char * str) {
+  if (str) ldr->mem.dealloc (ldr->mem.state, str, strlen (str) + 1);
+}
+
+static char * ldrstrdup (LDR * ldr, const char* str) {
+  size_t bytes = strlen (str) + 1;
+  char * res = ldr->mem.alloc (ldr->mem.state, bytes);
+  return strcpy (res, str);
+}
+
+void ldrelease (LDR * ldr) {
+  if (ldr->file) {
+    if (ldr->closefile == 1) fclose (ldr->file);
+    if (ldr->closefile == 2) pclose (ldr->file);
+  }
+  ldrdelstr (ldr, ldr->errmsg);
+  ldrdelstr (ldr, ldr->path);
+  ldr->mem.dealloc (ldr->mem.state, ldr, sizeof *ldr);
+}
+
+void ldrsetopt (LDR * ldr, void * state, ldropt fun) {
+  ldr->opt.fun = fun;
+  ldr->opt.state = state;
+}
+
+void ldrsetheader (LDR * ldr, void * state, ldrheader fun) {
+  ldr->header.fun = fun;
+  ldr->header.state = state;
+}
+
+void ldrsetadd (LDR * ldr, void * state, ldradd fun) {
+  ldr->add.fun = fun;
+  ldr->add.state = state;
+}
+
+static int ldrfilexists (const char * path) {
+  struct stat buf;
+  return !stat (path, &buf);
+}
+
+static int ldrperr (LDR * ldr, const char * msg) {
+  size_t bytes, len;
+  char * str;
+  assert (!ldr->errmsg);
+  assert (ldr->path);
+  bytes = strlen (msg) + strlen (ldr->path) + 20;
+  str = ldr->mem.alloc (ldr->mem.state, bytes);
+  sprintf (str, "%s:%d: %s", ldr->path, ldr->lineno, msg);
+  len = strlen (str) + 1;
+  ldr->errmsg = strcpy (ldr->mem.alloc (ldr->mem.state, len), str);
+  ldr->mem.dealloc (ldr->mem.state, str, bytes);
+  return 0;
+}
+
+static int ldrhas (const char * str, const char * suffix) {
+  int l = strlen (str), k = strlen (suffix);
+  if (l < k) return 0;
+  return !strcmp (str + l - k, suffix);
+}
+
+static FILE * ldrcmd (LDR * ldr, const char * fmt, const char * name) {
+  FILE * res;
+  int len = strlen (fmt) + strlen (name) + 1;
+  char * s = ldr->mem.alloc (ldr->mem.state, len);
+  sprintf (s, fmt, name);
+  res = popen (s, "r");
+  ldr->mem.dealloc (ldr->mem.state, s, len);
+  return res;
+}
+
+void ldrsetpath (LDR * ldr, const char * path) {
+  assert (!ldr->file);
+  assert (!ldr->path);
+  assert (!ldr->closefile);
+  ldr->path = ldrstrdup (ldr, path);
+  if (!ldrfilexists (path))
+    return (void) ldrperr (ldr, "file does not exist");
+  ldr->closefile = 2;
+  if (ldrhas (path, ".gz"))
+    ldr->file = ldrcmd  (ldr, "gunzip -c %s", path);
+  else if (ldrhas (path, ".bz2"))
+    ldr->file = ldrcmd (ldr, "bzcat %s", path);
+  else if (ldrhas (path, ".7z"))
+    ldr->file = ldrcmd (ldr, "7z x -so %s 2>/dev/null", path);
+  else if (ldrhas (path, ".lzma"))
+    ldr->file = ldrcmd (ldr, "lzcat %s", path);
+  else ldr->file = fopen (path, "r"), ldr->closefile = 1;
+  if (!ldr->file) return (void) ldrperr (ldr, "can not open file");
+}
+
+void ldrsetfile (LDR * ldr, FILE * file) {
+  assert (!ldr->file);
+  assert (!ldr->path);
+  assert (!ldr->closefile);
+  ldr->file = file;
+  ldr->path = ldrstrdup (ldr, "<unspecified-path>");
+}
+
+void ldrsetnamedfile (LDR * ldr, FILE * file, const char * path) {
+  assert (!ldr->file);
+  assert (!ldr->path);
+  assert (!ldr->closefile);
+  ldr->file = file;
+  ldr->path = ldrstrdup (ldr, path);
+}
+
+const char * ldrerr (LDR * ldr) { return ldr->errmsg; }
+
+static int ldrnext (LDR * ldr) {
+  int ch;
+  assert (ldr);
+  assert (ldr->file);
+  ch = getc (ldr->file);
+  if (ch == '\n') ldr->lineno++;
+  return ch;
+}
+
+int ldrparse (LDR * ldr) {
+  struct { int parsed, specified; } vars, clauses;
+  int ch, sign, lit, digit;
+  if (ldr->errmsg) return 0;
+  while ((ch = ldrnext (ldr)) == 'c') {
+    // TODO parse embedded options
+    while ((ch = ldrnext (ldr)) != '\n')
+      if (ch == EOF)
+	return ldrperr (ldr, "end-of-file in comment before header");
+  }
+  if (ch != 'p') return ldrperr (ldr, "expected 'p' or 'c'");
+  if (ldrnext (ldr) != ' ') return ldrperr (ldr, "expected space after 'p'");
+  if (ldrnext (ldr) != 'c') return ldrperr (ldr, "expected 'c' after 'p '");
+  if (ldrnext (ldr) != 'n') return ldrperr (ldr, "expected 'n' after 'p c'");
+  if (ldrnext (ldr) != 'f') return ldrperr (ldr, "expected 'f' after 'p cn'");
+  if (ldrnext (ldr) != ' ')
+    return ldrperr (ldr, "expected space after 'p cnf'");
+  ch = ldrnext (ldr);
+  if (!isdigit (ch)) return ldrperr (ldr, "expected digit after 'p cnf '");
+  vars.specified = ch - '0';
+  while (isdigit (ch = ldrnext (ldr))) {
+    if (INT_MAX/10 < vars.specified)
+NUMBER_TOO_LARGE:
+      return ldrperr (ldr, "number too large");
+    vars.specified *= 10;
+    digit = (ch - '0');
+    if (INT_MAX - digit < vars.specified) goto NUMBER_TOO_LARGE;
+    vars.specified += digit;
+  }
+  if (ch != ' ')
+    return ldrperr (ldr, "expected space after maximum variable index");
+  if (!isdigit (ch = ldrnext (ldr)))
+    return ldrperr (ldr, "expected digit after space after variable index");
+  clauses.specified = ch - '0';
+  while (isdigit (ch = ldrnext (ldr))) {
+    if (INT_MAX/10 < clauses.specified) goto NUMBER_TOO_LARGE;
+    clauses.specified *= 10;
+    digit = (ch - '0');
+    if (INT_MAX - digit < clauses.specified) goto NUMBER_TOO_LARGE;
+    clauses.specified += digit;
+  }
+  while (ch == ' ' || ch == '\t' || ch == '\r')
+    ch = ldrnext (ldr);
+  if (ch != '\n') return ldrperr (ldr, "expected new line after header");
+  if (ldr->header.fun)
+    ldr->header.fun (ldr->header.state, vars.specified, clauses.specified);
+  vars.parsed = clauses.parsed = 0;
+  lit = 0;
+  for (;;) {
+    ch = ldrnext (ldr);
+    if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') continue;
+    if (ch == 'c') {
+      while ((ch = ldrnext (ldr)) != '\n') {
+	if (ch == EOF)
+	  return ldrperr (ldr, "end-of-file in comment after header");
+      }
+      continue;
+    }
+    if (ch == EOF) {
+      if (lit) return ldrperr (ldr, "zero sentinel missing at end-of-file");
+      assert (clauses.parsed <= clauses.specified);
+      if (clauses.parsed + 1 == clauses.specified)
+        return ldrperr (ldr, "one clause is missing");
+      if (clauses.parsed < clauses.specified)
+        return ldrperr (ldr, "clauses are missing");
+      break;
+    }
+    if (ch == '-') {
+      ch = ldrnext (ldr);
+      if (!isdigit (ch)) return ldrperr (ldr, "expected digit after '-'");
+      sign = -1;
+    } else if (!isdigit (ch)) return ldrperr (ldr, "expected digit or '-'");
+    else sign = 1;
+    assert (clauses.parsed <= clauses.specified);
+    if (clauses.specified == clauses.parsed)
+      return ldrperr (ldr, "too many clauses");
+    lit = ch - '0';
+    while (isdigit (ch = ldrnext (ldr))) {
+      if (INT_MAX/10 < lit) goto NUMBER_TOO_LARGE;
+      lit *= 10;
+      digit = (ch - '0');
+      if (INT_MAX - digit < lit) goto NUMBER_TOO_LARGE;
+      lit += digit;
+    }
+    assert (0 <= lit);
+    if (lit > vars.specified)
+      return ldrperr (ldr, "maximum variable index exceeded");
+    lit *= sign;
+    assert ((sign < 0) == (lit < 0));
+    if (ldr->add.fun) ldr->add.fun (ldr->add.state, lit);
+    if (lit) continue;
+    clauses.parsed++;
+    assert (clauses.parsed <= clauses.specified);
+  }
+  return 1;
+}
diff --git a/lgldimacs.h b/lgldimacs.h
new file mode 100644
index 0000000..4a131b0
--- /dev/null
+++ b/lgldimacs.h
@@ -0,0 +1,32 @@
+#ifndef LGLDIMACS_h_INCLUDED
+#define LGLDIMACS_h_INCLUDED
+
+#include <stdlib.h>
+#include <stdio.h>
+
+typedef struct LDR LDR;
+
+typedef void * (*ldralloc) (void* state, size_t);
+typedef void * (*ldrealloc) (void* state, void*, size_t, size_t);
+typedef void (*ldrdealloc) (void* state, void*, size_t);
+typedef void (*ldropt)(void *state, const char * opt, int val);
+typedef void (*ldrheader)(void *state, int vars, int clauses);
+typedef void (*ldradd)(void *state, int lit);
+
+LDR * ldrinit ();
+LDR * ldrminit (void *  state, ldralloc, ldrealloc, ldrdealloc);
+void ldrelease (LDR *);
+
+void ldrsetopt (LDR *, void * optmgr, ldropt);
+void ldrsetheader (LDR *, void * header, ldrheader);
+void ldrsetadd (LDR *, void * adder, ldradd);
+
+void ldrsetpath (LDR *, const char * path);
+void ldrsetfile (LDR *, FILE * file);
+void ldrsetnamedfile (LDR *, FILE * file, const char * path);
+
+int ldrparse (LDR *);
+
+const char * ldrerr (LDR *);
+
+#endif
diff --git a/lglib.c b/lglib.c
new file mode 100644
index 0000000..da9d7c1
--- /dev/null
+++ b/lglib.c
@@ -0,0 +1,26717 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include "lglib.h"
+
+/*------------------------------------------------------------------------*/
+
+#include "lglconst.h"
+#include "lglopts.h"
+
+/*-------------------------------------------------------------------------*/
+
+#include <assert.h>
+#include <ctype.h>
+#include <limits.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <stddef.h>
+
+/*-------------------------------------------------------------------------*/
+
+#ifndef NLGLYALSAT
+#include "yals.h"
+#endif
+
+#ifndef NLGLDRUPLIG
+#include "druplig.h"
+#endif
+
+/*------------------------------------------------------------------------*/
+#ifndef NLGLOG
+/*------------------------------------------------------------------------*/
+
+#define MAPLOGLEVEL(LEVEL) (LEVEL)
+
+#define LOG(LEVEL,FMT,ARGS...) \
+do { \
+  if (MAPLOGLEVEL(LEVEL) > lgl->opts->log.val) break; \
+  lglogstart (lgl, MAPLOGLEVEL(LEVEL), FMT, ##ARGS); \
+  lglogend (lgl); \
+} while (0)
+
+#define LOGCLS(LEVEL,CLS,FMT,ARGS...) \
+do { \
+  const int * P; \
+  if (MAPLOGLEVEL(LEVEL) > lgl->opts->log.val) break; \
+  lglogstart (lgl, MAPLOGLEVEL(LEVEL), FMT, ##ARGS); \
+  for (P = (CLS); *P; P++) fprintf (lgl->out, " %d", *P); \
+  lglogend (lgl); \
+} while (0)
+
+#define LOGMCLS(LEVEL,CLS,FMT,ARGS...) \
+do { \
+  const int * P; \
+  if (MAPLOGLEVEL(LEVEL) > lgl->opts->log.val) break; \
+  lglogstart (lgl, MAPLOGLEVEL(LEVEL), FMT, ##ARGS); \
+  for (P = (CLS); *P; P++) fprintf (lgl->out, " %d", lglm2i (lgl, *P)); \
+  lglogend (lgl); \
+} while (0)
+
+#define LOGRESOLVENT(LEVEL,FMT,ARGS...) \
+do { \
+  const int * P; \
+  if (MAPLOGLEVEL(LEVEL) > lgl->opts->log.val) break; \
+  lglogstart (lgl, MAPLOGLEVEL(LEVEL), FMT, ##ARGS); \
+  for (P = lgl->resolvent.start; P < lgl->resolvent.top; P++) \
+    fprintf (lgl->out, " %d", *P); \
+  lglogend (lgl); \
+} while (0)
+
+#define LOGREASON(LEVEL,LIT,REASON0,REASON1,FMT,ARGS...) \
+do { \
+  int TAG, TMP, RED, G; \
+  const int * C, * P; \
+  if (MAPLOGLEVEL(LEVEL) > lgl->opts->log.val) break; \
+  lglogstart (lgl, MAPLOGLEVEL(LEVEL), FMT, ##ARGS); \
+  TMP = ((REASON0) >> RMSHFT); \
+  RED = ((REASON0) & REDCS); \
+  TAG = ((REASON0) & MASKCS); \
+  if (TAG == DECISION) fputs (" decision", lgl->out); \
+  else if (TAG == UNITCS) fprintf (lgl->out, " unit %d", (LIT)); \
+  else if (TAG == BINCS) { \
+    fprintf (lgl->out, \
+       " %s binary clause %d %d", lglred2str (RED), (LIT), TMP); \
+  } else if (TAG == TRNCS) { \
+    fprintf (lgl->out, " %s ternary clause %d %d %d", \
+	    lglred2str (RED), (LIT), TMP, (REASON1)); \
+  } else { \
+    assert (TAG == LRGCS); \
+    C = lglidx2lits (lgl, RED, (REASON1)); \
+    for (P = C; *P; P++) \
+      ; \
+    fprintf (lgl->out, " size %ld", (long)(P - C)); \
+    if (RED) { \
+      G = ((REASON1) & GLUEMASK); \
+      fprintf (lgl->out, " glue %d redundant", G); \
+    } else fputs (" irredundant", lgl->out); \
+    fputs (" clause", lgl->out); \
+    for (P = C; *P; P++) { \
+      fprintf (lgl->out, " %d", *P); \
+    } \
+  } \
+  lglogend (lgl); \
+} while (0)
+
+#define LOGDSCHED(LEVEL,LIT,FMT,ARGS...) \
+  do { \
+    int POS; \
+    if (MAPLOGLEVEL(LEVEL) > lgl->opts->log.val) break; \
+    POS = *lgldpos (lgl, LIT); \
+    lglogstart (lgl, MAPLOGLEVEL(LEVEL), "dsched[%d] = %d ", POS, LIT); \
+    fprintf (lgl->out, FMT, ##ARGS); \
+    fprintf (lgl->out, \
+      " score %s", lglscr2str (lgl, lglqvar (lgl, LIT)->score)); \
+    lglogend (lgl); \
+  } while (0)
+
+#define LOGESCHED(LEVEL,LIT,FMT,ARGS...) \
+do { \
+  int POS; \
+  EVar * EV; \
+  if (MAPLOGLEVEL(LEVEL) > lgl->opts->log.val) break; \
+  POS = *lglepos (lgl, LIT); \
+  EV = lglevar (lgl, LIT); \
+  lglogstart (lgl, MAPLOGLEVEL(LEVEL), "esched[%d] = %d ", POS, LIT); \
+  fprintf (lgl->out, FMT, ##ARGS); \
+  fprintf (lgl->out, " score"); \
+  fprintf (lgl->out, " occ %d %d", EV->occ[0], EV->occ[1]); \
+  lglogend (lgl); \
+} while (0)
+
+#define LOGEQN(LEVEL,EQN,FMT,ARGS...) \
+do { \
+  const int * P, * START; \
+  if (MAPLOGLEVEL(LEVEL) > lgl->opts->log.val) break; \
+  lglogstart (lgl, MAPLOGLEVEL(LEVEL), FMT, ##ARGS); \
+  START = lgl->gauss->xors.start + (EQN); \
+  assert (START < lgl->gauss->xors.top); \
+  for (P = START; *P > 1; P++) fprintf (lgl->out, " %d", *P); \
+  fprintf (lgl->out, " = %d", *P); \
+  lglogend (lgl); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+#else /* end of then start of else part of 'ifndef NLGLOG' */
+/*------------------------------------------------------------------------*/
+
+#define LOG(ARGS...) do { } while (0)
+#define LOGCLS(ARGS...) do { } while (0)
+#define LOGMCLS(ARGS...) do { } while (0)
+#define LOGRESOLVENT(ARGS...) do { } while (0)
+#define LOGREASON(ARGS...) do { } while (0)
+#define LOGDSCHED(ARGS...) do { } while (0)
+#define LOGESCHED(ARGS...) do { } while (0)
+#define LOGEQN(ARGS...) do { } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif /* end of else part of 'ifndef NLGLOG' */
+/*------------------------------------------------------------------------*/
+
+#define ABORTIF(COND,FMT,ARGS...) \
+do { \
+  if (!(COND)) break; \
+  fprintf (stderr, "*** API usage error of '%s' in '%s'", \
+	   __FILE__, __FUNCTION__); \
+  if (lgl && lgl->tid >= 0) fprintf (stderr, " (tid %d)", lgl->tid); \
+  fputs (": ", stderr); \
+  fprintf (stderr, FMT, ##ARGS); \
+  fputc ('\n', stderr); \
+  fflush (stderr); \
+  lglabort (lgl); \
+  exit (1); \
+} while (0)
+
+// Useful for using our 'sleeponabort' and other hooks 'on abort' ...
+
+#ifndef NDEBUG
+#define ASSERT(COND) \
+do { \
+  if ((COND)) break; \
+  fprintf (stderr, \
+    "liblgl.a: %s:%d: %s: Lingeling Assertion `%s' failed.", \
+    __FUNCTION__, __LINE__, __FILE__, # COND); \
+  if (lgl && lgl->tid >= 0) fprintf (stderr, " (tid %d)", lgl->tid); \
+  fputc ('\n', stderr); \
+  fflush (stderr); \
+  lglabort (lgl); \
+  exit (1); \
+} while (0)
+#else
+#define ASSERT(COND) do { } while (0)
+#endif
+
+#define COVER(COND) \
+do { \
+  if (!(COND)) break; \
+  fprintf (stderr, \
+    "liblgl.a: %s:%d: %s: Coverage target `%s' reached.", \
+    __FUNCTION__, __LINE__, __FILE__, # COND); \
+  if (lgl && lgl->tid >= 0) fprintf (stderr, " (tid %d)", lgl->tid); \
+  fputc ('\n', stderr); \
+  fflush (stderr); \
+  abort (); /* TODO: why not 'lglabort'? */ \
+} while (0)
+
+#define REQINIT() \
+do { \
+  ABORTIF (!lgl, "uninitialized manager"); \
+} while (0)
+
+#define REQINITNOTFORKED() \
+do { \
+  REQINIT (); \
+  ABORTIF (lgl->forked, "forked manager"); \
+} while (0)
+
+#define REQUIRE(STATE) \
+do { \
+  REQINIT (); \
+  ABORTIF(!(lgl->state & (STATE)), "!(%s)", #STATE); \
+} while (0)
+
+#define TRANS(STATE) \
+do { \
+  assert (lgl->state != STATE); \
+  LOG (1, "transition to state " #STATE); \
+  lgl->state = STATE; \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+#if !defined(NDEBUG) || !defined(NLGLOG)
+#define RESOLVENT
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#define TRAPI(MSG,ARGS...) \
+do { \
+  if (!lgl->apitrace) break; \
+  lgltrapi (lgl, MSG, ##ARGS); \
+} while (0)
+
+#define LGLCHKACT(ACT) \
+do { assert (NOTALIT <= (ACT) && (ACT) < REMOVED - 1); } while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define NEW(P,N) \
+do { (P) = lglnew (lgl, (N) * sizeof *(P)); } while (0)
+
+#define DEL(P,N) \
+do { lgldel (lgl, (P), (N) * sizeof *(P)); (P) = 0; } while (0)
+
+#define RSZ(P,O,N) \
+do { (P) = lglrsz (lgl, (P), (O)*sizeof*(P), (N)*sizeof*(P)); } while (0)
+
+#define CLN(P,N) \
+do { memset ((P), 0, (N) * sizeof *(P)); } while (0)
+
+#define CLRPTR(P) \
+do { memset ((P), 0, sizeof *(P)); } while (0)
+
+#define CLR(P) \
+do { memset (&(P), 0, sizeof (P)); } while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define SWAP(TYPE,A,B) \
+do { TYPE TMP = (A); (A) = (B); (B) = TMP; } while (0)
+
+#define ISORTLIM 10
+
+#define CMPSWAP(TYPE,CMP,P,Q) \
+do { if (CMP (&(P), &(Q)) > 0) SWAP (TYPE, P, Q); } while(0)
+
+#define QPART(TYPE,CMP,A,L,R) \
+do { \
+  TYPE PIVOT; \
+  int J = (R); \
+  I = (L) - 1; \
+  PIVOT = (A)[J]; \
+  for (;;) { \
+    while (CMP (&(A)[++I], &PIVOT) < 0) \
+      ; \
+    while (CMP (&PIVOT, &(A)[--J]) < 0) \
+      if (J == (L)) break; \
+    if (I >= J) break; \
+    SWAP (TYPE, (A)[I], (A)[J]); \
+  } \
+  SWAP (TYPE, (A)[I], (A)[R]); \
+} while(0)
+
+#define QSORT(TYPE,CMP,A,N) \
+do { \
+  int L = 0, R = (N) - 1, M, LL, RR, I; \
+  assert (lglmtstk (&lgl->sortstk)); \
+  if (R - L <= ISORTLIM) break; \
+  for (;;) { \
+    M = (L + R) / 2; \
+    SWAP (TYPE, (A)[M], (A)[R - 1]); \
+    CMPSWAP (TYPE, CMP, (A)[L], (A)[R - 1]); \
+    CMPSWAP (TYPE, CMP, (A)[L], (A)[R]); \
+    CMPSWAP (TYPE, CMP, (A)[R - 1], (A)[R]); \
+    QPART (TYPE, CMP, (A), L + 1, R - 1); \
+    if (I - L < R - I) { LL = I + 1; RR = R; R = I - 1; } \
+    else { LL = L; RR = I - 1; L = I + 1; } \
+    if (R - L > ISORTLIM) { \
+      assert (RR - LL > ISORTLIM); \
+      lglpushstk (lgl, &lgl->sortstk, LL); \
+      lglpushstk (lgl, &lgl->sortstk, RR); \
+    } else if (RR - LL > ISORTLIM) L = LL, R = RR; \
+    else if (!lglmtstk (&lgl->sortstk)) { \
+      R = lglpopstk (&lgl->sortstk); \
+      L = lglpopstk (&lgl->sortstk); \
+    } else break; \
+  } \
+} while (0)
+
+#define ISORT(TYPE,CMP,A,N) \
+do { \
+  TYPE PIVOT; \
+  int L = 0, R = (N) - 1, I, J; \
+  for (I = R; I > L; I--) \
+    CMPSWAP (TYPE, CMP, (A)[I - 1], (A)[I]); \
+  for (I = L + 2; I <= R; I++) { \
+    J = I; \
+    PIVOT = (A)[I]; \
+    while (CMP (&PIVOT, &(A)[J - 1]) < 0) { \
+      (A)[J] = (A)[J - 1]; \
+      J--; \
+    } \
+    (A)[J] = PIVOT; \
+  } \
+} while (0)
+
+#ifdef NDEBUG
+#define CHKSORT(CMP,A,N) do { } while(0)
+#else
+#define CHKSORT(CMP,A,N) \
+do { \
+  int I; \
+  for (I = 0; I < (N) - 1; I++) \
+    assert (CMP (&(A)[I], &(A)[I + 1]) <= 0); \
+} while(0)
+#endif
+
+#define SORT(TYPE,A,N,CMP) \
+do { \
+  TYPE * AA = (A); \
+  const int NN = (N); \
+  QSORT (TYPE, CMP, AA, NN); \
+  ISORT (TYPE, CMP, AA, NN); \
+  CHKSORT (CMP, AA, NN); \
+} while (0)
+
+#define SORTSTK(TYPE,S,CMP) \
+do { \
+  TYPE * A = (S)->start; \
+  const int N = lglcntstk (S); \
+  SORT (TYPE, A, N, CMP); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define LGLPOPWTK(WTK,WRAG,LIT,OTHER,RED,REMOVED) \
+do { \
+  assert (!lglmtwtk (WTK)); \
+  (WTK)->top--; \
+  (WRAG) = (WTK)->top->wrag; \
+  (LIT) = (WTK)->top->lit; \
+  (OTHER) = (WTK)->top->other; \
+  (RED) = (WTK)->top->red ? REDCS : 0; \
+  (REMOVED) = (WTK)->top->removed; \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define CLONE(FIELD,SIZE) \
+do { \
+  NEW (lgl->FIELD, (SIZE)); \
+  memcpy (lgl->FIELD, orig->FIELD, (SIZE) * sizeof *(lgl->FIELD)); \
+} while (0)
+
+#define CLONESTK(NAME) \
+do { \
+  size_t COUNT = orig->NAME.top - orig->NAME.start; \
+  size_t SIZE = orig->NAME.end - orig->NAME.start; \
+  size_t BYTES = SIZE * sizeof *lgl->NAME.start; \
+  NEW (lgl->NAME.start, SIZE); \
+  memcpy (lgl->NAME.start, orig->NAME.start, BYTES); \
+  lgl->NAME.top = lgl->NAME.start + COUNT; \
+  lgl->NAME.end = lgl->NAME.start + SIZE; \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define INCSTEPS(NAME) \
+ ((lgl->stats->steps++), (lgl->stats->NAME++))
+
+#define ADDSTEPS(NAME,INC) \
+ (assert ((INC) >= 0), \
+  (lgl->stats->steps += (INC)), (lgl->stats->NAME += (INC)))
+
+/*------------------------------------------------------------------------*/
+
+#define LGLUPDPEN(NAME,SUCCESS) \
+do { \
+  assert (!lgl->limits->NAME.del.rem); \
+  if ((SUCCESS) && lgl->limits->NAME.pen) \
+    lgl->limits->NAME.pen--; \
+  if (!(SUCCESS) && lgl->limits->NAME.pen < lgl->opts->penmax.val) \
+    lgl->limits->NAME.pen++; \
+  if ((SUCCESS) && lgl->limits->NAME.del.cur) \
+    lgl->limits->NAME.del.cur /= 2; \
+  if (!(SUCCESS) && lgl->limits->NAME.del.cur < lgl->opts->delmax.val) \
+    lgl->limits->NAME.del.cur++; \
+  lgl->limits->NAME.del.rem = lgl->limits->NAME.del.cur; \
+} while (0)
+
+/*-------------------------------------------------------------------------*/
+
+#define RMSHFTLIT(LIT)		((int)(((unsigned)LIT)<<RMSHFT))
+
+/*-------------------------------------------------------------------------*/
+
+#define LGLL long long
+
+/*-------------------------------------------------------------------------*/
+
+typedef enum Tag {
+  FREEVAR = 0,
+  FIXEDVAR = 1,
+  EQUIVAR = 2,
+  ELIMVAR = 3,
+
+  DECISION = 0,
+  UNITCS = 1,
+  OCCS = 1,
+  BINCS = 2,
+  TRNCS = 3,
+  LRGCS = 4,
+  MASKCS = 7,
+
+  REDCS = 8,
+  RMSHFT = 4,
+} Tag;
+
+typedef enum State {
+  UNUSED 	= (1<<0),
+  OPTSET 	= (1<<1),
+  USED 		= (1<<2),
+  READY		= (1<<3),
+  UNKNOWN	= (1<<4),
+  SATISFIED	= (1<<5),
+  EXTENDED      = (1<<6),
+  UNSATISFIED	= (1<<7),
+  FAILED        = (1<<8),
+  LOOKED        = (1<<9),
+  RESET		= (1<<10),
+} State;
+
+typedef enum Wrag {
+  PREFIX = 0,
+  BEFORE = 1,
+  AFTER = 2,
+  POSTFIX = 3,
+} Wrag;
+
+typedef enum GTag { ANDTAG, ITETAG, XORTAG } GTag;
+
+/*------------------------------------------------------------------------*/
+
+typedef int Exp;
+typedef uint64_t Mnt;
+typedef int64_t Flt;
+typedef int64_t Cnf;
+typedef uint64_t Fun[FUNQUADS];
+typedef signed char Val;
+typedef Flt LKHD;
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Conf { int lit, rsn[2]; } Conf;
+typedef struct Ctk { struct Ctr * start, * top, * end; } Ctk;
+typedef struct Buf { char * start; size_t size, count; } Buf;
+typedef struct DFOPF { int observed, pushed, flag; } DFOPF;
+typedef struct DFPR { int discovered, finished, parent, root; } DFPR;
+typedef struct EVar { int occ[2], pos, score; } EVar;
+typedef struct Ftk { Flt * start, * top, * end; } Ftk;
+typedef struct HTS { unsigned offset; int count; }  HTS;
+typedef struct Lim { int64_t confs, decs, props; } Lim;
+typedef struct PAGSL { int psm, act, glue, size, lidx; } PAGSL;
+typedef struct PSz { int pos, size; } PSz;
+typedef struct RNG { unsigned z, w; } RNG;
+typedef struct Stk { int * start, * top, * end; } Stk;
+typedef struct Timer { double start; int idx, ign; } Timer;
+typedef struct Timers { Timer stk[MAXPHN]; int nest; } Timers;
+typedef struct Trv { void * state; void (*trav)(void *, int); } Trv;
+typedef struct TVar { signed int val : 30; unsigned mark : 2; } TVar;
+typedef struct Wtk { struct Work * start, * top, * end; } Wtk;
+
+/*------------------------------------------------------------------------*/
+
+typedef struct EMA {
+  int shift, count;
+  int64_t val;
+} EMA;
+
+typedef struct AVG {
+  int64_t val, count;
+} AVG;
+
+#ifndef NLGLDEMA
+
+typedef struct DEMA {
+  EMA ema[2];
+  int64_t val;
+} DEMA;
+
+#define MACDEMA DEMA
+#define lglinitmacdema lglinitdema
+#define lglupdatemacdema lglupdatedema
+
+#else
+
+#define MACDEMA EMA
+#define lglinitmacdema lglinitema
+#define lglupdatemacdema(A,B,C) lglupdatema(A,B,C,1)
+
+#endif
+
+typedef struct MACD {
+  MACDEMA fast, slow;
+  struct { int64_t actual; EMA smoothed; } diff;
+} MACD;
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Ctr { 
+  signed int decision : 28; 
+  unsigned used : 2;
+  unsigned used2 : 2;
+} Ctr;
+
+typedef struct DVar { HTS hts[2]; } DVar;
+
+#define GLAGBITS 30
+#define MAXGLAG ((1<<(GLAGBITS-1)) - 1)
+
+typedef struct QVar {
+  Flt score;
+  unsigned enqueued:1;
+  unsigned important:1;
+  signed int glag:GLAGBITS;
+  int pos;
+} QVar;
+
+typedef struct TD {
+  signed int level:30;
+  unsigned lrglue:1, irr:1; 
+  int rsn[2];
+} TD;
+
+typedef struct AVar {
+  unsigned type : 4;
+#ifndef NDEBUG
+  unsigned simp:1, wasfalse:1;
+#endif
+  unsigned equiv:1, lcamark:4;
+  signed int phase:2, bias:2, fase:2;
+  unsigned inred:2, poisoned:1, assumed:2, failed:2;
+  unsigned donotelm:1, donotblk:1, donoternres:1;
+  unsigned donotbasicprobe:1, donotsimpleprobe:1, donotreelook:1, donotsweep:1;
+#ifndef NLGLYALSAT
+  signed int locsval:2;
+#endif
+  int mark, trail;
+} AVar;
+
+typedef struct Ext {
+  unsigned equiv:1,melted:1,blocking:2,eliminated:1,tmpfrozen:1,imported:1;
+  unsigned assumed:2,failed:2,aliased:1,important:1;
+  signed int val:2, oldval:2;
+  int repr, frozen;
+} Ext;
+
+typedef struct Work {
+  unsigned wrag : 2;
+  signed int lit : 30, other : 30;
+  unsigned red : 1, removed : 1;
+} Work;
+
+typedef struct DFL {
+  int discovered, finished;
+  union { int lit, sign; };
+#ifndef NLGLOG
+  int lit4logging;
+#endif
+} DFL;
+
+/*------------------------------------------------------------------------*/
+
+#define FEATURES \
+FEATURE(n) \
+FEATURE(s) \
+FEATURE(vo) \
+FEATURE(vc) \
+FEATURE(co) \
+FEATURE(cc) \
+FEATURE(b) \
+FEATURE(t) \
+FEATURE(q) \
+FEATURE(c1) \
+FEATURE(c2) \
+FEATURE(c3) \
+FEATURE(c4) \
+FEATURE(x) \
+FEATURE(a1) \
+FEATURE(a2) \
+FEATURE(g) \
+FEATURE(j) \
+FEATURE(c) \
+FEATURE(o)
+
+typedef struct Features {
+#define FEATURE(NAME) int NAME;
+FEATURES
+} Features;
+
+#define NFEATURES (sizeof (Features) / sizeof (int))
+
+#undef FEATURE
+#define FEATURE(NAME) #NAME,
+
+static const char * featurenames[] = {
+  FEATURES
+};
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Stats {
+  int64_t agility;
+  int64_t steps, trims, bins, trns, times;
+  int defrags, reported, features, repcntdown, gcs, decomps;
+  struct { int clauses, vars; } rescored;
+  struct { int64_t count, checked, skipped, forced;
+	   int64_t agile, delayed, blocked, notforced, reused;
+	   struct { int64_t count, pen, delta; } delta;
+	   struct { int64_t count, sum; } kept; } restarts;
+  struct { int count, arith, memlim, reset;
+           int64_t collected, retired; } reduced;
+  struct {
+    int64_t decs, pure, calls, sat, uns, lim, levels;
+    struct { int64_t confs, decs, props; } child;
+  } prune;
+  int64_t prgss, irrprgss, enlwchs, pshwchs, dense, sparse;
+  int64_t confs, decisions, hdecs, qdecs, randecs, randphases;
+  int64_t uips, decflipped;
+  MACD glue, jlevel;
+  EMA tlevel;
+  AVG avglue;
+  struct { MACD avg; int count; } its;
+  struct {
+    struct { int cur, max; int64_t add; } clauses, lits;
+    int64_t maxbytes;
+  } irr;
+  struct { int64_t sat, mosat, simp, deref, fixed, freeze, lkhd;
+	   int64_t melt, add, assume, cassume, failed, repr; } calls;
+  struct { int64_t search, simp, lkhd; } props, visits;
+  struct { size_t current, max; } bytes;
+  struct { int bin, trn, lrg; } red;
+  struct { int cnt, simple, trn, lrg, sub; } hbr;
+  struct { int current, sum; } fixed, equiv;
+  struct { int count, bin, trn; int64_t steps; } ternres;
+  struct { int count, clauses, lits, pure; int64_t res, steps; } blk;
+  struct {
+    struct { int count, failed, eqs; int64_t probed, steps; } simple;
+    struct { int count, failed, lifted; 
+             int64_t probed, steps, lastate;
+	     struct { int trnr, lrg, count; } ate; } basic;
+    struct { int count, failed, lifted; int64_t probed, steps; } treelook;
+  } prb;
+  struct { int count, red, failed; int64_t lits, bins, steps; } trd;
+  struct { int removed, red; } bindup;
+  struct { int count, rounds;
+	   struct { int trds, failed, sccs; int64_t sumsccsizes; } stamp;
+	   struct { int lits, bin, trn, lrg; } failed;
+	   struct { int bin, trn, lrg, red; } tauts;
+	   struct { int bin, trn, lrg; } units;
+	   struct { int trn, lrg, red; } hbrs, str;
+	   int64_t steps; } unhd;
+  struct {
+    int count, elmd, pure, large, sub, str, blkd, rounds;
+    struct { int elm, tried, failed; } small;
+    int64_t resolutions, copies, subchks, strchks, ipos, steps; } elm;
+  struct {
+    int sub2, sub3, subl, str2, str3, str3self, strl, strlself;
+    struct { int64_t lits, clauses, occs; } tried;
+    int64_t steps;
+  } bkwd;
+  struct {
+    struct { int64_t irr, red, bin, trn, lrg; } sub, str;
+    int64_t driving, restarting, total; } otfs;
+  struct { int64_t nonmin, learned; } lits;
+  struct { 
+    int64_t learned, glue, realglue, nonmaxglue, scglue;
+    struct { int64_t count, kept; } maxglue;
+  } clauses;
+  struct {
+    int clauses;
+    int64_t added, reduced, retired, resolved, forcing, conflicts;
+    int64_t maxbytes;
+  } lir[POW2GLUE];
+  struct { int count; int64_t set, pos, neg; } phase;
+  struct {
+    int count;
+    struct { int confs, irr, vars, its, bin, trn; } limhit;
+  } simp;
+  struct { int count, gcs, units, equivs, trneqs; 
+           struct {
+	      struct { int total, last; } max;
+	      struct { int64_t total, exactly1; } sum; } arity; 
+	   struct { int64_t extr, elim; } steps;
+	   struct { int64_t total, exactly1, last; } extracted; } gauss;
+  struct { int count, eliminated, ate, abce, failed, lifted;
+           int64_t steps, probed;
+	   struct { int64_t search, hits, cols, ins, rsz; } cache; } cce;
+  struct { 
+    int count, units, expam1, resched;
+    int64_t steps, eliminated, resolved, subsumed;
+    struct {
+      struct {
+	struct { int64_t sum, cnt; int max; } total;
+	struct { int cnt, max; } last;
+      } am1, am2;
+    } found;
+    struct { struct { int64_t sum, cnt; } am1, am2; } used;
+    } card;
+  struct { int64_t bin, trn; } moved;
+  struct { int count; int64_t added, skipped, steps; } bca;
+  struct { 
+    struct {
+      int64_t produced; 
+      struct { int64_t actual, tried, calls; } consumed;
+    } cls, units;
+  } sync;
+  struct { struct { int64_t orig, red; } sum; } deco;
+  struct {
+    int64_t min, bin, size, deco;
+    struct { int64_t search, hits; } poison;
+    struct { int64_t search, hits; } usedtwice;
+  } mincls;
+  struct {
+     struct { int64_t tried, red, sat; } cls, lits;
+     struct { int64_t red, sum; } jlevel; } redcls;
+  int64_t drupped, druplig;
+  struct { int64_t count, tried, cands, sub; } subl;
+  struct { int count; int64_t flips, mems; int min; } locs;
+  struct {
+    int count, failed, impls, equivs;
+    int64_t rounds, steps, cached, sat, unsat, decs, confs;
+    struct { int64_t classes, envs; } sumsize;
+    struct { int64_t total;
+	     struct { int64_t count, sat, unsat; } type[3]; } queries;
+  } sweep;
+  struct { int64_t count; int max, min; } setscincf;
+  struct { int64_t tried, locked; } promote;
+  struct { int count; int64_t quat, self1, self2, dup; } quatres;
+  struct { int64_t flushed, sorted; } queue;
+  struct { int64_t count, lits; } bump;
+  struct { int64_t count; EMA avg; int changed, level; } stability;
+} Stats;
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Times {
+    double all, search, preprocessing, inprocessing;            // level 0
+    double lookahead;///PUT NOTHING HERE!                       // level 0
+#define TIMESLEVEL0     lookahead
+    double elim, transred, block, unhide, ternres;              // level 1
+    double gauss, quatres, card, cce, bca, locs, sweep;         // level 1
+    double showscoredist, showfeatures, prune;                  // level 1
+    double probe;///////PUT NOTHING HERE!                       // level 1
+#define TIMESLEVEL1     probe
+    struct { double simple, basic, treelook; } prb;             // level 2
+    double quatres1, quatres2;                                  // level 2
+    double gc, decompose, queuesort, phase;                     // level 2
+    double backward;////PUT NOTHING HERE!                       // level 2
+#define TIMESLEVEL2     backward
+    double restart, defrag;                                     // level 3
+    double reduce;//////PUT NOTHING HERE!                       // level 3
+#define TIMESLEVEL3     reduce
+    double analysis, decide, bump, mincls, druplig;             // level 4
+    double redcls, queuedecision, heapdecision, subl;           // level 4
+} Times;
+
+#define TIMESLEVEL0IDX (&(((Times*)0)->TIMESLEVEL0)- &((Times*)0)->all)
+#define TIMESLEVEL1IDX (&(((Times*)0)->TIMESLEVEL1)- &((Times*)0)->all)
+#define TIMESLEVEL2IDX (&(((Times*)0)->TIMESLEVEL2)- &((Times*)0)->all)
+#define TIMESLEVEL3IDX (&(((Times*)0)->TIMESLEVEL3)- &((Times*)0)->all)
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Del { int cur, rem; } Del;
+
+typedef struct PruneLimit { int64_t lim, inc; } PruneLimit;
+
+typedef struct Limits {
+  int lkhdpen;
+  int64_t randec, randphase, dfg;
+  struct {
+    int64_t visits;
+    struct { int64_t add; int start; } clauses;
+    struct { int start; } vars;
+  } inc;
+  struct { struct { int64_t otfs, confs; } vars; } rescore;
+  struct { int pen; Del del; int64_t steps, irrprgss; } elm, blk;
+  struct { int pen; Del del; int64_t steps; }
+    trd, unhd, ternres, quatres, cce, card, sweep;
+  struct { int pen; Del del; struct { int64_t extr, elim; } steps; } gauss;
+  struct { int64_t confs; } restart;
+  struct { int64_t steps; 
+           struct { int pen; Del del; } simple, basic, treelook; } prb;
+  struct {
+    int64_t confs, hard, vars, its, bin, trn;
+    int cinc, itinc, binc, tinc; } simp;
+  struct { int64_t steps, confs; } sync;
+  struct { int64_t steps; } term;
+  struct { int64_t fixed; } gc;
+  struct { Del del; int64_t steps, added; } bca;
+  struct { int64_t steps, time; } trep;
+  struct { int64_t confs, inc; int vars; } locs;
+  struct { int redlarge, reset; } reduce;
+  struct { int64_t decisions, inc; } prune;
+} Limits;
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Cbs {
+  struct { int (*fun)(void*); void * state; int done; } term;
+  struct {
+    struct { void (*fun)(void*,int); void * state; } produce, consumed;
+    struct { void(*fun)(void*,int**,int**); void*state; } consume;
+  } units;
+  struct {
+    struct { void (*fun)(void*,int*,int); void * state; } produce;
+    struct { void(*fun)(void*,int**,int*); void*state; } consume;
+    struct { void (*fun)(void*,int); void * state; } consumed;
+  } cls;
+  struct {
+    struct { int * (*fun)(void*); void * state; } lock;
+    struct { void (*fun)(void*,int,int); void * state; } unlock;
+  } eqs;
+  struct { void(*lock)(void*); void (*unlock)(void*); void*state; } msglock;
+  double (*getime)(void);
+  void (*onabort)(void *); void * abortstate;
+} Cbs;
+
+typedef struct BCA { Stk covered; } BCA;
+
+typedef struct Dis { struct { Stk bin, trn; } red, irr; } Dis;
+
+typedef struct Elm {
+  int64_t oldsteps;
+  int pivot, negcls, necls, neglidx, round, oldelmd;
+  Stk lits, next, clv, csigs, sizes, occs, noccs, mark, m2i;
+  struct { Stk stk; int * pos, mt, nvars; } touched;
+  int bkwdocclim;
+} Elm;
+
+typedef struct Card {
+  Stk atmost1, atmost2, cards, elim, * occs, units, expam1;
+  char * eliminated, * lit2used, * marked;
+  signed char * count;
+  int * lit2count;
+} Card;
+
+typedef struct FltStr { int current; char str[MAXFLTSTR][100]; } FltStr;
+
+typedef struct SPE { signed int count : 31; unsigned mark : 1, sum; } SPE;
+
+typedef struct SPrb { 
+  Stk units, impls, eqs, counted, marked;
+  SPE * spes;
+} SPrb;
+
+typedef struct Gauss { 
+  Stk xors, order, * occs; 
+  signed char * eliminated;
+  int garbage, next; 
+} Gauss;
+
+typedef struct CCE {
+  Stk cla, extend, clauses;
+  int * rem, bin, trn;
+} CCE;
+
+typedef struct SWP {
+  int partitions, round, query, sat, type;
+  Stk partition;
+  struct { int64_t classes, envs; } sumsize;
+  struct { int count; struct { int a, b; } cached; Stk stk; } decision;
+} SWP;
+
+typedef struct Tlk { Stk stk, seen; TVar * tvars; LKHD * lkhd; } Tlk;
+
+typedef struct Mem {
+  void * state;
+  lglalloc alloc; lglrealloc realloc; lgldealloc dealloc;
+} Mem;
+
+typedef struct Wchs { Stk stk; unsigned start[MAXLDFW]; int free; } Wchs;
+
+typedef struct Wrk {
+  Stk queue;
+  int count, head, size, posonly, fifo, * pos;
+} Wrk;
+
+typedef struct Queue { Stk stk; int mt, next, sorted; } Queue;
+
+/*------------------------------------------------------------------------*/
+
+struct LGL {
+  State state;
+
+  int probing, tid, tids;
+  int nvars, szvars, maxext, szext, changed, mt, repcntdown;
+  int szdrail, next, next2, flushed, level, alevel, wait, glag;
+  int unassigned, lrgluereasons, failed, assumed;
+
+  Flt scinc, scincf, maxscore, minscore;
+  int scincinc;
+
+  char cceing, gaussing, bcaing, repforcehead, quatres, notrim;
+  char searching, simp, allphaseset, flushphases, occs;
+  char unhiding, basicprobing, simpleprobing, treelooking, setuponce;
+  char eliminating, donotsched, blocking, ternresing, lkhd, allfrozen;
+  char blkall, blkrem, blkrtc, elmall, elmrem, elmrtc, sweeprtc, decomposing;
+  char frozen, dense, rmredbintrn, notfullyconnected, forcegc, allowforce;
+  char ccertc, touching, sweeping;
+
+  int64_t confatlastit;
+
+  LGL * parent;
+  int forked;
+
+  Conf conf;
+  RNG rng;
+
+  // the state above this line is copied during 'clone' with 'memcpy'
+
+  Mem * mem;
+  Opts * opts;
+  Stats * stats;
+  Times * times;
+  Timers * timers;
+  Limits * limits;
+  Ext * ext;
+  int * i2e;
+  int * doms;
+  DVar * dvars;
+  QVar * qvars;
+  AVar * avars;
+  Val * vals;
+  Flt * jwh;
+  TD * drail;
+  Stk * red;
+  Wchs * wchs;
+
+  Ctk control;
+#ifndef NDEBUG
+  Stk prevclause;
+  int prevglue;
+#endif
+  Stk clause, eclause, extend, irr, trail, frames, promote;
+  Stk eassume, assume, learned;
+  Stk dsched;
+#ifndef NCHKSOL
+  Stk orig;
+#endif
+  Queue queue;
+
+  union {
+    Elm * elm; SPrb * sprb; Tlk * tlk; Gauss * gauss;
+    CCE * cce; BCA * bca; Card * card; SWP * swp;
+  };
+  union { Stk lcaseen, sortstk; };
+  Stk poisoned, seen, esched, minstk, resolvent;
+  struct { Stk bin, trn; } saved;
+  EVar * evars;
+  Dis * dis;
+  Wrk * wrk;
+  int * repr;
+
+  char closeapitrace;
+  FILE * out;
+  FILE * apitrace;
+  FILE * trace;
+  char * prefix;
+  Cbs * cbs;
+
+  LGL * clone;
+
+  FltStr * fltstr;
+#if !defined(NLGLDRUPLIG)
+  Druplig * druplig;
+  int drupligunit;
+#endif
+};
+
+/*-------------------------------------------------------------------------*/
+
+#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
+
+static const char lglfloorldtab[256] =
+{
+// 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
+  -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+  LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6),
+  LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7)
+};
+
+static const uint64_t lglbasevar2funtab[6] = {
+  0xaaaaaaaaaaaaaaaaull, 0xccccccccccccccccull, 0xf0f0f0f0f0f0f0f0ull,
+  0xff00ff00ff00ff00ull, 0xffff0000ffff0000ull, 0xffffffff00000000ull,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int lglfloorld (int n) {
+  assert (n >= 0);
+  if (n < (1<<8)) return lglfloorldtab[n];
+  if (n < (1<<16)) return 8 + lglfloorldtab[n>>8];
+  if (n < (1<<24)) return 16 + lglfloorldtab[n>>16];
+  return 24 + lglfloorldtab[n>>24];
+}
+
+static int lglispow2 (int n) {
+  assert (0 <= n && n <= INT_MAX);
+  return !(n & (n - 1));
+}
+
+static int lglceild (int n) {
+  int res = lglfloorld (n);
+  if (!lglispow2 (n)) res++;
+  return res;
+}
+
+static void lglchkflt (Flt a) {
+#ifndef NDEBUG
+  assert (a >= 0);
+  assert (FLTMAX >= (uint64_t) a);
+#else
+  (void) a;
+#endif
+}
+
+static Exp lglexp (Flt a) {
+  Flt tmp = a >> FLTPRC;
+  Exp res = tmp;
+  assert (0 <= res && res <= EXPMAX);
+  res -= EXPZRO;
+  return res;
+}
+
+static Mnt lglmnt (Flt a) {
+  Mnt res = a & MNTMAX;
+  res |= MNTBIT;
+  assert (res <= MNTMAX);
+  return res;
+}
+
+static Flt lglflt (Exp e, Mnt m) {
+  Flt res;
+  if (!m) return FLTMIN;
+  if (m < MNTBIT) {
+    while (!(m & MNTBIT)) {
+      m <<= 1;
+      if (e > INT_MIN) e--;
+      else break;
+    }
+  } else {
+    while (m > MNTMAX) {
+       m >>= 1;
+       if (e > INT_MIN) e++;
+       else break;
+    }
+  }
+  if (e < -EXPZRO) return FLTMIN;
+  if (e > EXPMAX - EXPZRO) return FLTMAX;
+  e += EXPZRO;
+  assert (0 <= e && e <= EXPMAX);
+  assert (m <= MNTMAX);
+  assert (m & MNTBIT);
+  res = m & ~MNTBIT;
+  res |= ((Flt)e) << FLTPRC;
+  return res;
+}
+
+static Flt lglrat (unsigned n, unsigned d) {
+  Mnt m;
+  Exp e;
+  if (!n) return FLTMIN;
+  if (!d) return FLTMAX;
+  m = n;
+  e = 0;
+  while (!(m & (1ull << 63))) m <<= 1, e--;
+  m /= d;
+  return lglflt (e, m);
+}
+
+#ifndef NDEBUG
+double lglflt2dbl (Flt a) {
+  return lglmnt (a) * pow (2.0, lglexp (a));
+}
+#endif
+
+static const char * lglflt2str (LGL * lgl, Flt a) {
+  double d, e;
+  assert (lgl->fltstr);
+  if (a == FLTMIN) return "0";
+  if (a == FLTMAX) return "inf";
+  d = lglmnt (a);
+  d /= 4294967296ll;
+  e = lglexp (a);
+  e += 32;
+  lgl->fltstr->current++;
+  if (lgl->fltstr->current == MAXFLTSTR) lgl->fltstr->current = 0;
+  sprintf (lgl->fltstr->str[lgl->fltstr->current], "%.6fd%+03.0f", d, e);
+  return lgl->fltstr->str[lgl->fltstr->current];
+}
+
+static Flt lgladdflt (Flt a, Flt b) {
+  Exp e, f, g;
+  Mnt m, n, o;
+  lglchkflt (a);
+  lglchkflt (b);
+  if (a == FLTMAX) return FLTMAX;
+  if (b == FLTMAX) return FLTMAX;
+  if (a == FLTMIN) return b;
+  if (b == FLTMIN) return a;
+  e = lglexp (a);
+  f = lglexp (b);
+  if (e < f) g = e, e = f, f = g, o = a, a = b, b = o;
+  m = lglmnt (a);
+  n = lglmnt (b);
+  if (e - f < sizeof (m) * 8) m += n >> (e - f);
+  return lglflt (e, m);
+}
+
+static Flt lglmulflt (Flt a, Flt b) {
+  Exp e, ea, eb;
+  Mnt m, ma, mb;
+  lglchkflt (a);
+  lglchkflt (b);
+  if (a == FLTMAX) return FLTMAX;
+  if (b == FLTMAX) return FLTMAX;
+  if (a == FLTMIN) return FLTMIN;
+  if (b == FLTMIN) return FLTMIN;
+  ea = lglexp (a); eb = lglexp (b);
+  if (ea > 0 && eb > 0 && (INT_MAX - ea < eb)) return FLTMAX;
+  e = ea + eb;
+  if (e > EXPMAX - EXPZRO - 32) return FLTMAX;
+  e += 32;
+  ma = lglmnt (a); mb = lglmnt (b);
+  ma >>= 1; mb >>= 1;
+  m = ma * mb;
+  assert (3ull << 62);
+  m >>= 30;
+  return lglflt (e, m);
+}
+
+static Flt lglshflt (Flt a, int s) {
+  Exp e;
+  Mnt m;
+  if (a == FLTMAX) return FLTMAX;
+  if (a == FLTMIN) return FLTMIN;
+  assert (0 <= s);
+  e = lglexp (a);
+  if (e < INT_MIN + s) return FLTMIN;
+  e -= s;
+  m = lglmnt (a);
+  return lglflt (e, m);
+}
+
+static const char * lglscr2str (LGL * lgl, Flt scr) {
+  return lglflt2str (lgl, scr);
+}
+
+static void lglwrn (LGL * lgl, const char * msg, ...) {
+  va_list ap;
+  fprintf (lgl->out, "*** warning in '%s': ", __FILE__);
+  va_start (ap, msg);
+  vfprintf (lgl->out, msg, ap);
+  va_end (ap);
+  fputc ('\n', lgl->out);
+  fflush (lgl->out);
+}
+
+static void lgldie (LGL * lgl, const char * msg, ...) {
+  va_list ap;
+  fprintf (lgl->out, "*** internal error in '%s': ", __FILE__);
+  va_start (ap, msg);
+  vfprintf (lgl->out, msg, ap);
+  va_end (ap);
+  fputc ('\n', lgl->out);
+  fflush (lgl->out);
+  exit (0);
+}
+
+static void lglabort (LGL * lgl) {
+  if (!lgl) exit (1);
+  if (lgl->opts && lgl->opts->sleeponabort.val) {
+    fprintf (stderr,
+"liblgl.a: Process %d will sleep for %d seconds "
+" before continuing with 'lglabort' procedure.\n",
+      getpid (), lgl->opts->sleeponabort.val);
+    fflush (stderr);
+    sleep (lgl->opts->sleeponabort.val);
+  }
+  if (lgl->cbs && lgl->cbs->onabort)
+    lgl->cbs->onabort (lgl->cbs->abortstate);
+  if (lgl->opts && lgl->opts->exitonabort.val) exit (1);
+  abort ();
+}
+
+static const char * lglprefix (LGL * lgl) {
+  return lgl && lgl->prefix ? lgl->prefix : "c (LGL HAS NO PREFIX YET) ";
+}
+
+static int lglmsgstart (LGL * lgl, int level) {
+#ifndef NLGLOG
+  if (lgl->opts->log.val <= 0)
+#endif
+  if (lgl->opts->verbose.val < level) return 0;
+  if (lgl->cbs && lgl->cbs->msglock.lock)
+    lgl->cbs->msglock.lock (lgl->cbs->msglock.state);
+  fputs (lglprefix (lgl), lgl->out);
+  if (lgl->tid >= 0) fprintf (lgl->out, "%d ", lgl->tid);
+  return 1;
+}
+
+static void lglmsgend (LGL * lgl) {
+  fputc ('\n', lgl->out);
+  fflush (lgl->out);
+  if (lgl->cbs && lgl->cbs->msglock.unlock)
+    lgl->cbs->msglock.unlock (lgl->cbs->msglock.state);
+}
+
+static void lglprt (LGL * lgl, int level, const char * msg, ...) {
+  va_list ap;
+#ifndef NLGLOG
+  if (lgl->opts->log.val <= 0)
+#endif
+  if (lgl->opts->verbose.val < level) return;
+  lglmsgstart (lgl, level);
+  va_start (ap, msg);
+  vfprintf (lgl->out, msg, ap);
+  va_end (ap);
+  lglmsgend (lgl);
+}
+
+#ifndef NLGLOG
+static void lglogstart (LGL * lgl, int level, const char * msg, ...) {
+  va_list ap;
+  assert (lgl->opts->log.val >= level);
+  if (lgl->cbs && lgl->cbs->msglock.lock)
+    lgl->cbs->msglock.lock (lgl->cbs->msglock.state);
+  fputs (lglprefix (lgl), lgl->out);
+  if (lgl->tid >= 0) fprintf (lgl->out, "%d ", lgl->tid);
+  fprintf (lgl->out, "LOG%d %d ", level, lgl->level);
+  va_start (ap, msg);
+  vfprintf (lgl->out, msg, ap);
+  va_end (ap);
+}
+
+#define lglogend lglmsgend
+#endif
+
+/*------------------------------------------------------------------------*/
+
+double lglprocesstime (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 lglgetime (LGL * lgl) {
+  lgl->stats->times++;
+  if (lgl->cbs && lgl->cbs->getime) return lgl->cbs->getime ();
+  else return lglprocesstime ();
+}
+
+static int lglprofidx (LGL * lgl, double * timestatsptr) {
+  int res;
+  assert ((double*) lgl->times <= timestatsptr);
+  assert (timestatsptr < (double*)(sizeof *lgl->times + (char*) lgl->times));
+  res = timestatsptr - (double*) lgl->times;
+  return res;
+}
+
+static int lglignprofidx (LGL * lgl, int idx) {
+  int res;
+  assert (0 <= idx);
+  assert (idx < sizeof (Times)/sizeof(double));
+  switch (lgl->opts->profile.val) {
+    case 0:  res = (TIMESLEVEL0IDX < idx); break;
+    case 1:  res = (TIMESLEVEL1IDX < idx); break;
+    case 2:  res = (TIMESLEVEL2IDX < idx); break;
+    case 3:  res = (TIMESLEVEL3IDX < idx); break;
+    default: res = 0;                      break;
+  }
+  return res;
+}
+
+static int lglignprofptr (LGL * lgl, double * timestatsptr) {
+  return lglignprofidx (lgl, lglprofidx (lgl, timestatsptr));
+}
+
+static void lglstart (LGL * lgl, double * timestatsptr) {
+  Timer * timer;
+  int ign, idx;
+  idx = lglprofidx (lgl, timestatsptr);
+  ign = lglignprofidx (lgl, idx);
+  assert (lgl->timers->nest < MAXPHN);
+  timer = lgl->timers->stk + lgl->timers->nest++;
+  timer->idx = idx;
+  if ((timer->ign = ign)) timer->start = 0;
+  else timer->start = lglgetime (lgl);
+}
+
+void lglflushtimers (LGL * lgl) {
+  double time = lglgetime (lgl), delta, entered, * ptr;
+  Timer * timer;
+  int nest;
+  for (nest = 0; nest < lgl->timers->nest; nest++) {
+    timer = lgl->timers->stk + nest;
+    if (timer->ign) continue;
+    entered = timer->start;
+    timer->start = time;
+    delta = time - entered;
+    if (delta < 0) delta = 0;
+    ptr = timer->idx + (double*)lgl->times;
+    *ptr += delta;
+  }
+}
+
+double lglsec (LGL * lgl) {
+  REQINIT ();
+  lglflushtimers (lgl);
+  return lgl->times->all;
+}
+
+static void lglstop (LGL * lgl) {
+  Timer * timer;
+  assert (lgl->timers->nest > 0);
+  timer = lgl->timers->stk + lgl->timers->nest - 1;
+  if (!timer->ign) lglflushtimers (lgl);
+  lgl->timers->nest--;
+  assert (lgl->timers->nest >= 0);
+}
+
+/*------------------------------------------------------------------------*/
+
+void lglsetid (LGL * lgl, int tid, int tids) {
+  REQINITNOTFORKED ();
+  ABORTIF (tid < 0, "negative id");
+  ABORTIF (tid >= tids, "id exceed number of ids");
+  lgl->tid = tid;
+  lgl->tids = tids;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void lglinc (LGL * lgl, size_t bytes) {
+  lgl->stats->bytes.current += bytes;
+  if (lgl->stats->bytes.max < lgl->stats->bytes.current) {
+    lgl->stats->bytes.max = lgl->stats->bytes.current;
+    LOG (5, "maximum allocated %ld bytes", lgl->stats->bytes.max);
+  }
+}
+
+static void lgldec (LGL * lgl, size_t bytes) {
+  assert (lgl->stats->bytes.current >= bytes);
+  lgl->stats->bytes.current -= bytes;
+}
+
+static void * lglnew (LGL * lgl, size_t bytes) {
+  void * res;
+  if (!bytes) return 0;
+  if (lgl->mem->alloc) res = lgl->mem->alloc (lgl->mem->state, bytes);
+  else res = malloc (bytes);
+  if (!res) lgldie (lgl, "out of memory allocating %ld bytes", bytes);
+  assert (res);
+  LOG (5, "allocating %p with %ld bytes", res, bytes);
+  lglinc (lgl, bytes);
+  if (res) memset (res, 0, bytes);
+  return res;
+}
+
+static void lgldel (LGL * lgl, void * ptr, size_t bytes) {
+  if (!ptr) { assert (!bytes); return; }
+  lgldec (lgl, bytes);
+  LOG (5, "freeing %p with %ld bytes", ptr, bytes);
+  if (lgl->mem->dealloc) lgl->mem->dealloc (lgl->mem->state, ptr, bytes);
+  else free (ptr);
+}
+
+static void * lglrsz (LGL * lgl, void * ptr, size_t old, size_t new) {
+  void * res;
+  assert (!ptr == !old);
+  if (!ptr) return lglnew (lgl, new);
+  if (!new) { lgldel (lgl, ptr, old); return 0; }
+  if (old == new) return ptr;
+  lgldec (lgl, old);
+  if (lgl->mem->realloc)
+    res = lgl->mem->realloc (lgl->mem->state, ptr, old, new);
+  else res = realloc (ptr, new);
+  if (!res)
+    lgldie (lgl, "out of memory reallocating %ld to %ld bytes", old, new);
+  assert (res);
+  LOG (5, "reallocating %p to %p from %ld to %ld bytes", ptr, res, old, new);
+  lglinc (lgl, new);
+  if (new > old) memset (res + old, 0, new - old);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static char * lglstrdup (LGL * lgl, const char * str) {
+  char * res;
+  NEW (res, strlen (str) + 1);
+  return strcpy (res, str);
+}
+
+static void lgldelstr (LGL * lgl, char * str) {
+  DEL (str, strlen (str) + 1);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void lglinitcbs (LGL * lgl) {
+  if (!lgl->cbs) NEW (lgl->cbs, 1);
+}
+
+void lglonabort (LGL * lgl, void * abortstate, void (*onabort)(void*)) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->abortstate = abortstate;
+  lgl->cbs->onabort = onabort;
+}
+
+void lglseterm (LGL * lgl, int (*fun)(void*), void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->term.fun = fun;
+  lgl->cbs->term.state = state;
+}
+
+void lglsetproduceunit (LGL * lgl, void (*fun) (void*, int), void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->units.produce.fun = fun;
+  lgl->cbs->units.produce.state = state;
+}
+
+void lglsetconsumeunits (LGL * lgl,
+			 void (*fun) (void*, int **, int **),
+			 void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->units.consume.fun =  fun;
+  lgl->cbs->units.consume.state = state;
+}
+
+void lglsetconsumedunits (LGL * lgl,
+			  void (*fun) (void*, int), void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->units.consumed.fun = fun;
+  lgl->cbs->units.consumed.state = state;
+}
+
+void lglsetproducecls (LGL * lgl, 
+                       void (*fun) (void*, int *, int), void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->cls.produce.fun = fun;
+  lgl->cbs->cls.produce.state = state;
+}
+
+void lglsetconsumecls (LGL * lgl,
+		       void (*fun) (void*, int **, int *),
+		       void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->cls.consume.fun =  fun;
+  lgl->cbs->cls.consume.state = state;
+}
+
+void lglsetconsumedcls (LGL * lgl,
+			void (*fun) (void*, int), void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->cls.consumed.fun = fun;
+  lgl->cbs->cls.consumed.state = state;
+}
+
+void lglsetlockeq (LGL * lgl, int * (*fun)(void*), void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->eqs.lock.fun = fun;
+  lgl->cbs->eqs.lock.state = state;
+}
+
+void lglsetunlockeq (LGL * lgl, void (*fun)(void*,int,int), void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->eqs.unlock.fun = fun;
+  lgl->cbs->eqs.unlock.state = state;
+}
+
+void lglsetmsglock (LGL * lgl,
+		    void (*lock)(void*), void (*unlock)(void*),
+		    void * state) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->msglock.lock = lock;
+  lgl->cbs->msglock.unlock = unlock;
+  lgl->cbs->msglock.state = state;
+}
+
+void lglsetime (LGL * lgl, double (*time)(void)) {
+  REQINITNOTFORKED ();
+  lglinitcbs (lgl);
+  lgl->cbs->getime = time;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglfullstk (Stk * s) { return s->top == s->end; }
+static int lglmtstk (Stk * s) { return s->top == s->start; }
+static size_t lglcntstk (Stk * s) { return s->top - s->start; }
+static size_t lglszstk (Stk * s) { return s->end - s->start; }
+
+static int lglpeek (Stk * s, int pos) {
+  assert (0 <= pos && pos < lglszstk (s));
+  return s->start[pos];
+}
+
+static void lglpoke (Stk * s, int pos, int val) {
+  assert (0 <= pos && pos <= lglszstk (s));
+  s->start[pos] = val;
+}
+
+static void lglenlstk (LGL * lgl, Stk * s) {
+  size_t old_size = lglszstk (s);
+  size_t new_size = old_size ? 2 * old_size : 1;
+  size_t count = lglcntstk (s);
+  RSZ (s->start, old_size, new_size);
+  s->top = s->start + count;
+  s->end = s->start + new_size;
+}
+
+static void lglrelstk (LGL * lgl, Stk * s) {
+  DEL (s->start, lglszstk (s));
+  CLRPTR (s);
+}
+
+static void lglshrstk (LGL * lgl, Stk * s, int new_size) {
+  size_t old_size, count = lglcntstk (s);
+  assert (new_size >= 0);
+  assert (count <= new_size);
+  if (new_size > 0) {
+    old_size = lglszstk (s);
+    RSZ (s->start, old_size, new_size);
+    s->top = s->start + count;
+    s->end = s->start + new_size;
+  } else lglrelstk (lgl, s);
+}
+
+static void lglfitstk (LGL * lgl, Stk * s) {
+  lglshrstk (lgl, s, lglcntstk (s));
+}
+
+static void lglpushstk (LGL * lgl, Stk * s, int elem) {
+  if (lglfullstk (s)) lglenlstk (lgl, s);
+  *s->top++ = elem;
+}
+
+static void lglrmstk (Stk * s, int elem) {
+  int * p, * q;
+  for (p = s->start; p < s->top; p++)
+    if (*p == elem) break;
+  assert (p < s->top);
+  q = p++;
+  while (p < s->top)
+    *q++ = *p++;
+  s->top = q;
+}
+
+static int lglpopstk (Stk * s) { assert (!lglmtstk (s)); return *--s->top; }
+
+static int lgltopstk (Stk * s) { assert (!lglmtstk (s)); return s->top[-1]; }
+
+static void lglrststk (Stk * s, int newsz) {
+  assert (0 <= newsz && newsz <= lglcntstk (s));
+  s->top = s->start + newsz;
+}
+
+static void lglclnstk (Stk * s) { lglrststk (s, 0); }
+
+/*------------------------------------------------------------------------*/
+
+static void lgltrapi (LGL * lgl, const char * msg, ...) {
+  va_list ap;
+  assert (lgl->apitrace);
+  va_start (ap, msg);
+  vfprintf (lgl->apitrace, msg, ap);
+  va_end (ap);
+  fputc ('\n', lgl->apitrace);
+  if (lgl->opts->trapiflush.val) fflush (lgl->apitrace);
+}
+
+static void lglopenapitrace (LGL * lgl, const char * name) {
+  FILE * file;
+  char * cmd;
+  int len;
+  len = strlen (name);
+  if (len >= 3 && !strcmp (name + len - 3, ".gz")) {
+    len += 20;
+    NEW (cmd, len);
+    sprintf (cmd, "gzip -c > %s", name);
+    file = popen (cmd, "w");
+    DEL (cmd, len);
+    if (file) lgl->closeapitrace = 2;
+  } else {
+    file = fopen (name, "w");
+    if (file) lgl->closeapitrace = 1;
+  }
+  if (file) lgl->apitrace = file;
+  else lglwrn (lgl, "can not write API trace to '%s'", name);
+  TRAPI ("init");
+}
+
+void lglwtrapi (LGL * lgl, FILE * apitrace) {
+  REQUIRE (UNUSED);
+  ABORTIF (lgl->apitrace, "can only write one API trace");
+  lgl->apitrace = apitrace;
+  TRAPI ("init");
+}
+
+/*------------------------------------------------------------------------*/
+
+static unsigned lglrand (LGL * lgl) {
+  unsigned res;
+  lgl->rng.z = 36969 * (lgl->rng.z & 65535) + (lgl->rng.z >> 16);
+  lgl->rng.w = 18000 * (lgl->rng.w & 65535) + (lgl->rng.w >> 16);
+  res = (lgl->rng.z << 16) + lgl->rng.w;
+  LOG (5, "rng %u", res);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglmtftk (Ftk * ftk) { return ftk->top == ftk->start; }
+
+static int lglfullftk (Ftk * ftk) { return ftk->top == ftk->end; }
+
+static int lglsizeftk (Ftk * ftk) { return ftk->end - ftk->start; }
+
+static int lglcntftk (Ftk * ftk) { return ftk->top - ftk->start; }
+
+static void lglrelftk (LGL * lgl, Ftk * ftk) {
+  DEL (ftk->start, lglsizeftk (ftk));
+  memset (ftk, 0, sizeof *ftk);
+}
+
+static void lglenlftk (LGL * lgl, Ftk * ftk) {
+  int oldsize = lglsizeftk (ftk);
+  int newsize = oldsize ? 2*oldsize : 1;
+  int count = lglcntftk (ftk);
+  RSZ (ftk->start, oldsize, newsize);
+  ftk->top = ftk->start + count;
+  ftk->end = ftk->start + newsize;
+}
+
+static void lglpushftk (LGL * lgl, Ftk * ftk, Flt f) {
+  if (lglfullftk (ftk)) lglenlftk (lgl, ftk);
+  *ftk->top++ = f;
+}
+
+static Flt lgltopftk (Ftk * ftk) {
+  assert (!lglmtftk (ftk));
+  return ftk->top[-1];
+}
+
+static Flt lglpopftk (Ftk * ftk) {
+  assert (!lglmtftk (ftk));
+  return *--ftk->top;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglfullctk (Ctk * ctk) { return ctk->top == ctk->end; }
+
+static int lglsizectk (Ctk * ctk) { return ctk->end - ctk->start; }
+
+static int lglcntctk (Ctk * ctk) { return ctk->top - ctk->start; }
+
+static void lglrelctk (LGL * lgl, Ctk * ctk) {
+  DEL (ctk->start, lglsizectk (ctk));
+  memset (ctk, 0, sizeof *ctk);
+}
+
+static void lglenlctk (LGL * lgl, Ctk * ctk) {
+  int oldsize = lglsizectk (ctk);
+  int newsize = oldsize ? 2*oldsize : 1;
+  int count = lglcntctk (ctk);
+  RSZ (ctk->start, oldsize, newsize);
+  ctk->top = ctk->start + count;
+  ctk->end = ctk->start + newsize;
+}
+
+static void lglpushcontrol (LGL * lgl, int decision) {
+  Ctk * ctk = &lgl->control;
+  Ctr * ctr;
+  if (lglfullctk (ctk)) lglenlctk (lgl, ctk);
+  ctr = ctk->top++;
+  ctr->decision = decision;
+  ctr->used = 0;
+  ctr->used2 = 0;
+}
+
+static void lglpopcontrol (LGL * lgl) {
+  assert (lgl->control.top > lgl->control.start);
+  --lgl->control.top;
+}
+
+static void lglrstcontrol (LGL * lgl, int count) {
+  while (lglcntctk (&lgl->control) > count)
+    lglpopcontrol (lgl);
+}
+
+static Ctr * lglctr (LGL * lgl, int level) {
+  Ctk * ctk = &lgl->control;
+  Ctr * res;
+  assert (0 < level && level < lglsizectk (ctk));
+  res = ctk->start + level;
+  return res;
+}
+
+static unsigned lglevelused (LGL * lgl, int level) {
+  return lglctr (lgl, level)->used;
+}
+
+static void lgluselevel (LGL * lgl, int level) {
+  Ctk * ctk = &lgl->control;
+  Ctr * ctr;
+  assert (0 < level && level < lglsizectk (ctk));
+  ctr = ctk->start + level;
+  if (!ctr->used) {
+    lglpushstk (lgl, &lgl->frames, level);
+    LOG (2, "pulled in decision level %d", level);
+    ctr->used = 1;
+  } else if (ctr->used == 1) {
+    LOG (2, "pulled in decision level %d a second time", level);
+    ctr->used = 2;
+  }
+}
+
+static void lglunuselevel (LGL * lgl, int level) {
+  Ctk * ctk = &lgl->control;
+  Ctr * ctr;
+  assert (0 < level);
+  if (level >= lglcntctk (ctk)) return;
+  ctr = ctk->start + level;
+  assert (ctr->used > 0);
+  ctr->used = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+void lglgetenv (LGL * lgl, Opt * opt, const char * lname) {
+  const char * q, * valstr;
+  char uname[40], * p;
+  int newval, oldval;
+  assert (strlen (lname) + 3 + 1 < sizeof (uname));
+  uname[0] = 'L'; uname[1] = 'G'; uname[2] = 'L';
+  p = uname + 3;
+  for (q = lname; *q; q++) {
+    assert (p < uname + sizeof uname);
+    *p++ = toupper ((int)*q);
+  }
+  assert (p < uname + sizeof uname);
+  *p = 0;
+  valstr = getenv (uname);
+  if (!valstr) return;
+  oldval = opt->val;
+  newval = atoi (valstr);
+  if (newval < opt->min) newval = opt->min;
+  if (newval > opt->max) newval = opt->max;
+  if (newval == oldval) return;
+  opt->val = newval;
+  TRAPI ("option %s %d", lname, newval);
+  COVER (lgl->clone);
+  if (lgl->clone) lglsetopt (lgl->clone, lname, newval);
+}
+
+static void lglchkenv (LGL * lgl) {
+  extern char ** environ;
+  char * src, *eos, * dst;
+  char ** p, * s, * d;
+  int len;
+  for (p = environ; (src = *p); p++) {
+    if (src[0] != 'L' || src[1] != 'G' || src[2] != 'L') continue;
+    for (eos = src; *eos && *eos != '='; eos++)
+      ;
+    len = eos - (src + 3);
+    NEW (dst, len + 1);
+    d = dst;
+    for (s = src + 3; s < eos; s++) *d++ = tolower ((int)*s);
+    *d = 0;
+    if (!lglhasopt (lgl, dst) &&
+        strcmp (dst, "apitrace") &&
+	strcmp (dst, "eak"))
+      lglwrn (lgl, "invalid 'LGL...' environment '%s'", src);
+    DEL (dst, len + 1);
+  }
+}
+
+#define SETPLAIN(NAME) \
+do { \
+  if (val) lgl->opts->NAME.val = 0; \
+  else lgl->opts->NAME.val = lgl->opts->NAME.dflt; \
+} while (0)
+
+#define SETDRUP SETPLAIN
+
+static void lglforcedruplig (LGL * lgl, int val) {
+  SETDRUP (bca);
+  SETDRUP (card);
+  SETDRUP (gauss);
+  SETDRUP (smallve);
+  SETDRUP (unhide);
+}
+
+static void lglsetdruplig (LGL * lgl, int val) {
+  lglforcedruplig (lgl, val);
+  lglprt (lgl, 1,
+    "[druplig] druplig checking switched %s",
+    val ? "on" : "off");
+}
+
+static void lglsetplain (LGL * lgl, int val) {
+  SETPLAIN (bca);
+  SETPLAIN (block);
+  SETPLAIN (card);
+  SETPLAIN (cce);
+  SETPLAIN (decompose);
+  SETPLAIN (elim);
+  SETPLAIN (gauss);
+  SETPLAIN (locs);
+  SETPLAIN (probe);
+  SETPLAIN (quatres);
+  SETPLAIN (sweep);
+  SETPLAIN (ternres);
+  SETPLAIN (transred);
+  SETPLAIN (unhide);
+  lglprt (lgl, 1, "[plain] plain solving switched %s", val ? "on" : "off");
+}
+
+#define SETWAIT(NAME) \
+do { \
+  if (val) lgl->opts->NAME.val = lgl->opts->NAME.dflt; \
+  else lgl->opts->NAME.val = 0; \
+} while (0)
+
+static void lglsetwait (LGL * lgl, int val) {
+  SETWAIT (batewait);
+  SETWAIT (bcawait);
+  SETWAIT (blockwait);
+  SETWAIT (ccewait);
+  SETWAIT (elmblkwait);
+  SETWAIT (gausswait);
+  SETWAIT (smallvewait);
+  SETWAIT (sweepwait);
+  SETWAIT (ternreswait);
+  SETWAIT (transredwait);
+  SETWAIT (unhidewait);
+  lglprt (lgl, 1, "[wait] waiting %s", val ? "enabled" : "disabled");
+}
+
+static LGL * lglnewlgl (void * mem,
+			lglalloc alloc,
+			lglrealloc realloc,
+			lgldealloc dealloc) {
+  LGL * lgl = alloc ? alloc (mem, sizeof *lgl) : malloc (sizeof *lgl);
+  ABORTIF (!lgl, "out of memory allocating main solver object");
+  CLRPTR (lgl);
+
+  lgl->mem = alloc ? alloc (mem, sizeof *lgl->mem) : malloc (sizeof *lgl->mem);
+  ABORTIF (!lgl->mem, "out of memory allocating memory manager object");
+
+  lgl->mem->state = mem;
+  lgl->mem->alloc = alloc;
+  lgl->mem->realloc = realloc;
+  lgl->mem->dealloc = dealloc;
+
+  lgl->opts = alloc ? alloc (mem, sizeof (Opts)) : malloc (sizeof (Opts));
+  ABORTIF (!lgl->opts, "out of memory allocating option manager object");
+  CLRPTR (lgl->opts);
+
+  lgl->stats = alloc ? alloc (mem, sizeof (Stats)) : malloc (sizeof (Stats));
+  ABORTIF (!lgl->stats, "out of memory allocating statistic counters");
+  CLRPTR (lgl->stats);
+
+  lglinc (lgl, sizeof *lgl);
+  lglinc (lgl, sizeof *lgl->mem);
+  lglinc (lgl, sizeof *lgl->opts);
+  lglinc (lgl, sizeof *lgl->stats);
+
+  return lgl;
+}
+
+static void lglsetmaxminscore (LGL * lgl) {
+  Flt oldmaxscore = lgl->maxscore, oldminscore = lgl->minscore;
+  lgl->maxscore = lglflt (DEFSCOREXP, 1);
+  lgl->minscore = lglflt (-DEFSCOREXP, 1);
+  if (oldmaxscore != lgl->maxscore)
+    lglprt (lgl, 1,
+      "[set-maximum-score] maximum score limit %s",
+      lglscr2str (lgl, lgl->maxscore));
+  if (oldminscore != lgl->minscore)
+    lglprt (lgl, 1,
+      "[set-minimum-score] minimum score limit %s",
+      lglscr2str (lgl, lgl->minscore));
+}
+
+static void lglsetscincf (LGL * lgl, int scincinc) {
+  if (scincinc == lgl->scincinc) return;
+  lgl->scincf = lglrat (1000 + scincinc, 1000);
+  if (!lgl->stats->setscincf.count++)
+    lgl->stats->setscincf.min = lgl->stats->setscincf.max = scincinc;
+  else {
+    if (scincinc < lgl->stats->setscincf.min)
+      lgl->stats->setscincf.min = scincinc;
+    if (scincinc > lgl->stats->setscincf.max)
+      lgl->stats->setscincf.max = scincinc;
+  }
+  lglprt (lgl, 2,
+    "[set-score-increment-%d] factor %s (%d/1000) after %lld conflicts",
+    lgl->stats->setscincf.count,
+    lglscr2str (lgl, lgl->scincf), scincinc, (LGLL) lgl->stats->confs);
+  lgl->scincinc = scincinc;
+}
+
+static void lglinitscores (LGL * lgl) {
+  lglsetmaxminscore (lgl);
+  lglsetscincf (lgl, lgl->opts->scincinc.val);
+}
+
+LGL * lglminit (void * mem,
+		lglalloc alloc,
+		lglrealloc realloc,
+		lgldealloc dealloc) {
+  const char * apitracename;
+  LGL * lgl;
+  int i;
+
+  lgl = 0;
+  ABORTIF (!alloc+!realloc+!dealloc != 0 && !alloc+!realloc+!dealloc != 3,
+	   "inconsistent set of external memory handlers");
+
+  assert (sizeof (long) == sizeof (void*));
+
+  assert (REMOVED > (RMSHFTLIT (MAXVAR) | MASKCS | REDCS));
+  assert (REMOVED > MAXREDLIDX);
+  assert (REMOVED > MAXIRRLIDX);
+
+  assert (MAXREDLIDX == MAXIRRLIDX);
+  assert (GLUESHFT == RMSHFT);
+
+  assert (INT_MAX > ((MAXREDLIDX << GLUESHFT) | GLUEMASK));
+  assert (INT_MAX > ((MAXIRRLIDX << RMSHFT) | MASKCS | REDCS));
+
+  assert (MAXGLUE < POW2GLUE);
+
+  lgl = lglnewlgl (mem, alloc, realloc, dealloc);
+  lgl->tid = -1;
+
+  lglpushcontrol (lgl, 0);
+  assert (lglcntctk (&lgl->control) == lgl->level + 1);
+
+  lgl->out = stdout;
+  lgl->prefix = lglstrdup (lgl, "c ");
+
+  apitracename = getenv ("LGLAPITRACE");
+  if (apitracename) lglopenapitrace (lgl, apitracename);
+
+  lglinitopts (lgl, lgl->opts);
+
+  if (lgl->opts->plain.val) lglsetplain (lgl, 1);
+  if (lgl->opts->druplig.val) lglsetdruplig (lgl, 1);
+  if (!lgl->opts->wait.val) lglsetwait (lgl, 0);
+
+  NEW (lgl->times, 1);
+  NEW (lgl->timers, 1);
+  NEW (lgl->limits, 1);
+  NEW (lgl->fltstr, 1);
+  NEW (lgl->red, MAXGLUE+1);
+  NEW (lgl->wchs, 1);
+  for (i = 0; i < MAXLDFW; i++) lgl->wchs->start[i] = UINT_MAX;
+  lglpushstk (lgl, &lgl->wchs->stk, (int) UINT_MAX);
+  lglpushstk (lgl, &lgl->wchs->stk, (int) UINT_MAX);
+
+  lgl->scinc = lglflt (0, 1);
+
+  TRANS (UNUSED);
+
+  return lgl;
+}
+
+static void lglcopyclonenfork (LGL * dst, LGL * src) {
+  memcpy (dst->opts, src->opts, sizeof *src->opts);
+  dst->out = src->out;
+  if (dst->prefix) lgldelstr (dst, dst->prefix);
+  dst->prefix = lglstrdup (dst, src->prefix);
+  if (src->cbs) {
+    lglinitcbs (dst);
+    if (src->cbs->onabort) {
+      dst->cbs->abortstate = src->cbs->abortstate;
+      dst->cbs->onabort = src->cbs->onabort;
+    }
+    if (src->cbs->getime) dst->cbs->getime = src->cbs->getime;
+  }
+}
+
+static void lglcompact (LGL *);
+
+LGL * lglmclone (LGL * orig,
+		 void * mem,
+		 lglalloc alloc,
+		 lglrealloc realloc,
+		 lgldealloc dealloc) {
+  size_t max_bytes, current_bytes;
+  LGL * lgl = orig;
+  int glue;
+
+  if (!orig) return 0;
+  lglcompact (orig);
+  LOG (1, "cloning");
+  lgl = lglnewlgl (mem, alloc, realloc, dealloc);
+  memcpy (lgl, orig, ((char*)&orig->mem) - (char*) orig);
+  max_bytes = lgl->stats->bytes.max;
+  current_bytes = lgl->stats->bytes.current;
+  memcpy (lgl->stats, orig->stats, sizeof *orig->stats);
+  lgl->stats->bytes.current = current_bytes;
+  lgl->stats->bytes.max = max_bytes;
+  lglcopyclonenfork (lgl, orig);
+
+  CLONE (limits, 1);
+  CLONE (times, 1);
+  CLONE (timers, 1);		assert (!lgl->timers->nest);
+  CLONE (fltstr, 1);
+  CLONE (ext, orig->szext);
+  CLONE (i2e, orig->szvars);
+  CLONE (doms, 2*orig->szvars);
+  CLONE (dvars, orig->szvars);
+  CLONE (qvars, orig->szvars);
+  CLONE (avars, orig->szvars);
+  CLONE (vals, orig->szvars);
+  CLONE (jwh, 2*orig->szvars);
+  CLONE (drail, orig->szdrail);
+
+  NEW (lgl->red, MAXGLUE+1);
+  for (glue = 0; glue <= MAXGLUE; glue++) CLONESTK (red[glue]);
+
+  NEW (lgl->wchs, 1);
+  memcpy (lgl->wchs, orig->wchs, sizeof *orig->wchs);
+  CLONESTK (wchs->stk);
+
+  CLONESTK (control);
+#ifndef NDEBUG
+  CLONESTK (prevclause);
+  lgl->prevglue = orig->prevglue;
+#endif
+  CLONESTK (clause);
+  CLONESTK (eclause);
+  CLONESTK (extend);
+  CLONESTK (irr);
+  CLONESTK (trail);
+  CLONESTK (frames);
+  CLONESTK (promote);
+  CLONESTK (eassume);
+  CLONESTK (assume);
+  CLONESTK (learned);
+  CLONESTK (dsched);
+
+  CLONESTK (queue.stk);
+  lgl->queue.mt = orig->queue.mt;
+  lgl->queue.next = orig->queue.next;
+
+#ifndef NCHKSOL
+  CLONESTK (orig);
+#endif
+#ifndef NDEBUG
+  {
+    const char * p;
+    for (p = (char*)&orig->elm; p < (char*)(&orig->repr+1); p++) assert (!*p);
+  }
+#endif
+  assert (lgl->stats->bytes.current == orig->stats->bytes.current);
+  assert (lgl->stats->bytes.max <= orig->stats->bytes.max);
+  lgl->stats->bytes.max = orig->stats->bytes.max;
+  return lgl;
+}
+
+LGL * lglclone (LGL * lgl) {
+  REQINIT ();
+  ABORTIF (lgl->opts->druplig.val,
+    "can not clone if Druplig checking is enabled");
+  return lglmclone (lgl,
+                    lgl->mem->state,
+                    lgl->mem->alloc,
+                    lgl->mem->realloc,
+                    lgl->mem->dealloc);
+}
+
+void lglchkclone (LGL * lgl) {
+  REQINITNOTFORKED ();
+  TRAPI ("chkclone");
+}
+
+LGL * lglinit (void) { return lglminit (0, 0, 0, 0); }
+
+static int lglmaxoptnamelen (LGL * lgl) {
+  int res = 0, len;
+  Opt * o;
+  for (o = FIRSTOPT (lgl); o <= LASTOPT (lgl); o++)
+    if ((len = strlen (o->lng)) > res)
+      res = len;
+  return res;
+}
+
+void lglusage (LGL * lgl) {
+  char fmt[20];
+  int len;
+  Opt * o;
+  REQINITNOTFORKED ();
+  len = lglmaxoptnamelen (lgl);
+  sprintf (fmt, "--%%-%ds", len);
+  for (o = FIRSTOPT (lgl); o <= LASTOPT (lgl); o++) {
+    fprintf (lgl->out, "   ");
+    fprintf (lgl->out, fmt, o->lng);
+    fprintf (lgl->out, " %s [%d]\n", o->descrp, o->val);
+  }
+}
+
+static int lglstrhasprefix (const char * str, const char * prefix) {
+  const char * p, * q;
+  for (p = str, q = prefix; *q && *p == *q; p++, q++)
+    ;
+  return !*q;
+}
+
+static int lglignopt (const char * name) {
+  if (!strcmp (name, "abstime")) return 1;
+  if (!strcmp (name, "check")) return 1;
+  if (lglstrhasprefix (name, "drup")) return 1;
+  if (!strcmp (name, "exitonabort")) return 1;
+  if (!strcmp (name, "log")) return 1;
+  if (!strcmp (name, "sleeponabort")) return 1;
+  if (!strcmp (name, "verbose")) return 1;
+  if (!strcmp (name, "witness")) return 1;
+  return 0;
+}
+
+void lglopts (LGL * lgl, const char * prefix, int ignsome) {
+  Opt * o;
+  REQINITNOTFORKED ();
+  for (o = FIRSTOPT (lgl); o <= LASTOPT (lgl); o++) {
+    if (ignsome && lglignopt (o->lng)) continue;
+    fprintf (lgl->out, "%s--%s=%d\n", prefix, o->lng, o->val);
+  }
+}
+
+void lglrgopts (LGL * lgl) {
+  Opt * o;
+  REQINITNOTFORKED ();
+  for (o = FIRSTOPT (lgl); o <= LASTOPT (lgl); o++)
+    fprintf (lgl->out, "%s %d %d %d\n", o->lng, o->val, o->min, o->max);
+}
+
+void lglpcs (LGL * lgl, int mixed) {
+  int i, printi, printl;
+  int64_t range;
+  Opt * o;
+  REQINITNOTFORKED ();
+  for (o = FIRSTOPT (lgl); o <= LASTOPT (lgl); o++) {
+    if (lglignopt (o->lng)) continue;
+    range = o->max; range -= o->min;
+    if (range >= 7 && mixed < 0) continue;
+    printi = printl = 0;
+    printf ("%s ", o->lng);
+    if (range < 7) {
+      printf ("{%d", o->min);
+      for (i = o->min + 1; i <= o->max; i++) printf (",%d", i);
+      printf ("}");
+    } else if (!mixed) {
+      printf ("[%d,%d]", o->min, o->max);
+      printi = 1;
+      printl = (o->min > 0 && range >= 100);
+    } else if (o->dflt == o->min || o->dflt == o->max) {
+      printf ("{%d,%d,%d,%d,%d}",
+        o->min,
+        (int)(o->min + (1*range + 3)/4),
+        (int)(o->min + (2*range + 3)/4),
+        (int)(o->min + (3*range + 3)/4),
+        o->max);
+    } else if (o->dflt == o->min + 1) {
+      printf ("{%d,%d,%d,%d}",
+        o->min,
+	o->dflt,
+	(int)(o->dflt + (o->max - (int64_t) o->dflt)/2),
+	o->max);
+    } else if (o->dflt + 1 == o->max) {
+      printf ("{%d,%d,%d,%d}",
+        o->min,
+	(int)(o->min + (o->dflt - (int64_t) o->min)/2),
+	o->dflt,
+	o->max);
+    } else {
+      assert (o->dflt - o->min >= 2);
+      assert (o->max - o->dflt >= 2);
+      printf ("{%d,%d,%d,%d,%d}",
+        o->min,
+	(int)(o->min + (o->dflt - (int64_t) o->min)/2),
+        o->dflt,
+        (int)(o->dflt + (o->max - (int64_t) o->min)/2),
+	o->max);
+    }
+    printf ("[%d]", o->dflt);
+    if (printi) printf ("i"); 
+    if (printl) printf ("l"); 
+    printf (" # %s\n",o->descrp);
+  }
+}
+
+int lglhasopt (LGL * lgl, const char * opt) {
+  Opt * o;
+  REQINITNOTFORKED ();
+  for (o = FIRSTOPT (lgl); o <= LASTOPT (lgl); o++)
+    if (!strcmp (o->lng, opt)) return 1;
+  return 0;
+}
+
+void * lglfirstopt (LGL * lgl) { return FIRSTOPT (lgl); }
+
+void * lglnextopt (LGL * lgl,
+		   void * current,
+		   const char **nameptr,
+		   int *valptr, int *minptr, int *maxptr) {
+  Opt * opt = current, * res = opt + 1;
+  if (res > LASTOPT (lgl)) return 0;
+  if (nameptr) *nameptr = opt->lng;
+  if (valptr) *valptr = opt->val;
+  if (minptr) *minptr = opt->min;
+  if (maxptr) *maxptr = opt->max;
+  return res;
+}
+
+void lglsetopt (LGL * lgl, const char * opt, int val) {
+  int oldval;
+  Opt * o;
+  REQINITNOTFORKED ();
+  for (o = FIRSTOPT (lgl); o <= LASTOPT (lgl); o++)
+    if (!strcmp (o->lng, opt)) break;
+  if (o > LASTOPT (lgl)) return;
+  if (val < o->min) val = o->min;
+  if (o->max < val) val = o->max;
+  oldval = o->val;
+  o->val = val;
+  if (o == &lgl->opts->plain) {
+    if (val > 0 && !oldval) lglsetplain (lgl, 1);
+    if (!val && oldval) lglsetplain (lgl, 0);
+  }
+  if (o == &lgl->opts->druplig) {
+    if (val > 0 && !oldval) lglsetdruplig (lgl, 1);
+    if (!val && oldval) lglsetdruplig (lgl, 0);
+  }
+  if (o == &lgl->opts->wait) {
+    if (val > 0 && !oldval) lglsetwait (lgl, 1);
+    if (!val && oldval) lglsetwait (lgl, 0);
+  }
+  if (o == &lgl->opts->phase && val != oldval) lgl->flushphases = 1;
+  if (lgl->state == UNUSED) TRANS (OPTSET);
+  TRAPI ("option %s %d", opt, val);
+
+  if (lgl->opts->druplig.val)
+    lglforcedruplig (lgl, 1);
+}
+
+static int lglws (int ch) {
+  return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r';
+}
+
+int lglreadopts (LGL * lgl, FILE * file) {
+  int res, ch, val, nvalbuf, noptbuf;
+  char optbuf[40], valbuf[40];
+  const char * opt;
+  res = 0;
+  for (;;) {
+    while (lglws (ch = getc (file)))
+      ;
+    if (ch == EOF) break;
+    noptbuf = 0;
+    optbuf[noptbuf++] = ch;
+    while ((ch = getc (file)) != EOF && !lglws (ch)) {
+      if (noptbuf + 1 >= sizeof optbuf) { ch = EOF; break; }
+      optbuf[noptbuf++] = ch;
+    }
+    if (ch == EOF) break;
+    assert (noptbuf < sizeof optbuf);
+    optbuf[noptbuf++] = 0;
+    assert (lglws (ch));
+    while (lglws (ch = getc (file)))
+      ;
+    if (ch == EOF) break;
+    nvalbuf = 0;
+    valbuf[nvalbuf++] = ch;
+    while ((ch = getc (file)) != EOF && !lglws (ch)) {
+      if (nvalbuf + 1 >= sizeof valbuf) break;
+      valbuf[nvalbuf++] = ch;
+    }
+    assert (nvalbuf < sizeof valbuf);
+    valbuf[nvalbuf++] = 0;
+    opt = optbuf;
+    val = atoi (valbuf);
+    lglprt (lgl, 1, "read option --%s=%d", opt, val);
+    lglsetopt (lgl, opt, val);
+    res++;
+  }
+  return res;
+}
+
+void lglsetout (LGL * lgl, FILE * out) { lgl->out = out; }
+
+void lglsetrace (LGL * lgl, FILE * trace) { lgl->trace = trace; }
+
+FILE * lglgetout (LGL * lgl) { return lgl->out; }
+
+void lglsetprefix (LGL * lgl, const char * prefix) {
+  lgldelstr (lgl, lgl->prefix);
+  lgl->prefix = lglstrdup (lgl, prefix);
+}
+
+const char * lglgetprefix (LGL * lgl) { return lgl->prefix; }
+
+static Opt * lgligetopt (LGL * lgl, const char * opt) {
+  Opt * o;
+  REQINITNOTFORKED ();
+  for (o = FIRSTOPT (lgl); o <= LASTOPT (lgl); o++)
+    if (!strcmp (o->lng, opt)) return o;
+  return 0;
+}
+
+int lglgetopt (LGL * lgl, const char * opt) {
+  Opt * o = lgligetopt (lgl, opt);
+  return o ? o->val : 0;
+}
+
+int lgldefopt (LGL * lgl, const char * opt) {
+  Opt * o = lgligetopt (lgl, opt);
+  return o ? o->dflt : 0;
+}
+
+int lglgetoptminmax (LGL * lgl, const char * opt,
+                     int * min_ptr, int * max_ptr) {
+  Opt * o = lgligetopt (lgl, opt);
+  if (!o) return 0;
+  if (min_ptr) *min_ptr = o->min;
+  if (max_ptr) *max_ptr = o->max;
+  return o->val;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void lglrszvars (LGL * lgl, int new_size) {
+  int old_size = lgl->szvars;
+  assert (lgl->nvars <= new_size);
+  RSZ (lgl->vals, old_size, new_size);
+  RSZ (lgl->i2e, old_size, new_size);
+  RSZ (lgl->doms, 2*old_size, 2*new_size);
+  RSZ (lgl->dvars, old_size, new_size);
+  RSZ (lgl->avars, old_size, new_size);
+  RSZ (lgl->qvars, old_size, new_size);
+  RSZ (lgl->jwh, 2*old_size, 2*new_size);
+  lgl->szvars = new_size;
+}
+
+static void lglenlvars (LGL * lgl) {
+  size_t old_size, new_size;
+  old_size = lgl->szvars;
+  new_size = old_size ? 2 * old_size : 4;
+  LOG (3, "enlarging internal variables from %ld to %ld", old_size, new_size);
+  lglrszvars (lgl, new_size);
+}
+
+static void lglredvars (LGL * lgl) {
+  size_t old_size, new_size;
+  old_size = lgl->szvars;
+  new_size = lgl->nvars;
+  if (new_size == old_size) return;
+  LOG (3, "reducing variables from %ld to %ld", old_size, new_size);
+  lglrszvars (lgl, new_size);
+}
+
+static int lglmax (int a, int b) { return a > b ? a : b; }
+
+/*------------------------------------------------------------------------*/
+
+static DVar * lgldvar (LGL * lgl, int lit) {
+  assert (2 <= abs (lit) && abs (lit) < lgl->nvars);
+  return lgl->dvars + abs (lit);
+}
+
+/*------------------------------------------------------------------------*/
+
+static AVar * lglavar (LGL * lgl, int lit) {
+  assert (2 <= abs (lit) && abs (lit) < lgl->nvars);
+  return lgl->avars + abs (lit);
+}
+
+static Val lglval (LGL * lgl, int lit) {
+  int idx = abs (lit);
+  Val res;
+  ASSERT (2 <= idx && idx < lgl->nvars);
+  res = lgl->vals[idx];
+  if (lit < 0) res = -res;
+  return res;
+}
+
+static int lgltrail (LGL * lgl, int lit) { return lglavar (lgl, lit)->trail; }
+
+static int lglevel2trail (LGL * lgl, int level) {
+  return lgltrail (lgl, lglctr (lgl, level)->decision);
+}
+
+
+static TD * lgltd (LGL * lgl, int lit) {
+  int pos = lgltrail (lgl, lit);
+  assert (0 <= pos && pos < lgl->szdrail);
+  return lgl->drail + pos;
+}
+
+static int lglevel (LGL * lgl, int lit) { return lgltd (lgl, lit)->level; }
+
+static int lglisfree (LGL * lgl, int lit) {
+  return lglavar (lgl, lit)->type == FREEVAR;
+}
+
+/*------------------------------------------------------------------------*/
+
+static QVar * lglqvar (LGL * lgl, int lit) {
+  assert (2 <= abs (lit) && abs (lit) < lgl->nvars);
+  return lgl->qvars + abs (lit);
+}
+
+static int * lgldpos (LGL * lgl, int lit) {
+  QVar * qv;
+  int * res;
+  qv = lglqvar (lgl, lit);
+  res = &qv->pos;
+  return res;
+}
+
+static int lglscrcmp (LGL * lgl, Flt a, Flt b) {
+  const int shift = lgl->opts->scoreshift.val;
+  a >>= shift; assert (a >= 0);
+  b >>= shift; assert (b >= 0);
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+static int lgldcmp (LGL * lgl, int l, int k) {
+  QVar * pv = lglqvar (lgl, l);
+  QVar * qv = lglqvar (lgl, k);
+  int res;
+  if (!pv->important && qv->important) return -1;
+  if (pv->important && !qv->important) return 1;
+  if ((res = lglscrcmp (lgl, pv->score, qv->score))) return res;
+  return 0;
+}
+
+#ifndef NDEBUG
+static void lglchkdsched (LGL * lgl) {
+  int * p, parent, child, ppos, cpos, size, i, tmp;
+  Stk * s = &lgl->dsched;
+  size = lglcntstk (s);
+  p = s->start;
+  for (ppos = 0; ppos < size; ppos++) {
+    parent = p[ppos];
+    assert (parent > 1);
+    tmp = *lgldpos (lgl, parent);
+    assert (ppos == tmp);
+    for (i = 0; i <= 1; i++) {
+      cpos = 2*ppos + 1 + i;
+      if (cpos >= size) continue;
+      child = p[cpos];
+      assert (child > 1);
+      tmp = *lgldpos (lgl, child);
+      assert (cpos == tmp);
+      assert (lgldcmp (lgl, parent, child) >= 0);
+    }
+  }
+}
+#endif
+
+static void lgldup (LGL * lgl, int lit) {
+  int child = lit, parent, cpos, ppos, * p, * cposptr, * pposptr;
+  Stk * s = &lgl->dsched;
+  assert (lit > 1);
+  p = s->start;
+  cposptr = lgldpos (lgl, child);
+  cpos = *cposptr;
+  assert (cpos >= 0);
+  while (cpos > 0) {
+    ppos = (cpos - 1)/2;
+    parent = p[ppos];
+    if (lgldcmp (lgl, parent, lit) >= 0) break;
+    pposptr = lgldpos (lgl, parent);
+    assert (*pposptr == ppos);
+    p[cpos] = parent;
+    *pposptr = cpos;
+    LOGDSCHED (5, parent, "down from %d", ppos);
+    cpos = ppos;
+  }
+  if (*cposptr == cpos) return;
+#ifndef NLGLOG
+  ppos = *cposptr;
+#endif
+  *cposptr = cpos;
+  p[cpos] = lit;
+  LOGDSCHED (5, lit, "up from %d", ppos);
+#ifndef NDEBUG
+  if (lgl->opts->check.val >= 2) lglchkdsched (lgl);
+#endif
+}
+
+static void lglddown (LGL * lgl, int lit) {
+  int parent = lit, child, right, ppos, cpos;
+  int * p, * pposptr, * cposptr, size;
+  Stk * s = &lgl->dsched;
+  assert (lit > 1);
+  size = lglcntstk (s);
+  p = s->start;
+  pposptr = lgldpos (lgl, parent);
+  ppos = *pposptr;
+  assert (0 <= ppos);
+  for (;;) {
+    cpos = 2*ppos + 1;
+    if (cpos >= size) break;
+    child = p[cpos];
+    if (cpos + 1 < size) {
+      right = p[cpos + 1];
+      if (lgldcmp (lgl, child, right) < 0) cpos++, child = right;
+    }
+    if (lgldcmp (lgl, child, lit) <= 0) break;
+    cposptr = lgldpos (lgl, child);
+    assert (*cposptr = cpos);
+    p[ppos] = child;
+    *cposptr = ppos;
+    LOGDSCHED (5, child, "up from %d", cpos);
+    ppos = cpos;
+  }
+  if (*pposptr == ppos) return;
+#ifndef NLGLOG
+  cpos = *pposptr;
+#endif
+  *pposptr = ppos;
+  p[ppos] = lit;
+  LOGDSCHED (5, lit, "down from %d", cpos);
+#ifndef NDEBUG
+  if (lgl->opts->check.val >= 2) lglchkdsched (lgl);
+#endif
+}
+
+static void lgldsched (LGL * lgl, int lit) {
+  int * p = lgldpos (lgl, lit);
+  Stk * s = &lgl->dsched;
+  assert (lit > 1);
+  assert (!lglqvar (lgl, lit)->enqueued);
+  assert (*p < 0);
+  *p = lglcntstk (s);
+  lglpushstk (lgl, s, lit);
+  lgldup (lgl, lit);
+  lglddown (lgl, lit);
+  LOGDSCHED (4, lit, "pushed");
+}
+
+static int lgltopdsched (LGL * lgl) {
+  assert (!lglmtstk (&lgl->dsched));
+  return lgl->dsched.start[0];
+}
+
+static int lglpopdsched (LGL * lgl) {
+  Stk * s = &lgl->dsched;
+  int res, last, cnt, * p;
+  QVar * qv;
+  assert (!lglmtstk (s));
+  res = *s->start;
+  LOGDSCHED (4, res, "popped");
+  qv = lglqvar (lgl, res);
+  assert (!qv->pos);
+  qv->pos = -1;
+  last = lglpopstk (s);
+  cnt = lglcntstk (s);
+  if (!cnt) { assert (last == res); return res; }
+  p = lgldpos (lgl, last);
+  assert (*p == cnt);
+  *p = 0;
+  *s->start = last;
+  lglddown (lgl, last);
+  return res;
+}
+
+#if 0
+static void lgldunsched (LGL * lgl, int lit) {
+  Stk * s = &lgl->dsched;
+  int last, cnt, * p, pos;
+  QVar * qv;
+  if (lit < 0) lit = -lit;
+  assert (!lglmtstk (s));
+  LOGDSCHED (4, lit, "unschedule");
+  qv = lglqvar (lgl, lit);
+  pos = qv->pos;
+  qv->pos = -1;
+  assert (lglpeek (s, pos) == lit);
+  last = lglpopstk (s);
+  cnt = lglcntstk (s);
+  if (cnt == pos) { assert (last == lit); return; }
+  p = lgldpos (lgl, last);
+  assert (*p == cnt);
+  lglpoke (s, pos, last);
+  *p = pos;
+  lgldup (lgl, last);
+  lglddown (lgl, last);
+}
+#endif
+
+static void lgldreschedule (LGL * lgl) {
+  Stk * s = &lgl->dsched;
+  int idx, i, pos, cnt = lglcntstk (s);
+  QVar * qv;
+  LOG (1, "rescheduling %d variables", cnt);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    qv= lglqvar (lgl, idx);
+    if (qv->enqueued) continue;
+    qv->pos = -1;
+  }
+  pos = 0;
+  s->top = s->start;
+  for (i = 0; i < cnt; i++) {
+    assert (pos <= i);
+    assert (s->start + pos == s->top);
+    idx = s->start[i];
+    if (abs (idx) <= 1) continue;
+    qv = lglqvar (lgl, idx);
+    assert (!qv->enqueued);
+    if (!lglisfree (lgl, idx)) { qv->pos = -1; continue; }
+    assert (qv->pos == -1);
+    s->start[pos] = idx;
+    qv->pos = pos++;
+    s->top++;
+    lgldup (lgl, idx);
+    lglddown (lgl, idx);
+  }
+  LOG (1, "new schedule with %d variables", lglcntstk (s));
+  lglfitstk (lgl, s);
+#ifndef NDEBUG
+  if (lgl->opts->check.val >= 1) lglchkdsched (lgl);
+#endif
+}
+
+static void lglenq (LGL * lgl, int idx, int updatequeuenext) {
+  QVar * qv = lglqvar (lgl, idx);
+  assert (!qv->enqueued);
+  assert (qv->pos < 0);
+  qv->enqueued = 1;
+  qv->pos = lglcntstk (&lgl->queue.stk);
+  lglpushstk (lgl, &lgl->queue.stk, idx);
+  if (updatequeuenext || lgl->queue.next < 0) lgl->queue.next = qv->pos;
+}
+static void lglrescorevars (LGL * lgl) {
+  Flt oldscinc, oldscore, newscore, oldmaxscore = 0, newmaxscore = 0;
+  int64_t newotfs;
+  QVar * qv;
+  int idx;
+  lgl->stats->rescored.vars++;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    qv = lglqvar (lgl, idx);
+    if (qv->enqueued) continue;
+    oldscore = qv->score;
+    if (oldscore > oldmaxscore) oldmaxscore = oldscore;
+    if (oldscore == FLTMIN) newscore = oldscore;
+    else if (oldscore <= lgl->minscore) newscore = lgl->minscore;
+    else {
+      newscore = lglshflt (oldscore, DEFSCOREXP);
+      if (newscore < lgl->minscore) newscore = lgl->minscore;
+    }
+    if (newscore <= lgl->minscore) {
+      assert (newscore == FLTMIN || newscore == lgl->minscore);
+      assert (!qv->enqueued);
+    } else newscore = (oldscore >> 32);
+    qv->score = newscore;
+    if (qv->score > newmaxscore) newmaxscore = qv->score;
+    LOG (3, "rescored variable %d from %s to %s",
+	 idx, lglscr2str (lgl, oldscore), lglscr2str (lgl, qv->score));
+  }
+  lgldreschedule (lgl);
+  newotfs = lgl->stats->otfs.driving + lgl->stats->otfs.restarting;
+  assert (newotfs >= lgl->limits->rescore.vars.otfs);
+  assert (lgl->stats->confs >= lgl->limits->rescore.vars.confs);
+  lglprt (lgl, 3,
+    "[rescored-vars-%d] after %lld conflicts and %lld OTFS",
+    lgl->stats->rescored.vars,
+    lgl->stats->confs - lgl->limits->rescore.vars.confs,
+    newotfs - lgl->limits->rescore.vars.otfs);
+  lgl->limits->rescore.vars.confs = lgl->stats->confs;
+  lgl->limits->rescore.vars.otfs = newotfs;
+  lglprt (lgl, 3,
+    "[rescored-vars-%d] old maximum score %s",
+    lgl->stats->rescored.vars, lglscr2str (lgl, oldmaxscore));
+  lglprt (lgl, 3,
+    "[rescored-vars-%d] new maximum score %s",
+    lgl->stats->rescored.vars, lglscr2str (lgl, newmaxscore));
+  oldscinc = lgl->scinc;
+  lgl->scinc = lglshflt (oldscinc, DEFSCOREXP);
+  assert (lgl->scinc > 0);
+  lglprt (lgl, 3,
+    "[rescored-vars-%d] old score increment %s",
+    lgl->stats->rescored.vars, lglscr2str (lgl, oldscinc));
+  lglprt (lgl, 3,
+    "[rescored-vars-%d] new score increment %s",
+    lgl->stats->rescored.vars, lglscr2str (lgl, lgl->scinc));
+}
+
+static void lglbumpscinc (LGL * lgl) {
+  Flt oldscinc;
+  if (lgl->simp && !lgl->opts->bumpsimp.val) return;
+  oldscinc = lgl->scinc;
+  lgl->scinc = lglmulflt (oldscinc, lgl->scincf);
+  LOG (3, "bumped variable score increment from %s to %s",
+       lglscr2str (lgl, oldscinc), lglscr2str (lgl, lgl->scinc));
+  if (lgl->scinc >= lgl->maxscore) {
+    LOG (2, "variable max score %s hit", lglscr2str (lgl, lgl->maxscore));
+    lglrescorevars (lgl);
+  }
+  if (!lgl->simp &&
+      !(lgl->stats->confs % lgl->opts->scincincincint.val)) {
+    int newscincinc = lgl->scincinc;
+    if (lgl->opts->scincincmode.val == 1)
+      newscincinc -= lgl->opts->scincincdelta.val;
+    else if (lgl->opts->scincincmode.val == 2)
+      newscincinc = (lgl->opts->scincincmin.val + newscincinc)/2;
+    if (newscincinc < lgl->opts->scincincmin.val)
+      newscincinc = lgl->opts->scincincmin.val;
+    if (newscincinc != lgl->scincinc) lglsetscincf (lgl, newscincinc);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglnewvar (LGL * lgl) {
+  AVar * av;
+  DVar * dv;
+  QVar * qv;
+  int res;
+  assert (!lgl->dense);
+  if (lgl->nvars == lgl->szvars) lglenlvars (lgl);
+  if (lgl->nvars) res = lgl->nvars++;
+  else res = 2, lgl->nvars = 3;
+  assert (res < lgl->szvars);
+  if (res > MAXVAR) lgldie (lgl, "more than %d variables", MAXVAR - 1);
+  assert (res <= MAXVAR);
+  assert ((RMSHFTLIT(res) >> RMSHFT) == res);
+  assert ((RMSHFTLIT(-res) >> RMSHFT) == -res);
+  LOG (3, "new internal variable %d", res);
+  dv = lgl->dvars + res;
+  CLRPTR (dv);
+  av = lgl->avars + res;
+  CLRPTR (av);
+  qv = lgl->qvars + res;
+  CLRPTR (qv);
+  qv->glag = -1;
+  qv->pos = -1;
+  lglenq (lgl, res, 1);
+  lgl->unassigned++;
+  lgl->allphaseset = 0;
+  return res;
+}
+
+static int lglsgn (int lit) { return (lit < 0) ? -1 : 1; }
+
+static Ext * lglelit2ext (LGL * lgl, int elit) {
+  int idx = abs (elit);
+  assert (0 < idx), assert (idx <= lgl->maxext);
+  return lgl->ext + idx;
+}
+
+static int lglerepr (LGL * lgl, int elit) {
+  int res, next, tmp;
+  Ext * ext;
+  assert (0 < abs (elit)), assert (abs (elit) <= lgl->maxext);
+  res = elit;
+  for (;;) {
+    ext = lglelit2ext (lgl, res);
+    if (!ext->equiv) break;
+    next = ext->repr;
+    if (res < 0) next = -next;
+    res = next;
+  }
+  tmp = elit;
+  for (;;) {
+    ext = lglelit2ext (lgl, tmp);
+    if (!ext->equiv) { assert (tmp == res); break; }
+    next = ext->repr;
+    ext->repr = (tmp < 0) ? -res : res;
+    if (tmp < 0) next = -next;
+    tmp = next;
+  }
+  assert (res);
+  return res;
+}
+
+static void lgladjext (LGL * lgl, int eidx) {
+  size_t old, new;
+  assert (eidx >= lgl->szext);
+  assert (eidx > lgl->maxext);
+  assert (lgl->szext >= lgl->maxext);
+  old = lgl->szext;
+  new = old ? 2*old : 2;
+  while (eidx >= new) new *= 2;
+  assert (eidx < new), assert (new >= lgl->szext);
+  LOG (3, "enlarging external variables from %ld to %ld", old, new);
+  RSZ (lgl->ext, old, new);
+  lgl->szext = new;
+}
+
+static void lglmelter (LGL * lgl) {
+  if (lgl->allfrozen) {
+    lglprt (lgl, 1,
+      "[melter] not all literals assumed to be frozen anymore");
+    lgl->allfrozen = 0;
+  }
+  if (lgl->limits->elm.pen || lgl->limits->blk.pen || lgl->limits->cce.pen) {
+    lglprt (lgl, 1,
+      "[melter] reset penalties: %d elm, %d blk, %d cce",
+      lgl->limits->elm.pen, lgl->limits->blk.pen, lgl->limits->cce.pen);
+    lgl->limits->elm.pen = lgl->limits->blk.pen = lgl->limits->cce.pen = 0;
+  }
+  lgl->frozen = lgl->allfrozen = 0;
+  LOG (2, "melted solver");
+}
+
+static int lglimportaux (LGL * lgl, int elit) {
+  int res, repr, eidx = abs (elit);
+  Ext * ext;
+  assert (elit);
+  if (eidx >= lgl->szext) lgladjext (lgl, eidx);
+  if (eidx > lgl->maxext) {
+    lgl->maxext = eidx;
+    lglmelter (lgl);
+  }
+  repr = lglerepr (lgl, elit);
+  ext = lglelit2ext (lgl, repr);
+  assert (!ext->equiv);
+  res = ext->repr;
+  if (!ext->imported) {
+    res = lglnewvar (lgl);
+    assert (!ext->equiv);
+    ext->repr = res;
+    ext->imported = 1;
+    assert (eidx <= INT_MAX/2);
+    lgl->i2e[res] = 2*eidx;
+    LOG (3, "mapping external variable %d to %d", eidx, res);
+    lglmelter (lgl);
+  }
+  if (repr < 0) res = -res;
+  LOG (2, "importing %d as %d", elit, res);
+  return res;
+}
+
+static int lglimport (LGL * lgl, int elit) {
+  assert (elit);
+  if (!lgl->opts->import.val) {
+    if (!lgl->maxext) (void) lglimportaux (lgl, 1);
+    while (lgl->maxext < abs (elit))
+      (void) lglimportaux (lgl, lgl->maxext + 1);
+  }
+  return lglimportaux (lgl, elit);
+}
+
+static Stk * lglidx2stk (LGL * lgl, int red, int lidx) {
+  int glue = 0;
+  Stk * s;
+  assert (red == 0 || red == REDCS);
+  assert (0 <= lidx);
+  if (!red) s = &lgl->irr;
+  else {
+    glue = lidx & GLUEMASK;
+    lidx >>= GLUESHFT;
+    assert (lidx <= MAXREDLIDX);
+    s = &lgl->red[glue];
+  }
+  return s;
+}
+
+static int * lglidx2lits (LGL * lgl, int red, int lidx) {
+  Stk * s = lglidx2stk (lgl, red, lidx);
+  int * res;
+  assert (red == 0 || red == REDCS);
+  assert (0 <= lidx);
+  res = s->start + (red ? (lidx >> GLUESHFT) : lidx);
+#ifndef NDEBUG
+  if (red && (lidx & GLUEMASK) == MAXGLUE) assert (res < s->end);
+  else assert (res < s->top);
+#endif
+  return res;
+}
+
+#ifndef NLGLOG
+static const char * lglred2str (int red) {
+  assert (!red || red == REDCS);
+  return red ? "redundant" : "irredundant";
+}
+#endif
+
+static int lgliselim (LGL * lgl, int lit) {
+  Tag tag = lglavar (lgl, lit)->type;
+  return tag == ELIMVAR;
+}
+
+static int lglexport (LGL * lgl, int ilit) {
+  int iidx, tidx, eidx, def, res;
+  iidx = abs (ilit);
+  assert (2 <= iidx), assert (iidx < lgl->nvars);
+  tidx = lgl->i2e[iidx];
+  def = tidx & 1;
+  tidx >>= 1;
+  assert (tidx);
+  eidx = tidx;
+  if (def) eidx += lgl->maxext;
+  res = eidx;
+  if (ilit < 0) res = -res;
+  return res;
+}
+
+static int * lglrsn (LGL * lgl, int lit) { return lgltd (lgl, lit)->rsn; }
+
+static int lglulit (int lit) { return 2*abs (lit) + (lit < 0); }
+
+static void lglsetdom (LGL * lgl, int lit, int dom) {
+  assert (2 <= abs (lit)  && abs (lit) < lgl->nvars);
+  assert (2 <= abs (dom)  && abs (dom) < lgl->nvars);
+  ASSERT (lglval (lgl, lit) >= 0);
+  ASSERT (lglval (lgl, dom) >= 0);
+  lgl->doms[lglulit (lit)] = dom;
+  LOG (3, "literal %d dominated by %d", lit, dom);
+}
+
+static int lglgetdom (LGL * lgl, int lit) {
+  int res;
+  assert (2 <= abs (lit)  && abs (lit) < lgl->nvars);
+  assert (lglval (lgl, lit) >= 0);
+  res = lgl->doms[lglulit (lit)];
+  return res;
+}
+
+static HTS * lglhts (LGL * lgl, int lit) {
+  return lgldvar (lgl, lit)->hts + (lit < 0);
+}
+
+static int * lglhts2wchs (LGL * lgl, HTS * hts) {
+  int * res = lgl->wchs->stk.start + hts->offset;
+  assert (res < lgl->wchs->stk.top);
+  assert (res + hts->count < lgl->wchs->stk.top);
+  assert (res + hts->count < lgl->wchs->stk.top);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+#ifndef NLGLDRUPLIG
+
+static int lgldruplig (LGL * lgl) {
+  if (!lgl->opts->druplig.val) return 0;
+  if (!lgl->druplig) {
+    lgl->druplig = druplig_minit (lgl,
+		     (druplig_malloc) lglnew,
+		     (druplig_realloc) lglrsz,
+		     (druplig_free) lgldel);
+    druplig_set_check (lgl->druplig, lgl->opts->drupligcheck.val);
+    if (!lgl->opts->drupligtrace.val) druplig_set_trace (lgl->druplig, 0);
+    else if (lgl->trace) druplig_set_trace (lgl->druplig, lgl->trace);
+    else druplig_set_trace (lgl->druplig, lgl->out);
+    druplig_set_traceorig (lgl->druplig, lgl->opts->drupligtraceorig.val);
+    if (lgl->opts->verbose.val > 0) {
+      druplig_banner (lgl->out);
+      druplig_options (lgl->druplig, lgl->out);
+    }
+  }
+  return 1;
+}
+
+static void lgldrupligreallyadd (LGL * lgl, int red) {
+  assert (!red || red == REDCS);
+  assert (lgl->opts->druplig.val);
+  assert (lgl->druplig);
+  lglstart (lgl, &lgl->times->druplig);
+  if (red) druplig_check_and_add_redundant_clause (lgl->druplig);
+  else druplig_add_original_clause (lgl->druplig);
+  lglstop (lgl);
+}
+
+static void lgldrupligreallydel (LGL * lgl) {
+  assert (lgl->opts->druplig.val);
+  assert (lgl->druplig);
+  lglstart (lgl, &lgl->times->druplig);
+  druplig_forget_clause (lgl->druplig);
+  lglstop (lgl);
+}
+
+static int lglialiased (LGL * lgl, int ilit) {
+  int elit = lglexport (lgl, ilit);
+  Ext * ext = lglelit2ext (lgl, elit);
+  return ext->aliased;
+}
+
+#endif
+
+static void lgldrupligaddclsaux (LGL * lgl, int red, const int * c) {
+#ifndef NLGLDRUPLIG
+  assert (!red || red == REDCS);
+  if (lgldruplig (lgl)) {
+    const int * p;
+    int lit;
+    for (p = c; (lit = *p); p++)
+      druplig_add_literal (lgl->druplig, lglexport (lgl, lit));
+    lgldrupligreallyadd (lgl, red);
+  }
+#else
+  (void) lgl, (void) c;
+#endif
+}
+
+static void lgldrupligaddclsarg (LGL * lgl, int red, ...) {
+#ifndef NLGLDRUPLIG
+  assert (!red || red == REDCS);
+  if (lgldruplig (lgl)) {
+    va_list ap;
+    int unit = 0;
+#ifndef NLGLOG
+    int logging = (lgl->opts->log.val > 1);
+    if (logging) lglogstart (lgl, 2, "druplig adding internal clause");
+#endif
+    va_start (ap, red);
+    for (;;) {
+      int lit = va_arg (ap, int);
+      if (!lit) break;
+      if (unit) unit = INT_MAX; else unit = lit;
+      druplig_add_literal (lgl->druplig, lglexport (lgl, lit));
+#ifndef NLGLOG
+      if (logging) fprintf (lgl->out, " %d", lit);
+#endif
+    }
+    va_end (ap);
+#ifndef NLGLOG
+    if (logging) lglogend (lgl);
+#endif
+    lgldrupligreallyadd (lgl, red);
+    if (unit && unit != INT_MAX) lgl->drupligunit = unit;
+    else lgl->drupligunit = 0;
+  }
+#else
+  (void) lgl, (void) red;
+#endif
+}
+
+static void lgldrupligaddcls (LGL * lgl, int red) {
+#ifndef NLGLDRUPLIG
+  assert (!red || red == REDCS);
+  if (lgldruplig (lgl)) {
+    int lit, size = 0;
+    const int * p;
+    for (p = lgl->clause.start; p < lgl->clause.top; p++)
+      if ((lit = *p)) {
+	druplig_add_literal (lgl->druplig, lglexport (lgl, lit));
+	size++;
+      }
+    lgldrupligreallyadd (lgl, red);
+    if (size == 1) lgl->drupligunit = lgl->clause.start[0];
+    else lgl->drupligunit = 0;
+  }
+#else
+  (void) lgl, (void) red;
+#endif
+}
+
+static void lgldrupligdelclsarg (LGL * lgl, ...) {
+#ifndef NLGLDRUPLIG
+  if (lgldruplig (lgl)) {
+    int aliased = 0;
+    va_list ap;
+#ifndef NDEBUG
+    int size = 0;
+#endif
+#ifndef NLGLOG
+    int logging = (lgl->opts->log.val > 1);
+    if (logging) lglogstart (lgl, 2, "druplig forgetting internal clause");
+#endif
+    va_start (ap, lgl);
+    for (;;) {
+      int lit = va_arg (ap, int);
+      if (!lit) break;
+      if (lglialiased (lgl, lit)) aliased = 1;
+#ifndef NDEBUG
+      size++;
+#endif
+#ifndef NLGLOG
+      if (logging) fprintf (lgl->out, " %d", lit);
+#endif
+    }
+    va_end (ap);
+#ifndef NLGLOG
+    if (logging) {
+      if (aliased) fprintf (lgl->out, " (but aliased)");
+      lglogend (lgl);
+    }
+#endif
+    assert (size > 1);
+    if (aliased) return;
+    va_start (ap, lgl);
+    for (;;) {
+      int lit = va_arg (ap, int);
+      if (!lit) break;
+      druplig_add_literal (lgl->druplig, lglexport (lgl, lit));
+    }
+    va_end (ap);
+    lgldrupligreallydel (lgl);
+  }
+#else
+  (void) lgl;
+#endif
+}
+
+static void lgldrupligdelclsaux (LGL * lgl, const int * c) {
+#ifndef NLGLDRUPLIG
+  if (lgldruplig (lgl)) {
+    const int * p;
+    int lit;
+    for (p = c; (lit = *p); p++)
+      if (lglialiased (lgl, lit)) return;
+    for (p = c; (lit = *p); p++)
+      druplig_add_literal (lgl->druplig, lglexport (lgl, lit));
+    lgldrupligreallydel (lgl);
+    assert (p - c > 1);
+  }
+#else
+  (void) lgl, (void) c;
+#endif
+}
+
+static void lgldrupligunit (LGL * lgl, int lit) {
+#ifndef NLGLDRUPLIG
+  if (!lgldruplig (lgl)) return;
+  if (lit == lgl->drupligunit) return;
+  druplig_add_literal (lgl->druplig, lglexport (lgl, lit));
+  druplig_check_and_add_redundant_clause (lgl->druplig);
+  lgl->drupligunit = lit;
+#else
+  (void) lgl, (void) lit;
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+#ifndef NDEBUG
+static int lglrgforcing (LGL * lgl, int red, int lidx) {
+  int lit, val, level, truelevel, unit;
+  const int * p, * c;
+  int * rsn, r0, r1;
+  assert (!red || red == REDCS);
+  c = lglidx2lits (lgl, red, lidx);
+  truelevel = INT_MAX;
+  unit = 0;
+  for (p = c; (lit = *p); p++) {
+    assert (abs (lit) < NOTALIT);
+    val = lglval (lgl, lit);
+    if (!val) return 0;
+    level = lglevel (lgl, lit);
+    if (val > 0) {
+      if (unit) return 0;
+      truelevel = level;
+      unit = lit;
+    } else if (level > truelevel) return 0;
+  }
+  if (!unit) return 0;
+  rsn = lglrsn (lgl, unit);
+  r0 = rsn[0];
+  if ((r0 & MASKCS) != LRGCS) return 0;
+  if ((r0 & REDCS) != red) return 0;
+  r1 = rsn[1];
+  if (r1 != lidx) return 0;
+  return 1;
+}
+#endif
+
+static void lglassign (LGL * lgl, int lit, int r0, int r1) {
+  int * p, other, other2, * c, lidx, found;
+  int idx, phase, glue, tag, dom, red, irr;
+  AVar * av = lglavar (lgl, lit);
+  TD * td;
+  LOGREASON (2, lit, r0, r1, "assign %d through", lit);
+  av->trail = lglcntstk (&lgl->trail);
+  if (av->trail >= lgl->szdrail) {
+    int newszdrail = lgl->szdrail ? 2*lgl->szdrail : 1;
+    RSZ (lgl->drail, lgl->szdrail, newszdrail);
+    lgl->szdrail = newszdrail;
+  }
+  td = lgltd (lgl, lit);
+  tag = r0 & MASKCS;
+  dom = (tag == BINCS) ? lglgetdom (lgl, -(r0 >> RMSHFT)) : lit;
+  lglsetdom (lgl, lit, dom);
+#ifndef NDEBUG
+  {
+    if (tag == BINCS || tag == TRNCS) {
+      other = r0 >> RMSHFT;
+      assert (lglval (lgl, other) < 0);
+      if (tag == TRNCS) {
+	other2 = r1;
+	assert (lglval (lgl, other2) < 0);
+      }
+    } else if (tag == LRGCS) {
+      red = r0 & REDCS;
+      lidx = r1;
+      c = lglidx2lits (lgl, red, lidx);
+      found = 0;
+      for (p = c; (other = *p); p++)
+	if (other == lit) found++;
+	else assert (lglval (lgl, other) < 0);
+      assert (found == 1);
+    } else assert (tag == DECISION || tag == UNITCS);
+  }
+  assert (!lglval (lgl, lit));
+  assert (lgl->unassigned > 0);
+  assert (!lgliselim (lgl, lit));
+#endif
+  idx = abs (lit);
+  phase = lglsgn (lit);
+  lgl->vals[idx] = phase;
+  if (!lgl->simp) {
+    lgl->stats->agility -= lgl->stats->agility >> 13;
+    if (av->phase != phase) {
+      av->phase = phase;
+      lgl->stats->agility += ((int64_t)1) << 19;
+      lgl->stats->stability.changed++;
+    }
+  }
+#ifndef NDEBUG
+  if (phase < 0) av->wasfalse = 1; else av->wasfalse = 0;
+#endif
+  td->level = lgl->level;
+  if (!lgl->level) {
+    lgldrupligunit (lgl, lit);
+    td->irr = 1;
+    if (av->type == EQUIVAR) {
+      assert (lgl->stats->equiv.current > 0);
+      lgl->stats->equiv.current--;
+      assert (lgl->stats->equiv.sum > 0);
+      lgl->stats->equiv.sum--;
+    } else {
+      assert (av->type == FREEVAR);
+      av->type = FIXEDVAR;
+    }
+    lgl->stats->fixed.sum++;
+    lgl->stats->fixed.current++;
+    lgl->stats->prgss++;
+    lgl->stats->irrprgss++;
+    td->rsn[0] = UNITCS | RMSHFTLIT (lit);
+    td->rsn[1] = 0;
+    if (lgl->cbs && lgl->cbs->units.produce.fun) {
+      LOG (2, "trying to export internal unit %d external %d\n",
+	   lgl->tid, lit, lglexport (lgl, lit));
+      lgl->stats->sync.units.produced++;
+      lgl->cbs->units.produce.fun (lgl->cbs->units.produce.state,
+                                  lglexport (lgl, lit));
+      LOG (2, "exporting internal unit %d external %d\n",
+	      lgl->tid, lit, lglexport (lgl, lit));
+    }
+  } else {
+    td->rsn[0] = r0;
+    td->rsn[1] = r1;
+    if (lgl->level == 1) {
+      assert (tag != UNITCS);
+      if (tag == DECISION) irr = 1;
+      else if ((irr = !(red = (r0 & REDCS)))) {
+	if (tag == BINCS) {
+	  other = r0 >> RMSHFT;
+	  irr = lgltd (lgl, other)->irr;
+	} else if (tag == TRNCS) {
+	  other = r0 >> RMSHFT;
+	  if ((irr = lgltd (lgl, other)->irr)) {
+	    other2 = r1;
+	    irr = lgltd (lgl, other2)->irr;
+	  }
+	} else {
+	  assert (tag == LRGCS);
+	  lidx = r1;
+	  c = lglidx2lits (lgl, red, lidx);
+	  found = 0;
+	  for (p = c; irr && (other = *p); p++)
+	    if (other == lit) found++;
+	    else irr = lgltd (lgl, other)->irr;
+	  assert (!irr || found == 1);
+	}
+      }
+    } else irr = 0;
+    td->irr = irr;
+  }
+
+  lglpushstk (lgl, &lgl->trail, lit);
+  if (!lgl->simp && !lgl->failed && (av->assumed & (1u << (lit > 0)))) {
+    LOG (2, "failed assumption %d", -lit);
+    lgl->failed = -lit;
+  }
+  lgl->unassigned--;
+  td->lrglue = 0;
+  if ((r0 & REDCS) && (r0 & MASKCS) == LRGCS) {
+    glue = r1 & GLUEMASK;
+    lgl->stats->lir[glue].forcing++;
+    assert (lgl->stats->lir[glue].forcing > 0);
+    if (lgl->level && 0 < glue && glue < MAXGLUE) {
+      lgl->lrgluereasons++;
+      assert (lgl->lrgluereasons > 0);
+      td->lrglue = 1;
+    }
+#ifndef NDEBUG
+    if (glue == MAXGLUE)
+      assert ((r1 >> GLUESHFT) + 4 < lglcntstk (&lgl->red[MAXGLUE]));
+#endif
+  }
+#ifndef NDEBUG
+  if (tag == LRGCS) {
+    lidx = r1;
+    red = r0 & REDCS;
+    if (lgl->level) assert (lglrgforcing (lgl, red, lidx));
+    else assert (((*lglrsn (lgl, lit)) & MASKCS) == UNITCS);
+  }
+#endif
+}
+
+static void lglf2rce (LGL * lgl, int lit, int other, int red) {
+  assert (lglval (lgl, other) < 0);
+  assert (!red || red == REDCS);
+  assert (!lgliselim (lgl, other));
+  lglassign (lgl, lit, (RMSHFTLIT (other) | BINCS | red), 0);
+}
+
+static void lglf3rce (LGL * lgl, int lit, int other, int other2, int red) {
+  assert (lglval (lgl, other) < 0);
+  assert (lglval (lgl, other2) < 0);
+  assert (!lgliselim (lgl, other));
+  assert (!lgliselim (lgl, other2));
+  assert (!red || red == REDCS);
+  lglassign (lgl, lit, (RMSHFTLIT (other) | TRNCS | red), other2);
+}
+
+static void lglflrce (LGL * lgl, int lit, int red, int lidx) {
+#ifndef NDEBUG
+  int * p = lglidx2lits (lgl, red, lidx), other;
+  while ((other = *p++)) {
+    assert (!lgliselim (lgl, other));
+    if (other != lit) assert (lglval (lgl, other) < 0);
+  }
+  assert (red == 0 || red == REDCS);
+#endif
+  lglassign (lgl, lit, red | LRGCS, lidx);
+}
+
+static int lgldscheduled (LGL * lgl, int lit) {
+  QVar * qv = lglqvar (lgl, lit);
+  if (qv->enqueued) return 1;
+  return qv->pos >= 0;
+}
+
+static void lglunassign (LGL * lgl, int lit) {
+  int idx = abs (lit), r0, r1, tag, lidx, glue;
+  QVar * qv;
+  TD *  td;
+  LOG (2, "unassign %d", lit);
+  assert (lglval (lgl, lit) > 0);
+  assert (lgl->vals[idx] == lglsgn (lit));
+  lgl->vals[idx] = 0;
+  lgl->unassigned++;
+  assert (lgl->unassigned > 0);
+  qv = lglqvar (lgl, idx);
+  if (qv->enqueued) assert (qv->pos >= 0);
+  else if (qv->pos < 0) lgldsched (lgl, idx);
+  td = lgltd (lgl, idx);
+  r0 = td->rsn[0];
+  if (!(r0 & REDCS)) return;
+  tag = r0 & MASKCS;
+  if (tag != LRGCS) return;
+  r1 = td->rsn[1];
+  glue = r1 & GLUEMASK;
+  if (td->lrglue) {
+    assert (lgl->lrgluereasons > 0);
+    lgl->lrgluereasons--;
+  }
+  if (glue < MAXGLUE) return;
+  lidx = r1 >> GLUESHFT;
+  LOG (2, "eagerly deleting maximum glue clause at %d", lidx);
+  lglrststk (&lgl->red[glue], lidx);
+}
+
+static Val lglifixed (LGL * lgl, int lit) {
+  int res;
+  if (!(res = lglval (lgl, lit))) return 0;
+  if (lglevel (lgl, lit) > 0) return 0;
+  return res;
+}
+
+static void lglbacktrack (LGL * lgl, int level) {
+  int lit;
+  assert (level >= 0);
+  assert (lgl->level > level);
+  if (lgl->stats->stability.level > 0) {
+    LOG (2, "cancelling restart stability computation");
+    lgl->stats->stability.level = 0;
+  }
+  LOG (2, "backtracking to level %d", level);
+  assert (level <= lgl->level);
+  assert (abs (lgl->failed) != 1 || lgl->failed == -1);
+  if (lgl->failed &&
+      lgl->failed != -1 &&
+      lglevel (lgl, lgl->failed) > level) {
+    LOG (2, "resetting failed assumption %d", lgl->failed);
+    lgl->failed = 0;
+  }
+  while (!lglmtstk (&lgl->trail)) {
+    lit = lgltopstk (&lgl->trail);
+    assert (abs (lit) > 1);
+    if (lglevel (lgl, lit) <= level) break;
+    lglunassign (lgl, lit);
+    lgl->trail.top--;
+  }
+  if (!level) {
+    assert (!lgl->lrgluereasons);
+    while (!lglmtstk (&lgl->red[MAXGLUE])) {
+      int tmp = lglpopstk (&lgl->red[MAXGLUE]);
+      assert (tmp >= NOTALIT);
+      (void) tmp;
+    }
+  }
+  if (lgl->alevel > level) {
+    LOG (2,
+	 "resetting assumption decision level to %d from %d",
+	 level, lgl->alevel);
+    lgl->alevel = level;
+    if (lgl->assumed) {
+      LOG (2,
+	   "resetting assumption queue level to 0 from %d",
+	   lgl->assumed);
+      lgl->assumed = 0;
+    }
+  }
+  lgl->level = level;
+  lglrstcontrol (lgl, level + 1);
+  assert (lglcntctk (&lgl->control) == lgl->level + 1);
+  lgl->conf.lit = 0;
+  lgl->conf.rsn[0] = lgl->conf.rsn[1] = 0;
+  lgl->next2 = lgl->next = lglcntstk (&lgl->trail);
+#ifndef NDEBUG
+  if (lgl->prevglue == MAXGLUE) {
+    lglclnstk (&lgl->prevclause);
+    lgl->prevglue = -1;
+  }
+#endif
+  LOG (2, "backtracked ");
+}
+
+static int lglmarked (LGL * lgl, int lit) {
+  int res = lglavar (lgl, lit)->mark;
+  if (lit < 0) res = -res;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void lglunit (LGL * lgl, int lit) {
+  ASSERT (!lgl->level);
+  LOG (1, "unit %d", lit);
+  lglassign (lgl, lit, RMSHFTLIT (lit) | UNITCS, 0);
+}
+
+static void lglmark (LGL * lgl, int lit) {
+  lglavar (lgl, lit)->mark = lglsgn (lit);
+}
+
+static void lglmarkunmarked (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  assert (!av->mark);
+  av->mark = lglsgn (lit);
+}
+
+static void lglunmark (LGL * lgl, int lit) { lglavar (lgl, lit)->mark = 0; }
+
+static void lglchksimpcls (LGL * lgl) {
+#ifndef NDEBUG
+  int *p, tmp, lit;
+  AVar * av;
+  for (p = lgl->clause.start; (lit = *p); p++) {
+    tmp = lglifixed (lgl, lit);
+    assert (!tmp);
+    av = lglavar (lgl, lit);
+    assert (!av->simp);
+    av->simp = 1;
+  }
+  while (p > lgl->clause.start)
+    lglavar (lgl,  *--p)->simp = 0;
+#endif
+}
+
+static int lglcval (LGL * lgl, int litorval) {
+  assert (litorval);
+  if (litorval == 1 || litorval == -1) return litorval;
+  return lglval (lgl, litorval);
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglisimpcls (LGL * lgl) {
+  int * p, * q = lgl->clause.start, lit, satisfied, val, mark;
+#ifndef NLGLOG
+  int simplified;
+#endif
+
+  satisfied = 0;
+
+#ifndef NDEBUG
+  for (p = q; (lit = *p); p++) assert (!lglmarked (lgl, lit));
+#endif
+
+  for (p = q; (lit = *p); p++) {
+    if (satisfied) continue;
+    val = lglval (lgl, lit);
+    if (val > 0) {
+      LOG (4, "literal %d satisfies clauses", lit);
+      satisfied = 1;
+      continue;
+    }
+    if (val < 0) {
+      LOG (4, "removing false literal %d", lit);
+      continue;
+    }
+    mark = lglmarked (lgl, lit);
+    if (mark > 0) {
+      LOG (4, "removing duplicated literal %d", lit);
+      continue;
+    }
+    if (mark < 0) {
+      LOG (4, "literals %d and %d occur both", -lit, lit);
+      satisfied = 1;
+      continue;
+    }
+    *q++ = lit;
+    lglmark (lgl, lit);
+  }
+
+  *q = 0;
+  lgl->clause.top = q + 1;
+#ifndef NLGLOG
+  simplified = (lgl->clause.top != q + 1);
+#endif
+
+  if (satisfied) LOG (2, "simplified clause is trivial");
+  else
+    LOGCLS (2, lgl->clause.start,
+      "%s simplified clause", simplified ? "changed" : "unchanged");
+
+  while (q > lgl->clause.start) lglunmark (lgl, *--q);
+
+  return satisfied;
+}
+
+static int lglesimpcls (LGL * lgl) {
+  int * p, * q = lgl->clause.start, lit, satisfied, val, mark;
+#if !defined(NLGLOG) || (!defined(NLGLDRUPLIG) && !defined(NDEBUG))
+  int simplified;
+#endif
+
+  satisfied = 0;
+
+#ifndef NDEBUG
+  for (p = q; (lit = *p); p++)
+    assert (abs (lit) == 1 || !lglmarked (lgl, lit));
+#endif
+
+  for (p = q; !satisfied && (lit = *p); p++) {
+    val = lglcval (lgl, lit);
+    if (val > 0) {
+      LOG (4, "literal %d satisfies clauses", lit);
+      satisfied = 1;
+      continue;
+    }
+    if (val < 0) {
+      LOG (4, "removing false literal %d", lit);
+      continue;
+    }
+    mark = lglmarked (lgl, lit);
+    if (mark > 0) {
+      LOG (4, "removing duplicated literal %d", lit);
+      continue;
+    }
+    if (mark < 0) {
+      LOG (4, "literals %d and %d occur both", -lit, lit);
+      satisfied = 1;
+      continue;
+    }
+    *q++ = lit;
+    lglmark (lgl, lit);
+  }
+
+  *q = 0;
+  lgl->clause.top = q + 1;
+#if !defined(NLGLOG) || (!defined(NLGLDRUPLIG) && !defined(NDEBUG))
+  simplified = (lgl->clause.top != q + 1);
+#endif
+
+  if (satisfied) LOG (2, "simplified clause is trivial");
+  else
+    LOGCLS (2, lgl->clause.start,
+      "%s simplified clause", simplified ? "changed" : "unchanged");
+
+  while (q > lgl->clause.start) lglunmark (lgl, *--q);
+
+#ifndef NLGLDRUPLIG
+  if (lgldruplig (lgl)) {
+    int different = (lglcntstk (&lgl->eclause) != lglcntstk (&lgl->clause));
+    assert (!simplified || different);
+    if (!satisfied && different) lgldrupligaddcls (lgl, REDCS);
+    if (satisfied || different) {
+      const int * p;
+      int elit;
+      for (p = lgl->eclause.start; (elit = *p); p++)
+	druplig_add_literal (lgl->druplig, elit);
+      lgldrupligreallydel (lgl);
+    }
+  }
+#endif
+
+  return satisfied;
+}
+
+static void lglorderclsaux (LGL * lgl, int * start) {
+  int * p, max = 0, level, lit, val;
+  for (p = start; (lit = *p); p++) {
+    if ((val = lglval (lgl, lit)) < 0) level = lglevel (lgl, lit);
+    else if (val > 0) level = INT_MAX - 1;
+    else assert (!val), level = INT_MAX;
+    if (level <= max) continue;
+    max = level;
+    *p = start[0];
+    start[0] = lit;
+  }
+}
+
+static void lglordercls (LGL * lgl) {
+  assert (lglcntstk (&lgl->clause) > 2);
+  lglorderclsaux (lgl, lgl->clause.start);
+  LOG (3, "head literal %d", lgl->clause.start[0]);
+  lglorderclsaux (lgl, lgl->clause.start  + 1);
+  LOG (3, "tail literal %d", lgl->clause.start[1]);
+  LOGCLS (3, lgl->clause.start, "ordered clause");
+}
+/*------------------------------------------------------------------------*/
+
+
+static void lglfreewch (LGL * lgl, unsigned oldoffset, int oldhcount) {
+  int ldoldhcount = lglceild (oldhcount);
+  lgl->wchs->stk.start[oldoffset] = (int) lgl->wchs->start[ldoldhcount];
+  assert (oldoffset);
+  lgl->wchs->start[ldoldhcount] = oldoffset;
+  lgl->wchs->free++;
+  assert (lgl->wchs->free > 0);
+  LOG (5, "saving watch stack at %u of size %d on free list %d",
+       oldoffset, oldhcount, ldoldhcount);
+}
+
+static void lglshrinkhts (LGL * lgl, HTS * hts, int newcount) {
+  int * p, i, oldcount = hts->count;
+  assert (newcount <= oldcount);
+  if (newcount == oldcount) return;
+  p = lglhts2wchs (lgl, hts);
+  for (i = newcount; i < oldcount; i++) p[i] = 0;
+  hts->count = newcount;
+  if (newcount) return;
+  lglfreewch (lgl, hts->offset, oldcount);
+  hts->offset = 0;
+}
+
+static ptrdiff_t lglenlwchs (LGL * lgl, HTS * hts) {
+  int oldhcount, ldoldhcount, ldnewhcount, newhcount;
+  long oldwcount, newwcount, oldwsize, newwsize;
+  int * oldwstart, * newwstart, * start;
+  unsigned oldoffset, newoffset, i, j;
+  ptrdiff_t res;
+
+  res = 0;
+
+  oldhcount = hts->count;
+  oldoffset = hts->offset;
+  newhcount = 1, ldnewhcount = 0;
+  ldoldhcount = lglfloorld (oldhcount);
+  assert (ldoldhcount < 31);
+  ldnewhcount = ldoldhcount + 1;
+  if (ldnewhcount > 30) lgldie (lgl, "watcher stack overflow");
+  newhcount = (1<<ldnewhcount);
+
+  assert (newhcount > oldhcount);
+
+  LOG (5,
+    "increasing watch stack at %u from %d to %d",
+     oldoffset, oldhcount, newhcount);
+
+  assert (!oldoffset == !oldhcount);
+
+  lgl->stats->enlwchs++;
+
+  newoffset = lgl->wchs->start[ldnewhcount];
+  start = lgl->wchs->stk.start;
+  if (newoffset != UINT_MAX) {
+    lgl->wchs->start[ldnewhcount] = start[newoffset];
+    start[newoffset] = 0;
+    assert (lgl->wchs->free > 0);
+    lgl->wchs->free--;
+    LOG (5, "reusing free watch stack at %u of size %d",
+	 newoffset, (1 << ldnewhcount));
+  } else {
+    assert (lgl->wchs->stk.start[hts->offset]);
+    assert (lgl->wchs->stk.top[-1] == (int) UINT_MAX);
+
+    oldwcount = lglcntstk (&lgl->wchs->stk);
+    newwcount = oldwcount + newhcount;
+    if (newwcount > UINT_MAX)
+      lgldie (lgl, "watcher stack memory arena overflow");
+    oldwsize = lglszstk (&lgl->wchs->stk);
+    newwsize = oldwsize;
+
+    assert (lgl->wchs->stk.top == lgl->wchs->stk.start + oldwcount);
+    assert (oldwcount > 0);
+
+    while (newwsize < newwcount) newwsize *= 2;
+    if (newwsize > UINT_MAX) {
+      assert (newwcount <= UINT_MAX);
+      newwsize = UINT_MAX;
+    }
+    if (newwsize > oldwsize) {
+      newwstart = oldwstart = lgl->wchs->stk.start;
+      RSZ (newwstart, oldwsize, newwsize);
+      LOG (3, "resized global watcher stack from %ld to %ld",
+	   oldwsize, newwsize);
+      res = newwstart - oldwstart;
+      if (res) {
+	LOG (3, "moved global watcher stack by %ld", (long) res);
+	start = lgl->wchs->stk.start = newwstart;
+      }
+      lgl->wchs->stk.end = start + newwsize;
+    }
+    lgl->wchs->stk.top = start + newwcount;
+    lgl->wchs->stk.top[-1] = (int) UINT_MAX;
+    newoffset = oldwcount - 1;
+    LOG (5,
+      "new watch stack of size %d at end of global watcher stack at %u",
+      newhcount, newoffset);
+  }
+  assert (start == lgl->wchs->stk.start);
+  assert (start[0]);
+  j = newoffset;
+  for (i = oldoffset; i < oldoffset + oldhcount; i++) {
+    start[j++] = start[i];
+    start[i] = 0;
+  }
+  while (j < newoffset + newhcount)
+    start[j++] = 0;
+  assert (start + j <= lgl->wchs->stk.top);
+  hts->offset = newoffset;
+  if (oldhcount > 0) lglfreewch (lgl, oldoffset, oldhcount);
+  return res;
+}
+
+static ptrdiff_t lglpushwch (LGL * lgl, HTS * hts, int wch) {
+  ptrdiff_t res = 0;
+  int * wchs = lglhts2wchs (lgl, hts);
+  assert (sizeof (res) == sizeof (void*));
+  assert (hts->count >= 0);
+  if (wchs[hts->count]) {
+    res = lglenlwchs (lgl, hts);
+    wchs = lglhts2wchs (lgl, hts);
+  }
+  assert (!wchs[hts->count]);
+  assert (wch != (int) UINT_MAX);
+  wchs[hts->count++] = wch;
+  lgl->stats->pshwchs++;
+  assert (lgl->stats->pshwchs > 0);
+  return res;
+}
+
+static ptrdiff_t lglwchbin (LGL * lgl, int lit, int other, int red) {
+  HTS * hts = lglhts (lgl, lit);
+  int cs = (RMSHFTLIT (other) | BINCS | red);
+  ptrdiff_t res;
+  assert (red == 0 || red == REDCS);
+  res = lglpushwch (lgl, hts, cs);
+  LOG (3, "new %s binary watch %d blit %d", lglred2str (red), lit, other);
+  return res;
+}
+
+static ptrdiff_t lglwchtrn (LGL * lgl, int a, int b, int c, int red) {
+  HTS * hts = lglhts (lgl, a);
+  int cs = (RMSHFTLIT (b) | TRNCS | red);
+  ptrdiff_t res;
+  assert (red == 0 || red == REDCS);
+  res = lglpushwch (lgl, hts, cs);
+  res += lglpushwch (lgl, hts, c);
+  LOG (3, "new %s ternary watch %d blits %d %d", lglred2str (red), a, b, c);
+  return res;
+}
+
+static ptrdiff_t lglwchlrg (LGL * lgl, int lit, int other, int red, int lidx) {
+  HTS * hts = lglhts (lgl, lit);
+  int blit = (RMSHFTLIT (other) | LRGCS | red);
+  ptrdiff_t res = 0;
+  assert (red == 0 || red == REDCS);
+  res += lglpushwch (lgl, hts, blit);
+  res += lglpushwch (lgl, hts, lidx);
+#ifndef NLGLOG
+  {
+    int * p = lglidx2lits (lgl, red, lidx);
+    if (red)
+      LOG (3,
+	   "watching %d with blit %d in red[%d][%d] %d %d %d %d%s",
+	   lit, other, (lidx & GLUEMASK), (lidx >> GLUESHFT),
+	   p[0], p[1], p[2], p[3], (p[4] ? " ..." : ""));
+    else
+      LOG (3,
+       "watching %d with blit %d in irr[%d] %d %d %d %d%s",
+       lit, other, lidx, p[0], p[1], p[2], p[3], (p[4] ? " ..." : ""));
+  }
+#endif
+  assert (sizeof (res) == sizeof (void*));
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static EVar * lglevar (LGL * lgl, int lit) {
+  int idx = abs (lit);
+  assert (1 <= idx && idx < lgl->nvars);
+  return lgl->evars + idx;
+}
+
+static int * lglepos (LGL * lgl, int lit) {
+  EVar * ev;
+  int * res;
+  ev = lglevar (lgl, lit);
+  res = &ev->pos;
+  return res;
+}
+
+static int lglecmp (LGL * lgl, int l, int k) {
+  return lglevar (lgl,k)->score - lglevar (lgl,l)->score;
+}
+
+#ifndef NDEBUG
+static void lglchkesched (LGL * lgl) {
+  int * p, parent, child, ppos, cpos, size, i, tmp;
+  Stk * s = &lgl->esched;
+  size = lglcntstk (s);
+  p = s->start;
+  for (ppos = 0; ppos < size; ppos++) {
+    parent = p[ppos];
+    tmp = *lglepos (lgl, parent);
+    assert (ppos == tmp);
+    for (i = 0; i <= 1; i++) {
+      cpos = 2*ppos + 1 + i;
+      if (cpos >= size) continue;
+      child = p[cpos];
+      tmp = *lglepos (lgl, child);
+      assert (cpos == tmp);
+      assert (lglecmp (lgl, parent, child) >= 0);
+    }
+  }
+}
+#endif
+
+static void lgleup (LGL * lgl, int lit) {
+  int child = lit, parent, cpos, ppos, * p, * cposptr, * pposptr;
+  Stk * s = &lgl->esched;
+  p = s->start;
+  cposptr = lglepos (lgl, child);
+  cpos = *cposptr;
+  assert (cpos >= 0);
+  while (cpos > 0) {
+    ppos = (cpos - 1)/2;
+    parent = p[ppos];
+    if (lglecmp (lgl, parent, lit) >= 0) break;
+    pposptr = lglepos (lgl, parent);
+    assert (*pposptr == ppos);
+    p[cpos] = parent;
+    *pposptr = cpos;
+    LOGESCHED (5, parent, "down from %d", ppos);
+    cpos = ppos;
+  }
+  if (*cposptr == cpos) return;
+#ifndef NLGLOG
+  ppos = *cposptr;
+#endif
+  *cposptr = cpos;
+  p[cpos] = lit;
+  LOGESCHED (5, lit, "up from %d", ppos);
+#ifndef NDEBUG
+  if (lgl->opts->check.val >= 2) lglchkesched (lgl);
+#endif
+}
+
+static void lgledown (LGL * lgl, int lit) {
+  int parent = lit, child, right, ppos, cpos;
+  int * p, * pposptr, * cposptr, size;
+  Stk * s = &lgl->esched;
+  size = lglcntstk (s);
+  p = s->start;
+  pposptr = lglepos (lgl, parent);
+  ppos = *pposptr;
+  assert (0 <= ppos);
+  for (;;) {
+    cpos = 2*ppos + 1;
+    if (cpos >= size) break;
+    child = p[cpos];
+    if (cpos + 1 < size) {
+      right = p[cpos + 1];
+      if (lglecmp (lgl, child, right) < 0)
+	cpos++, child = right;
+    }
+    if (lglecmp (lgl, child, lit) <= 0) break;
+    cposptr = lglepos (lgl, child);
+    assert (*cposptr = cpos);
+    p[ppos] = child;
+    *cposptr = ppos;
+    LOGESCHED (5, child, "up from %d", cpos);
+    ppos = cpos;
+  }
+  if (*pposptr == ppos) return;
+#ifndef NLGLOG
+  cpos = *pposptr;
+#endif
+  *pposptr = ppos;
+  p[ppos] = lit;
+  LOGESCHED (5, lit, "down from %d", cpos);
+#ifndef NDEBUG
+  if (lgl->opts->check.val >= 2) lglchkesched (lgl);
+#endif
+}
+
+static int lglifrozen (LGL * lgl, int ilit) {
+  int elit = lglexport (lgl, ilit);
+  Ext * ext = lglelit2ext (lgl, elit);
+  return ext->frozen || ext->tmpfrozen;
+}
+
+static void lglesched (LGL * lgl, int lit) {
+  AVar * av;
+  int * p;
+  Stk * s;
+  if (lgl->cceing) return;
+  if (lglifrozen (lgl, lit)) return;
+  if (!lglisfree (lgl, lit)) return;
+  if (lgl->donotsched) {
+    av = lglavar (lgl, lit);
+    if (lgl->eliminating && av->donotelm) return;
+    if (lgl->blocking && av->donotblk) return;
+  }
+  p = lglepos (lgl, lit);
+  s = &lgl->esched;
+  if (*p >= 0) return;
+  *p = lglcntstk (s);
+  lglpushstk (lgl, s, lit);
+  lgleup (lgl, lit);
+  lgledown (lgl, lit);
+  LOGESCHED (4, lit, "pushed");
+}
+
+/*------------------------------------------------------------------------*/
+
+static unsigned lglgcd (unsigned a, unsigned b) {
+  unsigned tmp;
+  assert (a), assert (b);
+  if (a < b) SWAP (unsigned, a, b);
+  while (b) tmp = b, b = a % b, a = tmp;
+  return a;
+}
+
+static int lglrandidxtrav (LGL * lgl, int (*fun)(LGL*,int idx)) {
+  int idx, delta, mod, prev, first, res;
+  first = mod = lglmax (lgl->nvars, 2);
+  idx = lglrand (lgl) % mod;
+  delta = lglrand (lgl) % mod;
+  if (!delta) delta++;
+  while (lglgcd (delta, mod) > 1)
+    if (++delta == mod) delta = 1;
+  res = 1;
+  LOG (2,
+    "random index traversal start %d delta %d mod %d",
+     idx, delta, mod);
+  while (res) {
+    if (idx >= 2 && !fun (lgl, idx)) res = 0;
+    else {
+      prev = idx;
+      idx += delta;
+      if (idx >= mod) idx -= mod;
+      if (idx == first) break;
+      if (first == mod) first = prev;
+    }
+  }
+  return res;
+}
+
+static int lglrem (LGL * lgl) {
+  int res = lgl->nvars;
+  if (!res) return 0;
+  assert (res >= 2);
+  res -= lgl->stats->fixed.current + 2;
+  assert (res >= 0);
+  return res;
+}
+
+static double lglpcnt (double n, double d) {
+  if (d <= 0 || !n) return 0.0;
+  return 100.0 * n / d;
+}
+
+static int lglecalc (LGL * lgl, EVar * ev) {
+  int oldscore = ev->score, o0 = ev->occ[0], o1 = ev->occ[1], newscore;
+  if (!o0 || !o1) newscore = 0;
+  else newscore = o0 + o1;
+  ev->score = newscore;
+  return newscore - oldscore;
+}
+
+static int lglocc (LGL * lgl, int lit) {
+  if (!lgl->occs) return lglhts (lgl, lit)->count;
+  return lglevar (lgl, lit)->occ[lit < 0];
+}
+
+static void lglflushtouched (LGL * lgl) {
+  int * q, idx, mt = 0, * pos = lgl->elm->touched.pos, newpos = 0;
+  Stk * touched = &lgl->elm->touched.stk;
+  const int * p;
+  for (p = q = touched->start; p < touched->top; p++) {
+    if ((idx = *p)) {
+      assert (1 < idx), assert (idx < lgl->elm->touched.nvars);
+      pos[idx] = newpos++;
+      *q++ = idx; 
+    } else mt++;
+  }
+  LOG (2, "flushed %d empty entries on touched stack kept %d", mt, newpos);
+  assert (lgl->elm->touched.mt == mt);
+  lgl->elm->touched.mt = 0;
+  touched->top = q;
+}
+
+static void lgltouch (LGL * lgl, int lit) {
+  int idx = abs (lit), * posptr, oldpos, newpos;
+  assert (lgl->elm);
+  posptr = lgl->elm->touched.pos + idx;
+  newpos = lglcntstk (&lgl->elm->touched.stk);
+  oldpos = *posptr;
+  assert (oldpos < 0 || lglpeek (&lgl->elm->touched.stk, oldpos) == idx);
+  LOG (4, "touching %d (moved to %d from %d)", idx, newpos, oldpos);
+  lglpushstk (lgl, &lgl->elm->touched.stk, idx);
+  *posptr = newpos;
+  if (oldpos >= 0) {
+    lglpoke (&lgl->elm->touched.stk, oldpos, 0);
+    lgl->elm->touched.mt++;
+    if (lgl->elm->touched.mt > lgl->elm->touched.nvars)
+      lglflushtouched (lgl);
+  }
+}
+
+static int lglpoptouched (LGL * lgl) {
+#if !defined(NDEBUG) || !defined(NLGLOG)
+  int pos;
+#endif
+  int res, * posptr;
+  assert (lgl->elm);
+  for (;;) {
+    if (lglmtstk (&lgl->elm->touched.stk)) return 0;
+    if ((res = lglpopstk (&lgl->elm->touched.stk))) break;
+    assert (lgl->elm->touched.mt > 0);
+    lgl->elm->touched.mt--;
+  }
+#if !defined(NDEBUG) || !defined(NLGLOG)
+  pos = lglcntstk (&lgl->elm->touched.stk);
+#endif
+  assert (1 < res), assert (res < lgl->elm->touched.nvars);
+  posptr = lgl->elm->touched.pos + res;
+  assert (*posptr >= 0), assert (*posptr == pos);
+  *posptr = -1;
+  LOG (4, "popped touched %d at position %d", res, pos);
+  return res;
+}
+
+static int lgltouched (LGL * lgl, int lit) {
+  int idx = abs (lit);
+  assert (1 < idx), assert (idx < lgl->elm->touched.nvars);
+  return lgl->elm->touched.pos[idx] >= 0;
+}
+
+static void lglincocc (LGL * lgl, int lit) {
+  int idx, sign, change;
+  EVar * ev;
+  if (!lgl->occs) return;
+  idx = abs (lit), sign = (lit < 0);
+  ev = lglevar (lgl, lit);
+  assert (lglisfree (lgl, lit));
+  ev->occ[sign] += 1;
+  assert (ev->occ[sign] > 0);
+  change = lglecalc (lgl, ev);
+  LOG (3,
+    "inc occ of %d now occs[%d] = %d %d",
+    lit, idx, ev->occ[0], ev->occ[1]);
+  if (ev->pos < 0) lglesched (lgl, idx);
+  else if (change > 0) lgledown (lgl, idx);
+  else if (change < 0) lgleup (lgl, idx);
+  if (lgl->touching) lgltouch (lgl, lit);
+}
+
+static int lglisact (int act) { return NOTALIT <= act && act < REMOVED-1; }
+
+static int lglrescoreglue (LGL * lgl, int glue) {
+  int * c, * p, oldact, newact, count = 0;
+  const int retireint = lgl->opts->retireint.val;
+  Stk * lir = lgl->red + glue;
+  for (c = lir->start; c < lir->top; c = p + 1) {
+    oldact = *c;
+    if (oldact == REMOVED) {
+      for (p = c + 1; p < lir->top && *p == REMOVED; p++)
+	;
+      assert (p >= lir->top || *p < NOTALIT || lglisact (*p));
+      p--;
+    } else if (NOTALIT + retireint < oldact) {
+      assert (NOTALIT + retireint <= oldact && oldact <= REMOVED - 1);
+      newact = (oldact - NOTALIT - retireint + 1) / 2;
+      newact += NOTALIT + retireint;
+      assert (newact < REMOVED);
+      *c++ = newact;
+      LOGCLS (5, c,
+        "rescoring activity from %d to %d of clause",
+	oldact - NOTALIT, newact - NOTALIT);
+      for (p = c; *p; p++)
+	;
+      count++;
+    } else {
+      for (p = c + 1; *p; p++)
+	;
+    }
+  }
+  return count;
+}
+
+static void lglrescoreclauses (LGL * lgl) {
+  int glue, count = 0;
+  lgl->stats->rescored.clauses++;
+  for (glue = 0; glue < MAXGLUE; glue++)
+    count += lglrescoreglue (lgl, glue);
+  lglprt (lgl, 3,
+    "[rescored-clauses-%d] rescored activity of %d clauses",
+    lgl->stats->rescored.clauses, count);
+}
+
+static void lglchkirrstats (LGL * lgl) {
+#if  0
+  int idx, sign, lit, blit, tag, red, other, other2, clauses, lits;
+  const int * p, * w, * eow, * c, * top;
+  HTS * hts;
+  clauses = lits = 0;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	red = blit & REDCS;
+	if (red) continue;
+	if (tag == BINCS) {
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  lits += 2;
+	} else if (tag == TRNCS) {
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	  lits += 3;
+	} else continue;
+	clauses++;
+      }
+    }
+  top = lgl->irr.top;
+  for (c = lgl->irr.start; c < top; c = p + 1) {
+    if (*(p = c) >= NOTALIT) continue;
+    while (*++p)
+      ;
+    lits += p - c;
+    clauses++;
+  }
+  assert (clauses == lgl->stats->irr.clauses.cur);
+  assert (lits == lgl->stats->irr.lits.cur);
+#else
+  (void) lgl;
+#endif
+}
+
+static void lglincirr (LGL * lgl, int size) {
+  if (size < 2) return;
+  lgl->stats->irr.clauses.cur++;
+  assert (lgl->stats->irr.clauses.cur > 0);
+  if (lgl->stats->irr.clauses.cur > lgl->stats->irr.clauses.max)
+    lgl->stats->irr.clauses.max = lgl->stats->irr.clauses.cur;
+  lgl->stats->irr.lits.cur += size;
+  assert (lgl->stats->irr.lits.cur >= size);
+  if (lgl->stats->irr.lits.cur > lgl->stats->irr.lits.max)
+    lgl->stats->irr.lits.max = lgl->stats->irr.lits.cur;
+  lgl->stats->irrprgss++;
+}
+
+static void lgldecirr (LGL * lgl, int size) {
+  assert (size >= 2);
+  assert (lgl->stats->irr.clauses.cur > 0);
+  lgl->stats->irr.clauses.cur--;
+  assert (lgl->stats->irr.lits.cur >= size);
+  lgl->stats->irr.lits.cur -= size;
+  assert (!lgl->stats->irr.clauses.cur == !lgl->stats->irr.lits.cur);
+  lgl->stats->irrprgss++;
+}
+
+static void lglincglag (LGL * lgl) {
+  if (lgl->glag == MAXGLAG) {
+    int idx;
+    for (idx = 2; idx < lgl->nvars; idx++)
+      lglqvar (lgl, idx)->glag = -1;
+    lgl->glag = 0;
+  } else lgl->glag++;
+  LOG (4, "new glue flag %d", lgl->glag);
+}
+
+static int lglaged (LGL * lgl, int lit) {
+  int level = lglevel (lgl, lit);
+  QVar * qv;
+  if (!level++) return 1;
+  assert (2 <= level), assert (level < lgl->nvars);
+  qv = lglqvar (lgl, level);
+  assert (qv->glag <= lgl->glag);
+  if (qv->glag >= lgl->glag) return 1;
+  assert (0 <= lgl->glag), assert (lgl->glag <= MAXGLAG);
+  qv->glag = lgl->glag;
+  assert (0 <= qv->glag);
+  return 0;
+}
+
+static const int lglar1scalegluetab[POW2GLUE] =
+{
+// 0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15
+   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+};
+
+static const int lglar2scalegluetab[POW2GLUE] =
+{
+// 0  1  2  3   4   5   6   7   8   9  10  11  12  13   14   15
+   0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105, 120
+};
+
+static const int lglsqrtscalegluetab[POW2GLUE] = 
+{
+// 0  1  2  3   4   5   6   7   8   9  10  11    12   13   14   15
+   0, 1, 2, 5, 10, 17, 26, 37, 50, 65, 82, 101, 122, 145, 170, 197
+};
+
+static const int lglsqrtldscalegluetab[POW2GLUE] =
+{
+// 0  1  2  3   4   5   6   7   8   9  10   11   12   13    14    15
+   0, 1, 2, 5, 10, 17, 26, 37, 50, 65, 82, 122, 226, 530, 1522, 5042
+};
+
+static const int lglldscalegluetab[POW2GLUE] =
+{
+// 0  1  2  3   4   5   6    7    8    9    10    11    12    13     14     15
+   0, 1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768
+};
+
+
+static int lglsearchscaleglue (int unscaled, const int * tab) {
+  int res;
+  for (res = 0; res < POW2GLUE && tab[res + 1] <= unscaled; res++)
+    ;
+  return res;
+}
+
+#define LGLSEARCHSCALEGLUE(NAME,GLUE) \
+  lglsearchscaleglue (GLUE, lgl ## NAME ## scalegluetab)
+
+static int lglunboundedscaleglue (LGL * lgl, int origlue) {
+  int res, red;
+  assert (0 <= origlue);
+  if (origlue <= lgl->opts->gluekeep.val) res = 0;
+  else {
+    red = origlue - lgl->opts->gluekeep.val;
+    assert (red >= 1);
+    switch (lgl->opts->gluescale.val) {
+      default:
+      case 1: res = LGLSEARCHSCALEGLUE (ar1, red); break;
+      case 2: res = LGLSEARCHSCALEGLUE (ar2, red); break;
+      case 3: res = LGLSEARCHSCALEGLUE (sqrt, red); break;
+      case 4: res = LGLSEARCHSCALEGLUE (sqrtld, red); break;
+      case 5: res = LGLSEARCHSCALEGLUE (ld, red); break;
+    }
+    assert (res > 0);
+    if (res > MAXGLUE) res = MAXGLUE;
+  }
+  assert (0 <= res), assert (res <= MAXGLUE);
+  return res;
+}
+
+static int lglscaleglue (LGL * lgl, int origlue) {
+  int res = lglunboundedscaleglue (lgl, origlue);
+  if (lgl->opts->maxscaledglue.val <= res)
+    res = MAXGLUE;
+  assert (0 <= res), assert (res <= MAXGLUE);
+  return res;
+}
+
+static int lglunscaleglue (LGL * lgl, int scaledglue) {
+  int res = 0;
+  assert (0 <= scaledglue), assert (scaledglue <= MAXGLUE);
+  if (!scaledglue) res = 0;
+  else {
+    switch (lgl->opts->gluescale.val) {
+      default:
+      case 1: res = lglar1scalegluetab[scaledglue]; break;
+      case 2: res = lglar2scalegluetab[scaledglue]; break;
+      case 3: res = lglsqrtldscalegluetab[scaledglue]; break;
+      case 4: res = lglsqrtldscalegluetab[scaledglue]; break;
+      case 5: res = lglldscalegluetab[scaledglue]; break;
+    }
+    res += lgl->opts->gluekeep.val;
+  }
+  assert (lglunboundedscaleglue (lgl, res) == scaledglue);
+  assert (!res || lglunboundedscaleglue (lgl, res - 1) == scaledglue - 1);
+  return res;
+}
+
+static int lglcheckgluereduced (LGL * lgl, int lidx,
+                               int gluelim, int sizelim,
+			       int * newunscaledglueptr) {
+  int oldscaledglue, newunscaledglue, newscaledglue, lit, pos, size;
+  const int * c;
+  Stk * lir;
+  oldscaledglue = (lidx & GLUEMASK);
+  if (!oldscaledglue) return 0;
+  if (oldscaledglue >= MAXGLUE) return 0;
+  lglincglag (lgl);
+  lir = lgl->red + oldscaledglue;
+  pos = lidx >> GLUESHFT;
+  assert (pos > 0);
+  c = lir->start + pos;
+  if (c > lir->top) return 0;
+  if (c[0] >= REMOVED) return 0;
+  assert (lir->start < c && c < lir->end);
+  size = newunscaledglue = 0;
+  while ((lit = c[size])) {
+    if (++size > sizelim) return 0;
+    if (lglaged (lgl, lit)) continue;
+    if (++newunscaledglue > gluelim) return 0;
+  }
+  newscaledglue = lglscaleglue (lgl, newunscaledglue);
+  if (oldscaledglue <= newscaledglue) return 0;
+  LOG (4,
+    "old scaled glue %d size %d clause at %d has new scaled glue %d"
+    " (unscaled %d)",
+    oldscaledglue, size, pos, newscaledglue, newunscaledglue);
+  if (newunscaledglueptr) *newunscaledglueptr = newunscaledglue;
+  return 1;
+}
+
+static void lglcheckpromotion (LGL * lgl, int lidx) {
+  const int gluelim = lgl->opts->promotegluelim.val;
+  int glue;
+  if (!lgl->opts->promote.val) return;
+  glue = lidx & GLUEMASK;
+  if (!glue) return;
+  if (glue >= MAXGLUE) return;
+  if (!lglcheckgluereduced (lgl, lidx, gluelim, INT_MAX, 0)) return;
+  LOG (4,
+    "saving clause idx red[%d][%d] on promotion stack",
+    glue, (lidx >> GLUESHFT));
+  lglpushstk (lgl, &lgl->promote, lidx);
+  lgl->stats->promote.tried++;
+}
+
+static void lglbumplidx (LGL * lgl, int lidx) {
+  int glue = (lidx & GLUEMASK), * c, *ap, act, pos;
+  const int retirenb = lgl->opts->retirenb.val;
+  const int retireint = lgl->opts->retireint.val;
+  Stk * lir = lgl->red + glue;
+  if (lgl->simp && !lgl->opts->bumpsimp.val) return;
+  if (glue >= MAXGLUE) return;
+  pos = lidx >> GLUESHFT;
+  c = lir->start + pos;
+  assert (lir->start < c && c < lir->end);
+  ap = c - 1;
+  act = *ap;
+  if (act < REMOVED - 1) {
+    LGLCHKACT (act);
+    act += 1;
+    if (retirenb && act < NOTALIT + retireint) act = NOTALIT + retireint;
+    LGLCHKACT (act);
+    *ap = act;
+  }
+  LOGCLS (4, c, "bumped activity to %d of glue %d clause", act-NOTALIT, glue);
+  lgl->stats->lir[glue].resolved++;
+  assert (lgl->stats->lir[glue].resolved > 0);
+  if (act >= REMOVED - 1) lglrescoreclauses (lgl);
+}
+
+static void lglbumpnupdatelidx (LGL * lgl, int lidx) {
+  lglbumplidx (lgl, lidx);
+  lglcheckpromotion (lgl, lidx);
+}
+
+static void lglincjwh (LGL * lgl, int lit, Flt inc) {
+  int ulit = lglulit (lit);
+  Flt old = lgl->jwh[ulit];
+  Flt new = lgladdflt (old, inc);
+  lgl->jwh[ulit] = new;
+}
+
+static void lglmtaux (LGL * lgl, int red) {
+  assert (!red || red == REDCS);
+  if (lgl->mt) return;
+  LOG (1, "adding empty clause");
+  lgl->mt = 1;
+  lgldrupligaddclsarg (lgl, red, 0);
+}
+
+static void lglmt (LGL * lgl) { lglmtaux (lgl, REDCS); }
+
+static int lgladdcls (LGL * lgl, int red, int origlue, int force) {
+  int size, lit, other, other2, * p, lidx, unit, blit;
+  int64_t * maxbytesptr, bytes;
+  int scaledglue, prevglue;
+  Flt inc;
+  Val val;
+  Stk * w;
+  lgl->stats->prgss++;
+  if (lgl->eliminating) {
+    size = lglcntstk (&lgl->clause);
+    ADDSTEPS (elm.steps, size);
+  }
+  if (!red) lgl->stats->irrprgss++;
+  assert (!lglmtstk (&lgl->clause));
+  assert (!lgl->clause.top[-1]);
+  if (force) lglchksimpcls (lgl);
+  size = lglcntstk (&lgl->clause) - 1;
+  if (!red) lglincirr (lgl, size);
+  else if (size == 2) lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+  else if (size == 3) lgl->stats->red.trn++, assert (lgl->stats->red.trn > 0);
+  assert (size >= 0);
+  if (!size) {
+    lglmtaux (lgl, red);
+    return 0;
+  }
+  lit = lgl->clause.start[0];
+  if (size == 1) {
+    assert (lglval (lgl, lit) >= 0);
+    if (!lglval (lgl, lit)) lglunit (lgl, lit);
+    return 0;
+  }
+  inc = lglflt (-size, 1);
+  other = lgl->clause.start[1];
+  if (size == 2) {
+    lglwchbin (lgl, lit, other, red);
+    lglwchbin (lgl, other, lit, red);
+    // if (red) 
+    {
+      if (force && lglval (lgl, lit) < 0) lglf2rce (lgl, other, lit, red);
+      if (force && lglval (lgl, other) < 0) lglf2rce (lgl, lit, other, red);
+    }
+    if (!red && lgl->dense) {
+      assert (!red);
+      lglincocc (lgl, lit);
+      lglincocc (lgl, other);
+    }
+    if (!red) lglincjwh (lgl, lit, inc), lglincjwh (lgl, other, inc);
+    return 0;
+  }
+  lglordercls (lgl);
+  lit = lgl->clause.start[0];
+  other = lgl->clause.start[1];
+  if (size == 3) {
+    other2 = lgl->clause.start[2];
+    lglwchtrn (lgl, lit, other, other2, red);
+    lglwchtrn (lgl, other, lit, other2, red);
+    lglwchtrn (lgl, other2, lit, other, red);
+    // if (red)
+    {
+      if (force && lglval (lgl, lit) < 0 && lglval (lgl, other) < 0)
+	lglf3rce (lgl, other2, lit, other, red);
+      if (force && lglval (lgl, lit) < 0 && lglval (lgl, other2) < 0)
+	lglf3rce (lgl, other, lit, other2, red);
+      if (force && lglval (lgl, other) < 0 && lglval (lgl, other2) < 0)
+	lglf3rce (lgl, lit, other, other2, red);
+    } 
+    if (!red && lgl->dense) {
+      assert (!red);
+      lglincocc (lgl, lit);
+      lglincocc (lgl, other);
+      lglincocc (lgl, other2);
+    }
+    if (!red) lglincjwh (lgl, lit, inc),
+              lglincjwh (lgl, other, inc),
+	      lglincjwh (lgl, other2, inc);
+    return 0;
+  }
+  assert (size > 3);
+  if (red) {
+    scaledglue = lglscaleglue (lgl, origlue);
+    if (scaledglue == MAXGLUE &&
+	lgl->opts->keepmaxglue.val &&
+  !(lgl->stats->clauses.maxglue.count % lgl->opts->keepmaxglueint.val)) {
+      lgl->stats->clauses.maxglue.count++;
+      lgl->stats->clauses.maxglue.kept++;
+      scaledglue = MAXGLUE-1;
+      LOG (2,
+        "reducing maximum glue %d to %d to keep clause", 
+	MAXGLUE, scaledglue);
+    }
+    lgl->stats->clauses.scglue += scaledglue;
+    if (scaledglue == MAXGLUE) {
+      lgl->stats->clauses.maxglue.count++;
+#ifndef NDEBUG
+      lglclnstk (&lgl->prevclause);
+      lgl->prevglue = -1;
+#endif
+    } else lgl->stats->clauses.nonmaxglue++;
+    w = lgl->red + scaledglue;
+    lidx = lglcntstk (w) + 1;
+    if (lidx > MAXREDLIDX) {
+      prevglue = scaledglue;
+      if (lidx > MAXREDLIDX) {
+	scaledglue = prevglue;
+	while (scaledglue + 1 < MAXGLUE && lidx > MAXREDLIDX) {
+	  w = lgl->red + ++scaledglue;
+	  lidx = lglcntstk (w) + 1;
+	}
+      }
+      if (lidx > MAXREDLIDX) {
+	scaledglue = prevglue;
+	while (scaledglue > 0 && lidx > MAXREDLIDX) {
+	  w = lgl->red + --scaledglue;
+	  lidx = lglcntstk (w) + 1;
+	}
+      }
+      if (lidx > MAXREDLIDX && scaledglue < MAXGLUE) {
+	w = lgl->red + (scaledglue = MAXGLUE);
+	lidx = lglcntstk (w) + 1;
+      }
+      if (lidx > MAXREDLIDX && scaledglue == MAXGLUE) {
+	lglbacktrack (lgl, 0);
+	lidx = lglcntstk (w);
+	assert (!lidx);
+      }
+      if (lidx > MAXREDLIDX)
+	lgldie (lgl, "number of redundant large clause literals exhausted");
+    }
+    assert (w == lgl->red + scaledglue);
+    maxbytesptr = &lgl->stats->lir[scaledglue].maxbytes;
+    lglpushstk (lgl, w, NOTALIT);
+    assert (lidx == lglcntstk (w));
+    lidx <<= GLUESHFT;
+    assert (0 <= lidx);
+    lidx |= scaledglue;
+    if (scaledglue < MAXGLUE) {
+      lgl->stats->lir[scaledglue].clauses++;
+      assert (lgl->stats->lir[scaledglue].clauses > 0);
+    }
+    lgl->stats->lir[scaledglue].added++;
+    assert (lgl->stats->lir[scaledglue].added > 0);
+  } else {
+    w = &lgl->irr;
+    maxbytesptr = &lgl->stats->irr.maxbytes;
+    lidx = lglcntstk (w);
+    scaledglue = 0;
+    if (lidx <= 0 && !lglmtstk (w))
+      lgldie (lgl, "number of irredundant large clause literals exhausted");
+  }
+  for (p = lgl->clause.start; (other2 = *p); p++)
+    lglpushstk (lgl, w, other2), lglincjwh (lgl, other2, inc);
+  lglpushstk (lgl, w, 0);
+  bytes = sizeof (int) * (int64_t) lglcntstk (w);
+  if (bytes > *maxbytesptr) *maxbytesptr = bytes;
+  // if (red)
+  {
+    unit = 0;
+    for (p = lgl->clause.start; (other2 = *p); p++) {
+      val = lglval (lgl, other2);
+      assert (!force || val <= 0);
+      if (val < 0) continue;
+      if (unit) unit = INT_MAX;
+      else unit = other2;
+    }
+    if (force && unit && unit != INT_MAX) lglflrce (lgl, unit, red, lidx);
+  }
+  assert (red == 0 || red == REDCS);
+  if (!red || (red && scaledglue < MAXGLUE)) {
+    (void) lglwchlrg (lgl, lit, other, red, lidx);
+    (void) lglwchlrg (lgl, other, lit, red, lidx);
+  }
+  if (red && scaledglue != MAXGLUE) {
+    // lglbumplidx (lgl, lidx); 		// TODO why was this here?
+    lgl->stats->red.lrg++;
+  }
+  if (!red && lgl->dense) {
+    if (lidx > MAXIRRLIDX)
+      lgldie (lgl, "number of irredundant large clause literals exhausted");
+    blit = (lidx << RMSHFT) | OCCS;
+    for (p = lgl->clause.start; (other2 = *p); p++) {
+      lglincocc (lgl, other2);
+      (void) lglpushwch (lgl, lglhts (lgl, other2), blit);
+    }
+  }
+  lglchkirrstats (lgl);
+  return lidx;
+}
+
+static void lgliadd (LGL * lgl, int ilit) {
+  int size;
+#ifndef NLGLOG
+  if (lglmtstk (&lgl->clause)) LOG (4, "opening irredundant clause");
+#endif
+  assert (abs (ilit) < 2 || abs (ilit) < lgl->nvars);
+  lglpushstk (lgl, &lgl->clause, ilit);
+  if (ilit) {
+    LOG (4, "added literal %d", ilit);
+  } else {
+    LOG (4, "closing irredundant clause");
+    LOGCLS (3, lgl->eclause.start, "external irredundant clause");
+    LOGCLS (3, lgl->clause.start, "internal unsimplified irredundant clause");
+#ifndef NLGLDRUPLIG
+    if (lgldruplig (lgl)) {
+      const int * p;
+      int other;
+      for (p = lgl->eclause.start; (other = *p); p++)
+	druplig_add_literal (lgl->druplig, other);
+      lgldrupligreallyadd (lgl, 0);
+    }
+#endif
+    if (!lglesimpcls (lgl)) {
+      lgladdcls (lgl, 0, 0, 1);
+      lgl->stats->irr.clauses.add++;
+      size = lglcntstk (&lgl->clause) - 1;
+      assert (size >= 0);
+      lgl->stats->irr.lits.add += size;
+    }
+    lglclnstk (&lgl->clause);
+    lglclnstk (&lgl->eclause);
+  }
+}
+
+static void lgleunassignall (LGL * lgl) {
+  int eidx;
+  for (eidx = 1; eidx <= lgl->maxext; eidx++)
+    lglelit2ext (lgl, eidx)->val = 0;
+}
+
+static void lglchkeassumeclean (LGL * lgl) {
+  assert (lglmtstk (&lgl->eassume));
+#ifndef NDEBUG
+  int eidx;
+  for (eidx = 1; eidx <= lgl->maxext; eidx++) {
+    Ext * ext = lglelit2ext (lgl, eidx);
+    assert (!ext->assumed);
+    assert (!ext->failed);
+  }
+#endif
+}
+
+static void lglchkassumeclean (LGL * lgl) {
+  assert (!lgl->failed);
+  assert (!lgl->assumed);
+  assert (lglmtstk (&lgl->assume));
+#ifndef NDEBUG
+  if (lgl->opts->check.val >= 1) {
+    int idx;
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      AVar * av = lglavar (lgl, idx);
+      assert (!av->assumed);
+      assert (!av->failed);
+    }
+  }
+#endif
+}
+
+static void lglreset (LGL * lgl) {
+  int elit, ilit, erepr;
+  Ext * ext, * rext;
+  unsigned bit;
+  AVar * av;
+  if (lgl->state == RESET) return;
+  if (lgl->state <= USED) return;
+  assert (lgl->state & (UNKNOWN|SATISFIED|EXTENDED|UNSATISFIED|FAILED|LOOKED));
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  if (!lglmtstk (&lgl->eassume)) {
+    LOG (2, "resetting %d external assumptions", lglcntstk (&lgl->eassume));
+    while (!lglmtstk (&lgl->eassume)) {
+      elit = lglpopstk (&lgl->eassume);
+      ext = lglelit2ext (lgl, elit);
+      ext->assumed = 0;
+      if (ext->failed) {
+	ext->failed = 0;
+	erepr = lglerepr (lgl, elit);
+	if (erepr != elit) {
+	  rext = lglelit2ext (lgl, erepr);
+	  rext->failed = 0;
+	}
+      }
+    }
+  }
+  lglchkeassumeclean (lgl);
+  if (!lglmtstk (&lgl->assume)) {
+    LOG (2, "resetting %d internal assumptions", lglcntstk (&lgl->assume));
+    while (!lglmtstk (&lgl->assume)) {
+      ilit = lglpopstk (&lgl->assume);
+      av = lglavar (lgl, ilit);
+      bit = (1u << (ilit < 0));
+      assert (av->assumed & bit);
+      av->assumed &= ~bit;
+      av->failed &= ~bit;
+    }
+  }
+  if (lgl->failed) {
+    LOG (2, "resetting internal failed assumption %d", lgl->failed);
+    lgl->failed = 0;
+  }
+  if (lgl->assumed) {
+    LOG (2, "resetting assumption queue level to 0 from %d", lgl->assumed);
+    lgl->assumed = 0;
+  }
+  lglchkassumeclean (lgl);
+  lgleunassignall (lgl);
+  if (lgl->cbs && lgl->cbs->term.done) {
+    LOG (2, "resetting forced termination done flag");
+    lgl->cbs->term.done = 0;
+  }
+  TRANS (RESET);
+}
+
+static void lgluse (LGL * lgl) {
+  if (lgl->state >= USED) return;
+  assert (lgl->state == UNUSED || lgl->state == OPTSET);
+  TRANS (USED);
+}
+
+static void lglupdatealiased (LGL * lgl, int elit) {
+  Ext * ext;
+  int erepr;
+  assert (elit), assert (elit != INT_MIN);
+  if (abs (elit) > lgl->maxext) return;
+  erepr = lglerepr (lgl, elit);
+  if (erepr == elit) return;
+  ext = lglelit2ext (lgl, erepr);
+  if (ext->aliased) return;
+  LOG (4,
+    "external literal %d aliased by external literal %d",
+    erepr, elit);
+  ext->aliased = 1;
+}
+
+static void lgleadd (LGL * lgl, int elit) {
+  int ilit;
+  lglreset (lgl);
+  if (elit) {
+    lglupdatealiased (lgl, elit);
+    ilit = lglimport (lgl, elit);
+    LOG (4, "adding external literal %d as %d", elit, ilit);
+  } else {
+    ilit = 0;
+    LOG (4, "closing external clause");
+  }
+  lglpushstk (lgl, &lgl->eclause, elit);
+  lgliadd (lgl, ilit);
+#ifndef NCHKSOL
+  lglpushstk (lgl, &lgl->orig, elit);
+#endif
+}
+
+void lgladd (LGL * lgl, int elit) {
+  int eidx = abs (elit);
+  Ext * ext;
+  REQINITNOTFORKED ();
+  TRAPI ("add %d", elit);
+  if (0 < eidx && eidx <= lgl->maxext) {
+    ext = lglelit2ext (lgl, elit);
+    ABORTIF (ext->melted, "adding melted literal %d", elit);
+  }
+  lgl->stats->calls.add++;
+  lgleadd (lgl, elit);
+  lgluse (lgl);
+  if (lgl->clone) lgladd (lgl->clone, elit);
+}
+
+static void lglisetphase (LGL * lgl, int lit, int phase) {
+  AVar * av;
+  if (lit < 0) lit = -lit, phase = -phase;
+  av = lglavar (lgl, lit);
+  av->fase = phase;
+  LOG (2, "setting phase of internal literal %d to %d", lit, phase);
+}
+
+static void lglesetphase (LGL * lgl, int elit, int phase) {
+  int ilit = lglimport (lgl, elit);
+  if (abs (ilit) >= 2) {
+    LOG (2, "setting phase of external literal %d to %d", elit, phase);
+    lglisetphase (lgl, ilit, phase);
+  } else LOG (2, "setting phase of external literal %d skipped", elit);
+}
+
+void lglsetphase (LGL * lgl, int elit) {
+  REQINITNOTFORKED ();
+  TRAPI ("setphase %d", elit);
+  ABORTIF (!elit, "invalid literal argument");
+  if (elit < 0) lglesetphase (lgl, -elit, -1);
+  else lglesetphase (lgl, elit, 1);
+  if (lgl->clone) lglsetphase (lgl->clone, elit);
+}
+
+void lglresetphase (LGL * lgl, int elit) {
+  REQINITNOTFORKED ();
+  TRAPI ("resetphase %d", elit);
+  ABORTIF (!elit, "invalid literal argument");
+  lglesetphase (lgl, elit, 0);
+  if (lgl->clone) lglresetphase (lgl->clone, elit);
+}
+
+static void lglisetimportant (LGL * lgl, int lit) {
+  QVar * qv;
+  qv = lglqvar (lgl, lit);
+  qv->important = 1;
+  LOG (2, "setting variable %d to be important", abs (lit));
+}
+
+static void lglesetimportant (LGL * lgl, int elit) {
+  int ilit = lglimport (lgl, elit);
+  if (abs (ilit) >= 2) {
+    LOG (2, "setting external literal %d to be important", elit);
+    lglisetimportant (lgl, ilit);
+  } else
+    LOG (2, "setting external literal %d to be important skipped", elit);
+}
+
+void lglsetimportant (LGL * lgl, int elit) {
+  REQINITNOTFORKED ();
+  TRAPI ("setimportant %d", elit);
+  ABORTIF (!elit, "invalid literal argument");
+  if (elit < 0) lglesetphase (lgl, -elit, -1);
+  else lglesetimportant (lgl, elit);
+  if (lgl->clone) lglsetimportant (lgl->clone, elit);
+}
+
+static void lgleassume (LGL * lgl, int elit) {
+  int ilit, val;
+  unsigned bit;
+  AVar * av;
+  Ext * ext;
+  lglreset (lgl);
+  ilit = lglimport (lgl, elit);
+  LOG (2, "assuming external literal %d", elit);
+  bit = 1u << (elit < 0);
+  ext = lglelit2ext (lgl, elit);
+  if (!(ext->assumed & bit)) {
+    ext->assumed |= bit;
+    lglpushstk (lgl, &lgl->eassume, elit);
+  }
+  assert (!lgl->level);
+  if (!(val = lglcval (lgl, ilit))) {
+    av = lglavar (lgl, ilit);
+    bit = (1u << (ilit < 0));
+    if (av->assumed & bit) {
+      LOG (2, "internal literal %d already assumed", ilit);
+    } else {
+      av->assumed |= bit;
+      if (av->assumed & (bit^3))
+	LOG (2, "negation %d was also already assumed", -ilit);
+      lglpushstk (lgl, &lgl->assume, ilit);
+    }
+  } else if (val > 0) {
+    LOG (2, "externally assumed literal %d already fixed to true", elit);
+  } else {
+    assert (val < 0);
+    LOG (2, "externally assumed literal %d already fixed to false", elit);
+    if (ilit != -1) {
+      av = lglavar (lgl, ilit);
+      bit = (1u << (ilit < 0));
+      if (!(av->assumed & bit)) {
+	av->assumed |= bit;
+	lglpushstk (lgl, &lgl->assume, ilit);
+      }
+    }
+    if (!lgl->failed) lgl->failed = ilit;
+  }
+}
+
+static void lglecassume (LGL * lgl, int elit) {
+  LOG (2, "adding external literal %d to assumed clause", elit);
+}
+
+void lglassume (LGL * lgl, int elit) {
+  int eidx = abs (elit);
+  Ext * ext;
+  REQINITNOTFORKED ();
+  TRAPI ("assume %d", elit);
+  lgl->stats->calls.assume++;
+  ABORTIF (!elit, "can not assume invalid literal 0");
+  if (0 < eidx && eidx <= lgl->maxext) {
+    ext = lglelit2ext (lgl, elit);
+    ABORTIF (ext->melted, "assuming melted literal %d", elit);
+  }
+  lgleassume (lgl, elit);
+  lgluse (lgl);
+  lglmelter (lgl);
+  if (lgl->clone) lglassume (lgl->clone, elit);
+}
+
+void lglcassume (LGL * lgl, int elit) {
+  int eidx = abs (elit);
+  Ext * ext;
+  REQINITNOTFORKED ();
+  TRAPI ("cassume %d", elit);
+  lgl->stats->calls.cassume++;
+  if (0 < eidx && eidx <= lgl->maxext) {
+    ext = lglelit2ext (lgl, elit);
+    ABORTIF (ext->melted, "assuming melted literal %d", elit);
+  }
+  lglecassume (lgl, elit);
+  lgluse (lgl);
+  if (lgl->clone) lglcassume (lgl->clone, elit);
+}
+
+void lglfixate (LGL * lgl) {
+  const int  * p;
+  Stk eassume;
+  REQINITNOTFORKED ();
+  TRAPI ("fixate");
+  if (lgl->mt) return;
+  CLR (eassume);
+  for (p = lgl->eassume.start; p < lgl->eassume.top; p++)
+    lglpushstk (lgl, &eassume, *p);
+  for (p = eassume.start; p < eassume.top; p++)
+    lgleadd (lgl, *p), lgleadd (lgl, 0);
+  lglrelstk (lgl, &eassume);
+  lgluse (lgl);
+  if (lgl->clone) lglfixate (lgl->clone);
+}
+
+static void lglbonflict (LGL * lgl, int lit, int blit) {
+  assert (lglevel (lgl, lit) >= lglevel (lgl, blit >> RMSHFT));
+  assert (!lgliselim (lgl, blit >> RMSHFT));
+  assert (!lgliselim (lgl, lit));
+  lgl->conf.lit = lit;
+  lgl->conf.rsn[0] = blit;
+  LOG (2, "inconsistent %s binary clause %d %d",
+       lglred2str (blit & REDCS), lit, (blit >> RMSHFT));
+}
+
+static void lgltonflict (LGL * lgl, int lit, int blit, int other2) {
+  assert ((blit & MASKCS) == TRNCS);
+  assert (lglevel (lgl, lit) >= lglevel (lgl, blit >> RMSHFT));
+  assert (lglevel (lgl, lit) >= lglevel (lgl, other2));
+  assert (!lgliselim (lgl, blit >> RMSHFT));
+  assert (!lgliselim (lgl, other2));
+  assert (!lgliselim (lgl, lit));
+  lgl->conf.lit = lit;
+  lgl->conf.rsn[0] = blit;
+  lgl->conf.rsn[1] = other2;
+  LOG (2, "inconsistent %s ternary clause %d %d %d",
+       lglred2str (blit & REDCS), lit, (blit>>RMSHFT), other2);
+}
+
+static void lglonflict (LGL * lgl, int check, int lit, int red, int lidx) {
+  int glue;
+#if !defined (NLGLOG) || !defined (NDEBUG)
+  int * p, * c = lglidx2lits (lgl, red, lidx);
+#endif
+  assert (red == REDCS || !red);
+#ifndef NDEBUG
+  {
+    int found = 0;
+    for (p = c; *p; p++) {
+      if(*p == lit) found++;
+      assert (lglval (lgl, *p) <= -check);
+      assert (lglevel (lgl, lit) >= lglevel (lgl, *p));
+      assert (!lgliselim (lgl, lit));
+    }
+    assert (found == 1);
+  }
+#endif
+  lgl->conf.lit = lit;
+  lgl->conf.rsn[0] = red | LRGCS;
+  lgl->conf.rsn[1] = lidx;
+#ifndef NLGLOG
+  if (lgl->opts->log.val >= 2) {
+    lglogstart (lgl, 2, "inconsistent %s large clause", lglred2str (red));
+    for (p = c ; *p; p++)
+      fprintf (lgl->out, " %d", *p);
+    lglogend (lgl);
+  }
+#endif
+  if (red) {
+    glue = lidx & GLUEMASK;
+    lgl->stats->lir[glue].conflicts++;
+    assert (lgl->stats->lir[glue].conflicts > 0);
+  }
+}
+
+static void lgldeclscnt (LGL * lgl, int size, int red, int glue) {
+  assert (!red || red == REDCS);
+  if (!red) lgldecirr (lgl, size);
+  else if (size == 2) assert (lgl->stats->red.bin), lgl->stats->red.bin--;
+  else if (size == 3) assert (lgl->stats->red.trn), lgl->stats->red.trn--;
+  else {
+    assert (lgl->stats->red.lrg > 0);
+    lgl->stats->red.lrg--;
+    assert (lgl->stats->lir[glue].clauses > 0);
+    lgl->stats->lir[glue].clauses--;
+  }
+}
+
+static void lglrminc (LGL * lgl, const int * w, const int * eow) {
+  int inc;
+  assert (w <= eow);
+  assert (sizeof w < 8 || eow <= w + INT_MAX);
+  inc = eow - w;
+  assert (inc >= 0);
+  inc >>= lgl->opts->rmincpen.val;
+  inc++;
+  assert (lgl->blocking + lgl->eliminating + lgl->simpleprobing <= 1);
+  if (lgl->blocking) ADDSTEPS (blk.steps, inc);
+  else if (lgl->eliminating) ADDSTEPS (elm.steps, inc);
+  else if (lgl->simpleprobing) ADDSTEPS (prb.simple.steps, inc);
+}
+
+static void lglrmtwch (LGL * lgl, int lit, int other1, int other2, int red) {
+  int * p, blit, other, blit1, blit2, * w, * eow, tag;
+  HTS * hts;
+  assert (!red || red == REDCS);
+  LOG (3, "removing %s ternary watch %d blits %d %d",
+       lglred2str (red), lit, other1, other2);
+  hts = lglhts (lgl, lit);
+  assert (hts->count >= 2);
+  p = w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  lglrminc (lgl, w, eow);
+  blit1 = RMSHFTLIT (other1) | red | TRNCS;
+  blit2 = RMSHFTLIT (other2) | red | TRNCS;
+  for (;;) {
+    assert (p < eow);
+    blit = *p++;
+    tag = blit & MASKCS;
+    if (tag == BINCS || tag == OCCS) continue;
+    other = *p++;
+    if (tag == LRGCS) continue;
+    assert (tag == TRNCS);
+    if (blit == blit1 && other == other2) break;
+    if (blit == blit2 && other == other1) break;
+  }
+  while (p < eow) p[-2] = p[0], p++;
+  lglshrinkhts (lgl, hts, p - w - 2);
+}
+
+static void lglpopnunmarkstk (LGL * lgl, Stk * stk) {
+  while (!lglmtstk (stk)) {
+    int lit = lglpopstk (stk);
+    if (!lit) continue;
+    lglavar (lgl, lit)->mark = 0;
+  }
+}
+
+static void lglpopnunlcamarkstk (LGL * lgl, Stk * stk) {
+  while (!lglmtstk (stk))
+    lglavar (lgl, lglpopstk (stk))->lcamark = 0;
+}
+
+static int lglcamarked (LGL * lgl, int lit) {
+  switch (lglavar (lgl, lit)->lcamark) {
+    case 1: return (lit < 0) ? -1 : 1;
+    case 2: return (lit < 0) ? -2 : 2;
+    case 4: return (lit < 0) ? 1 : -1;
+    case 8: return (lit < 0) ? 2 : -2;
+    default: assert (!lglavar (lgl, lit)->lcamark); return 0;
+  }
+}
+
+static void lglcamark (LGL * lgl, int lit, int mark) {
+  int newmark;
+  AVar * av;
+  assert (mark == 1 || mark == 2);
+  av = lglavar (lgl, lit);
+  assert (!av->lcamark);
+  newmark = mark;
+  if (lit < 0) newmark <<= 2;
+  av->lcamark = newmark;
+  lglpushstk (lgl, &lgl->lcaseen, lit);
+  assert (lglcamarked (lgl, lit) == mark);
+  assert (lglcamarked (lgl, -lit) == -mark);
+}
+
+static int lgbiglca (LGL * lgl, int a, int b, int64_t * stepsptr) {
+  int blit, tag, mark, negmark, prevmark, c, res, prev, next;
+  const int * p, * w, * eow;
+  int64_t steps;
+  HTS * hts;
+  assert (a), assert (b);
+  assert (abs (a) != abs (b));
+  assert (lglevel (lgl, a));
+  assert (lglevel (lgl, b));
+  assert (lglval (lgl, a) > 0);
+  assert (lglval (lgl, b) > 0);
+  assert (lglgetdom (lgl, a) == lglgetdom (lgl, b));
+  assert (lglmtstk (&lgl->lcaseen));
+  lglcamark (lgl, a, 1);
+  lglcamark (lgl, b, 2);
+  res = next = 0;
+  steps = 0;
+  while (next < lglcntstk (&lgl->lcaseen)) {
+    c = lglpeek (&lgl->lcaseen, next++);
+    assert (lglval (lgl, c) > 0);
+    assert (lglevel (lgl, c) > 0);
+    mark = lglcamarked (lgl, c);
+    assert (mark == 1 || mark == 2);
+    negmark = mark ^ 3;
+    hts = lglhts (lgl, c);
+    if (!hts->count) continue;
+    w = lglhts2wchs (lgl, hts);
+    eow = w + hts->count;
+    steps++;
+    for (p = w; p < eow; p++) {
+      blit = *p;
+      tag = blit & MASKCS;
+      if (tag == TRNCS || tag == LRGCS) p++;
+      if (tag != BINCS) continue;
+      prev = -(blit >> RMSHFT);
+      if (!lglevel (lgl, prev)) continue;
+      if (lglval (lgl, prev) <= 0) continue;
+      if ((prevmark = lglcamarked (lgl, prev)) < 0) continue;
+      if (mark == prevmark) continue;
+      if (prevmark == negmark) { res = prev; goto DONE; }
+      lglcamark (lgl, prev, mark);
+    }
+  }
+DONE:
+  lglpopnunlcamarkstk (lgl, &lgl->lcaseen);
+  LOG (3, "least common ancestor of %d and %d is %d", a, b, res);
+  *stepsptr += steps;
+  return res;
+}
+
+static int lglimplca (LGL * lgl, int a, int b, int64_t * stepsptr) {
+  int r0, tag, mark, negmark, prevmark, c, res, prev, next;
+  int64_t steps;
+  assert (a), assert (b);
+  assert (abs (a) != abs (b));
+  assert (lglevel (lgl, a));
+  assert (lglevel (lgl, b));
+  assert (lglval (lgl, a) > 0);
+  assert (lglval (lgl, b) > 0);
+  assert (lglgetdom (lgl, a) == lglgetdom (lgl, b));
+  assert (lglmtstk (&lgl->lcaseen));
+  lglcamark (lgl, a, 1);
+  lglcamark (lgl, b, 2);
+  res = next = 0;
+  steps = 0;
+  while (next < lglcntstk (&lgl->lcaseen)) {
+    c = lglpeek (&lgl->lcaseen, next++);
+    assert (lglval (lgl, c) > 0);
+    assert (lglevel (lgl, c) > 0);
+    mark = lglcamarked (lgl, c);
+    assert (mark == 1 || mark == 2);
+    negmark = mark ^ 3;
+    steps++;
+    r0 = *lglrsn (lgl, c);
+    tag = r0 & MASKCS;
+    if (tag != BINCS) continue;
+    prev = -(r0 >> RMSHFT);
+    if (!lglevel (lgl, prev)) continue;
+    if (lglval (lgl, prev) <= 0) continue;
+    if ((prevmark = lglcamarked (lgl, prev)) < 0) continue;
+    if (mark == prevmark) continue;
+    if (prevmark == negmark) { res = prev; goto DONE; }
+    lglcamark (lgl, prev, mark);
+  }
+DONE:
+  lglpopnunlcamarkstk (lgl, &lgl->lcaseen);
+  LOG (3, "least common ancestor of %d and %d is %d", a, b, res);
+  *stepsptr += steps;
+  return res;
+}
+
+
+static int lglhbrdom (LGL * lgl, int a, int b, int64_t * stepsptr) {
+  assert (lglgetdom (lgl, a) == lglgetdom (lgl, b));
+  switch (lgl->opts->hbrdom.val) {
+    case 2: return lgbiglca (lgl, a, b, stepsptr);
+    case 1: return lglimplca (lgl, a, b, stepsptr);
+    default: return lglgetdom (lgl, a);
+  }
+}
+
+static void lglrmlwch (LGL * lgl, int lit, int red, int lidx) {
+  int blit, tag, * p, * q, * w, * eow, ored, olidx;
+  HTS * hts;
+#ifndef NLGLOG
+  p = lglidx2lits (lgl, red, lidx);
+  if (red)
+    LOG (3, "removing watch %d in red[%d][%d] %d %d %d %d%s",
+	 lit, (lidx & GLUEMASK), (lidx >> GLUESHFT), p[0], p[1], p[2], p[3],
+	 (p[4] ? " ..." : ""));
+  else
+    LOG (3, "removing watch %d in irr[%d] %d %d %d %d%s",
+	 lit, lidx, p[0], p[1], p[2], p[3], (p[4] ? " ..." : ""));
+#endif
+  hts = lglhts (lgl, lit);
+  assert (hts->count >= 2);
+  p = w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  lglrminc (lgl, w, eow);
+  for (;;) {
+    assert (p < eow);
+    blit = *p++;
+    tag = blit & MASKCS;
+    if (tag == BINCS) continue;
+    if (tag == OCCS) { assert (lgl->dense); continue; }
+    olidx = *p++;
+    if (tag == TRNCS) continue;
+    assert (tag == LRGCS);
+    ored = blit & REDCS;
+    if (ored != red) continue;
+    if (olidx == lidx) break;
+  }
+  assert ((p[-2] & REDCS) == red);
+  assert (p[-1] == lidx);
+  for (q = p; q < eow; q++)
+    q[-2] = q[0];
+  lglshrinkhts (lgl, hts, q - w - 2);
+}
+
+static void lglpropsearch (LGL * lgl, int lit) {
+  int * q, * eos, blit, other, other2, other3, red, prev;
+  int tag, val, val2, lidx, * c, * l;
+  const int * p;
+  ptrdiff_t delta;
+  int visits;
+  HTS * hts;
+
+  LOG (3, "propagating %d in search", lit);
+
+  assert (!lgl->simp);
+  assert (!lgl->lkhd);
+  assert (!lgl->probing);
+  assert (!lgl->dense);
+  assert (!lgliselim (lgl, lit));
+  assert (lglval (lgl, lit) == 1);
+
+  hts = lglhts (lgl, -lit);
+  if (!hts->offset) return;
+  q = lglhts2wchs (lgl, hts);
+  assert (hts->count >= 0);
+  eos = q + hts->count;
+  visits = 0;
+  for (p = q; p < eos; p++) {
+    visits++;
+    *q++ = blit = *p;
+    tag = blit & MASKCS;
+    if (tag != BINCS) {
+      assert (tag == TRNCS || tag == LRGCS);
+      *q++ = *++p;
+    }
+    other = (blit >> RMSHFT);
+    assert (abs (other) != abs (lit));
+    val = lglval (lgl, other);
+    if (val > 0) continue;
+    red = blit & REDCS;
+    if (tag == BINCS) {
+      if (val < 0) { lglbonflict (lgl, -lit, blit); p++; break; }
+      lglf2rce (lgl, other, -lit, red);
+    } else if (tag == TRNCS) {
+      other2 = *p;
+      val2 = lglval (lgl, other2);
+      if (val2 > 0) continue;
+      if (!val && !val2) continue;
+      if (val < 0 && val2 < 0) {
+	lgltonflict (lgl, -lit, blit, other2);
+	p++;
+	break;
+      }
+      if (!val) SWAP (int, other, other2);
+      else assert (val < 0);
+      lglf3rce (lgl, other2, -lit, other, red);
+    } else {
+      assert (tag == LRGCS);
+      assert (val <= 0);
+      lidx = *p;
+      c = lglidx2lits (lgl, red, lidx);
+      other2 = c[0];
+      if (other2 == -lit) other2 = c[0] = c[1], c[1] = -lit;
+      else assert (c[1] == -lit);
+      if (other2 != other) {
+	other = other2;
+	val = lglval (lgl, other);
+	if (val > 0) {
+	  q[-2] = LRGCS | RMSHFTLIT (other2) | red;
+	  continue;
+	}
+      }
+      assert (!red || !lgliselim (lgl, other));
+      val2 = 0;
+      prev = -lit;
+      for (l = c + 2; (other2 = *l); l++) {
+	*l = prev;
+	val2 = lglval (lgl, other2);
+	if (val2 >= 0) break;
+	assert (!red || !lgliselim (lgl, other2));
+	prev = other2;
+      }
+      assert (!other2 || val2 >= 0);
+      if (other2) {
+	c[1] = other2;
+	assert (other == c[0]);
+	delta = lglwchlrg (lgl, other2, other, red, lidx);
+	if (delta) p += delta, q += delta, eos += delta;
+	q -= 2;
+	continue;
+      }
+      while (l > c + 2) {
+	other3 = *--l;
+	*l = prev;
+	prev = other3;
+      }
+      if (val < 0) {
+	lglonflict (lgl, 1, -lit, red, lidx);
+	p++;
+	break;
+      }
+      assert (!val);
+      lglflrce (lgl, other, red, lidx);
+    }
+  }
+  while (p < eos) *q++ = *p++;
+  lglshrinkhts (lgl, hts, hts->count - (p - q));
+  assert (!lgl->simp);
+
+  lgl->stats->visits.search += visits;
+}
+
+static int lglhbred (LGL * lgl, int subsumed, int red) {
+  int res = subsumed ? red : REDCS;
+  LOG (3, "hyber binary learned clause becomes %s", lglred2str (res));
+  return res;
+}
+
+static void lgldecocc (LGL *, int);	//TODO move scheduling ...
+
+static void lglrmlocc (LGL * lgl, int lit, int red, int lidx) {
+  int search, blit, tag, * p, * q, * w, * eow;
+  HTS * hts;
+#ifndef NLGLOG
+  if (red) LOG (3, "removing occurrence %d in red[0][%d]", lit, lidx);
+  else LOG (3, "removing occurrence %d in irr[%d]", lit, lidx);
+#endif
+  assert (!red || red == REDCS);
+  hts = lglhts (lgl, lit);
+  assert (hts->count >= 1);
+  assert (lidx <= MAXIRRLIDX);
+  search = (lidx << RMSHFT) | OCCS | red;
+  assert (search >= 0);
+  p = w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  lglrminc (lgl, w, eow);
+  do {
+    assert (p < eow);
+    blit = *p++;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+  } while (blit != search);
+  assert (p[-1] == search);
+  for (q = p ; q < eow; q++)
+    q[-1] = q[0];
+  lglshrinkhts (lgl, hts, q - w - 1);
+}
+
+static void lglflushremovedoccs (LGL * lgl, int lit) {
+  HTS * hts = lglhts (lgl, lit);
+  int * w = lglhts2wchs (lgl, hts);
+  int * eow = w + hts->count;
+  int blit, tag, red, lidx;
+  int * p, * q, * c;
+  lglrminc (lgl, w, eow);
+  for (p = q = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    red = blit & REDCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == BINCS) *q++ = blit;
+    else if (tag == TRNCS) *q++ = blit, *q++ = *p;
+    else {
+      assert (tag == LRGCS || tag == OCCS);
+      if (!red) {
+	lidx = (tag == LRGCS) ? *p : (blit >> RMSHFT);
+	c = lglidx2lits (lgl, red, lidx);
+	if (c[0] == REMOVED) continue;
+      }
+      *q++ = blit;
+      if (tag == LRGCS) *q++ = *p;
+    }
+  }
+  lglshrinkhts (lgl, hts, q - w);
+}
+
+static void lglpropupdvisits (LGL * lgl, int visits, int64_t steps) {
+  if (lgl->lkhd) lgl->stats->visits.lkhd += visits;
+  else if (lgl->simp) lgl->stats->visits.simp += visits;
+  else lgl->stats->visits.search += visits;
+
+  if (lgl->simp) {
+         if (lgl->basicprobing) ADDSTEPS (prb.basic.steps, visits + steps);
+    else if (lgl->simpleprobing) ADDSTEPS (prb.simple.steps, visits + steps);
+    else if (lgl->treelooking) ADDSTEPS (prb.treelook.steps, visits + steps);
+    else if (lgl->sweeping) ADDSTEPS (sweep.steps, visits + steps);
+  } else {
+    assert (!lgl->basicprobing);
+    assert (!lgl->simpleprobing);
+    assert (!lgl->treelooking);
+    assert (!lgl->sweeping);
+  }
+}
+
+static void lglprop (LGL * lgl, int lit) {
+  int * p, * q, * eos, blit, other, other2, other3, red, prev;
+  int tag, val, val2, lidx, * c, * l, dom, hbred, subsumed;
+  int glue, flushoccs, visits;
+  int64_t steps;
+  ptrdiff_t delta;
+  HTS * hts;
+  LOG (3, "propagating %d over ternary and large clauses", lit);
+  assert (!lgliselim (lgl, lit));
+  assert (lglval (lgl, lit) == 1);
+  hts = lglhts (lgl, -lit);
+  if (!hts->offset) return;
+  flushoccs = 0;
+  q = lglhts2wchs (lgl, hts);
+  assert (hts->count >= 0);
+  eos = q + hts->count;
+  visits = 0;
+  steps = 0;
+  for (p = q; p < eos; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    red = blit & REDCS;
+    if (tag == OCCS) {
+      assert (lgl->dense);
+      assert (!red);
+      *q++ = blit;
+      continue;
+    }
+    visits++;
+    other = (blit >> RMSHFT);
+    val = lglval (lgl, other);
+    if (tag == BINCS) {
+      *q++ = blit;
+      if (val > 0) continue;
+      if (red && lgliselim (lgl, other)) continue;
+      if (val < 0) {
+	lglbonflict (lgl, -lit, blit);
+	p++;
+	break;
+      }
+      assert (!val);
+      lglf2rce (lgl, other, -lit, red);
+    } else if (tag == TRNCS) {
+      *q++ = blit;
+      other2 = *++p;
+      *q++ = other2;
+      if (val > 0) continue;
+      if (red && lgliselim (lgl, other)) continue;
+      val2 = lglval (lgl, other2);
+      if (val2 > 0) continue;
+      if (!val && !val2) continue;
+      if (red && lgliselim (lgl, other2)) continue;
+      if (val < 0 && val2 < 0) {
+	lgltonflict (lgl, -lit, blit, other2);
+	p++;
+	break;
+      }
+      if (!val) SWAP (int, other, other2); else assert (val < 0);
+      if (lgl->level &&
+	  lgl->simp &&
+	  lgl->opts->lhbr.val) {
+	assert (lgl->simp);
+	dom = lglgetdom (lgl, lit);
+	if (lglgetdom (lgl, -other) != dom) goto NO_HBR_JUST_F3RCE;
+	dom = lglhbrdom (lgl, lit, -other, &steps);
+	if (!dom) goto NO_HBR_JUST_F3RCE;
+	subsumed = (dom == lit || dom == -other);
+	hbred = lglhbred (lgl, subsumed, red);
+	LOG (2, "hyper binary resolved %s clause %d %d",
+	     lglred2str (hbred), -dom, other2);
+        lgldrupligaddclsarg (lgl, REDCS, -dom, other2, 0);
+	if (subsumed) {
+	  LOG (2, "subsumes %s ternary clause %d %d %d",
+	       lglred2str (red), -lit, other, other2);
+	  lglrmtwch (lgl, other2, other, -lit, red);
+	  lglrmtwch (lgl, other, other2, -lit, red);
+	  lgl->stats->hbr.sub++;
+	  if (red) assert (lgl->stats->red.trn), lgl->stats->red.trn--;
+	  else {
+	    lgldecirr (lgl, 3);
+	    if (lgl->dense) {
+	      if (-dom == -lit) lgldecocc (lgl, other);
+	      else { assert (-dom == other); lgldecocc (lgl, -lit); }
+	    }
+	  }
+	  lgldrupligdelclsarg (lgl, -lit, other, other2, 0);
+	}
+	delta = 0;
+	if (dom == lit) {
+	  LOG (3,
+    "replacing %s ternary watch %d blits %d %d with binary %d blit %d",
+	  lglred2str (red), -lit, other, other2, -dom, other2);
+	  assert (subsumed);
+	  blit = RMSHFTLIT (other2) | BINCS | hbred;
+	  q[-2] = blit;
+	  q--;
+	} else {
+	  if (dom == -other) {
+	    LOG (3, "removing %s ternary watch %d blits %d %d",
+		 lglred2str (red), -lit, other, other2);
+	    assert (subsumed);
+	    q -= 2;
+	  } else {
+	    LOG (2, "replaces %s ternary clause %d %d %d as reason for %d",
+		 lglred2str (red), -lit, other, other2, other2);
+	    assert (!subsumed);
+	    assert (abs (dom) != abs (lit));
+	    assert (abs (other2) != abs (lit));
+	  }
+	  delta += lglwchbin (lgl, -dom, other2, hbred);
+	}
+	delta += lglwchbin (lgl, other2, -dom, hbred);
+	if (delta) p += delta, q += delta, eos += delta;
+	if (hbred) lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+	else lglincirr (lgl, 2);
+	lglf2rce (lgl, other2, -dom, hbred);
+	lgl->stats->hbr.trn++;
+	lgl->stats->hbr.cnt++;
+	lgl->stats->prgss++;
+      } else {
+NO_HBR_JUST_F3RCE:
+       lglf3rce (lgl, other2, -lit, other, red);
+      }
+    } else {
+      assert (tag == LRGCS);
+      if (val > 0) goto COPYL;
+      lidx = p[1];
+      c = lglidx2lits (lgl, red, lidx);
+      other2 = c[0];
+      if (other2 >= NOTALIT) {
+	p++;
+	continue;
+      }
+      if (other2 == -lit) other2 = c[0] = c[1], c[1] = -lit;
+      if (other2 != other) {
+	other = other2;
+	val = lglval (lgl, other);
+	blit = red;
+	blit |= LRGCS;
+	blit |= RMSHFTLIT (other2);
+	if (val > 0) goto COPYL;
+      }
+      if (red && lgliselim (lgl, other)) goto COPYL;
+      val2 = INT_MAX;
+      prev = -lit;
+      for (l = c + 2; (other2 = *l); l++) {
+	*l = prev;
+	val2 = lglval (lgl, other2);
+	if (val2 >= 0) break;
+	if (red && lgliselim (lgl, other2)) break;
+	prev = other2;
+      }
+      assert (val2 != INT_MAX);
+      if (other2 && val2 >= 0) {
+	c[1] = other2;
+	assert (other == c[0]);
+	delta = lglwchlrg (lgl, other2, other, red, lidx);
+	if (delta) p += delta, q += delta, eos += delta;
+	p++;
+	continue;
+      }
+
+      while (l > c + 2) {
+	other3 = *--l;
+	*l = prev;
+	prev = other3;
+      }
+
+      if (other2 && val2 < 0) goto COPYL;
+
+      if (val < 0) {
+	lglonflict (lgl, 1, -lit, red, lidx);
+	break;
+      }
+
+      assert (!val);
+      if (lgl->level &&
+	  lgl->simp &&
+	  lgl->opts->lhbr.val) {
+	assert (lgl->simp);
+	dom = 0;
+	for (l = c; (other2 = *l); l++) {
+	  if (other2 == other) continue;
+	  if (!lglevel (lgl, other2)) continue;
+	  assert (lglval (lgl, other2) < 0);
+	  if (!dom) dom = lglgetdom (lgl, -other);
+	  if (dom != lglgetdom (lgl, -other2)) goto NO_HBR_JUST_FLRCE;
+	}
+	LOGCLS (2, c, "dominator %d for %s clause", dom, lglred2str (red));
+	dom = 0;
+	for (l = c; (other2 = *l); l++) {
+	  if (other2 == other) continue;
+	  if (!lglevel (lgl, other2)) continue;
+	  dom = lglhbrdom (lgl, dom, -other2, &steps);
+	}
+	if (!dom) goto NO_HBR_JUST_FLRCE;
+	LOGCLS (2, c, "closest dominator %d", dom);
+	subsumed = 0;
+	for (l = c; !subsumed && (other2 = *l); l++)
+	  subsumed = (dom == -other2);
+	assert (lit != dom || subsumed);
+	hbred = lglhbred (lgl, subsumed, red);
+	LOG (2, "hyper binary resolved %s clause %d %d",
+	     lglred2str (hbred), -dom, other);
+        lgldrupligaddclsarg (lgl, REDCS, -dom, other, 0);
+	if (subsumed) {
+	  LOGCLS (2, c, "subsumes %s large clause", lglred2str (red));
+	  lglrmlwch (lgl, other, red, lidx);
+	  lgl->stats->hbr.sub++;
+	  if (red) {
+	    glue = lidx & GLUEMASK;
+	    if (glue != MAXGLUE) {
+	      assert (lgl->stats->red.lrg);
+	      lgl->stats->red.lrg--;
+	      assert (lgl->stats->lir[glue].clauses > 0);
+	      lgl->stats->lir[glue].clauses--;
+	    }
+	  }
+	  if (!red && lgl->dense) {
+	    for (l = c; (other2 = *l); l++) {
+	      if (other2 != -lit) lglrmlocc (lgl, other2, 0, lidx);
+	      if (other2 == -dom) continue;
+	      if (other2 == other) continue;
+	      lgldecocc (lgl, other2);
+	    }
+	    flushoccs++;
+	  }
+	  if (red && glue < MAXGLUE) { LGLCHKACT (c[-1]); c[-1] = REMOVED; }
+	  lgldrupligdelclsaux (lgl, c);
+	  for (l = c; *l; l++) *l = REMOVED;
+	  if (!red) lgldecirr (lgl, l - c);
+	  *l = REMOVED;
+	}
+	delta = 0;
+	if (dom == lit) {
+	  assert (subsumed);
+	  LOG (3,
+	       "replacing %s large watch %d with binary watch %d blit %d",
+	       lglred2str (red), -lit, -lit, -dom);
+	  blit = RMSHFTLIT (other) | BINCS | hbred;
+	  *q++ = blit, p++;
+	} else {
+	  if (subsumed) {
+	    LOG (3, "removing %s large watch %d", lglred2str (red), -lit);
+	    p++;
+	  } else {
+	    LOGCLS (2, c,
+		    "%s binary clause %d %d becomes reasons "
+		    "for %d instead of %s large clause",
+		    lglred2str (hbred), -dom, other, other, lglred2str (red));
+	    assert (hbred == REDCS);
+	  }
+	  delta += lglwchbin (lgl, -dom, other, hbred);
+	}
+	delta += lglwchbin (lgl, other, -dom, hbred);
+	if (delta) p += delta, q += delta, eos += delta;
+	if (hbred) lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+	else lglincirr (lgl, 2);
+	lglf2rce (lgl, other, -dom, hbred);
+	lgl->stats->hbr.lrg++;
+	lgl->stats->hbr.cnt++;
+	lgl->stats->prgss++;
+	if (subsumed) continue;
+      } else {
+NO_HBR_JUST_FLRCE:
+	lglflrce (lgl, other, red, lidx);
+      }
+COPYL:
+      *q++ = blit;
+      *q++ = *++p;
+    }
+  }
+  while (p < eos) *q++ = *p++;
+  lglshrinkhts (lgl, hts, hts->count - (p - q));
+  if (flushoccs) lglflushremovedoccs (lgl, -lit);
+  lglpropupdvisits (lgl, visits, steps);
+}
+
+static void lglprop2 (LGL * lgl, int lit) {
+  int other, blit, tag, val, red, visits;
+  const int * p, * w, * eow;
+  int64_t travs;
+  HTS * hts;
+  LOG (3, "propagating %d over binary clauses", lit);
+  assert (!lgliselim (lgl, lit));
+  assert (lglval (lgl, lit) == 1);
+  visits = 0;
+  travs = 0;
+  hts = lglhts (lgl, -lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag != BINCS) continue;
+    visits++;
+    red = blit & REDCS;
+    other = blit >> RMSHFT;
+    travs++;
+    if (lgliselim (lgl, other)) { assert (red); continue; }
+    val = lglval (lgl, other);
+    if (val > 0) continue;
+    if (val < 0) { lglbonflict (lgl, -lit, blit); break; }
+    lglf2rce (lgl, other, -lit, red);
+  }
+
+  lglpropupdvisits (lgl, visits, travs);
+}
+
+static int lglhasconflict (LGL * lgl) {
+  return lgl->conf.lit != 0;
+}
+
+static int lglbcpcomplete (LGL * lgl) {
+  assert (lgl->next2 <= lgl->next);
+  assert (lgl->next <= lglcntstk (&lgl->trail));
+  if (lgl->next2 < lgl->next) return 0;
+  if (lgl->next < lglcntstk (&lgl->trail)) return 0;
+  return 1;
+}
+
+static void lglchkbcpclean (LGL * lgl, const char * where) {
+  ASSERT (lglbcpcomplete (lgl));
+  ASSERT (!lgl->conf.lit);
+  ASSERT (!lgl->mt);
+}
+
+static int lglbcp (LGL * lgl) {
+  int lit, trail, count;
+  assert (!lgl->mt);
+  assert (!lgl->conf.lit);
+  assert (!lgl->notfullyconnected);
+  count = 0;
+  while (!lgl->conf.lit) {
+    trail = lglcntstk (&lgl->trail);
+    if (lgl->next2 < trail) {
+      lit = lglpeek (&lgl->trail, lgl->next2++);
+      lglprop2 (lgl, lit);
+      continue;			// TODO try to optionally uncomment
+    }
+    if (lgl->next >= trail) break;
+    count++;
+    lit = lglpeek (&lgl->trail, lgl->next++);
+    lglprop (lgl, lit);
+  }
+  if (lgl->lkhd) ADDSTEPS (props.lkhd, count);
+  else if (lgl->simp) ADDSTEPS (props.simp, count);
+  else ADDSTEPS (props.search, count);
+  assert (lglhasconflict (lgl) || lglbcpcomplete (lgl));
+  return !lglhasconflict (lgl);
+}
+
+static int lglbcpsearch (LGL * lgl) {
+  int lit, count = 0;
+  assert (!lgl->simp);
+  assert (!lgl->notfullyconnected);
+  while ((!lgl->failed || !lgl->level) &&
+	 !lgl->conf.lit &&
+	 lgl->next < lglcntstk (&lgl->trail)) {
+    lit = lglpeek (&lgl->trail, lgl->next++);
+    lglpropsearch (lgl, lit);
+    count++;
+  }
+  ADDSTEPS (props.search, count);
+  lgl->next2 = lgl->next;
+  if (lgl->conf.lit && lgl->failed) {
+    LOG (2, "inconsistency overwrites failed assumption %d", lgl->failed);
+    lgl->failed = 0;
+  }
+  assert (lglhasconflict (lgl) || lgl->failed || lglbcpcomplete (lgl));
+  return !lgl->conf.lit && !lgl->failed;
+}
+
+#ifndef NDEBUG
+static void lglchkclnvar (LGL * lgl) {
+  AVar * av;
+  int i;
+  for (i = 2; i < lgl->nvars; i++) {
+    av = lglavar (lgl, i);
+    assert (!av->mark);
+  }
+}
+#endif
+
+#ifdef RESOLVENT
+static int lglmaintainresolvent (LGL * lgl) {
+#ifndef NDEBUG
+  if (lgl->opts->check.val >= 1) return 1;
+#endif
+#ifndef NLGLOG
+  if (lgl->opts->log.val >= 2) return 1;
+#endif
+  return 0;
+}
+#endif
+
+static int lgldecision (LGL * lgl, int lit) {
+  int * rsn = lglrsn (lgl, lit);
+  int tag = rsn[0] & MASKCS;
+  return tag == DECISION;
+}
+
+static int lglassumption (LGL * lgl, int lit) {
+  return lglavar (lgl, lit)->assumed;
+}
+
+static int lglpull (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  int level, res;
+  level = lglevel (lgl, lit);
+  if (!level) return 0;
+  if (av->mark) return 0;
+  av->mark = 1;
+  lglpushstk (lgl, &lgl->seen, lit);
+#ifdef RESOLVENT
+  if (lglmaintainresolvent (lgl)) {
+    lglpushstk (lgl, &lgl->resolvent, lit);
+    LOG (2, "adding %d to resolvent", lit);
+    LOGRESOLVENT (3, "resolvent after adding %d is", lit);
+  }
+#endif
+  if (level == lgl->level) {
+    LOG (2, "reason literal %d at same level %d", lit, lgl->level);
+    res = 1;
+  } else {
+    lglpushstk (lgl, &lgl->clause, lit);
+    LOG (2, "adding literal %d at upper level %d to 1st UIP clause",
+	 lit, lglevel (lgl, lit));
+    lgluselevel (lgl, level);
+    res = 0;
+  }
+  return res;
+}
+
+static int lglusedtwice (LGL * lgl, int lit) {
+  int level;
+  if (!lgl->opts->usedtwice.val) return 1;
+  level = lglevel (lgl, lit);
+  lgl->stats->mincls.usedtwice.search++;
+  if (lglevelused (lgl, level) >= 2) return 1;
+  lgl->stats->mincls.usedtwice.hits++;
+  return 0;
+}
+
+static int lglpoison (LGL * lgl, int lit, Stk * stk, int local) {
+  AVar * av = lglavar (lgl, lit);
+  int level, res;
+  if (av->mark) res = 0;
+  else {
+    level = lglevel (lgl, lit);
+    if (!level) res = 0;
+    else {
+      assert (level < lgl->level);
+      if (lgldecision (lgl, lit)) res = 1;
+      else if (lglevelused (lgl, level) < 2) res = 1;
+      else {
+	if (lgl->opts->poison.val) lgl->stats->mincls.poison.search++;
+	if (av->poisoned) {
+	  assert (lgl->opts->poison.val);
+	  lgl->stats->mincls.poison.hits++;
+	  res = 1;
+	} else if (local) res = 1;
+	else if (lglusedtwice (lgl, lit)) {
+	  av->mark = 1;
+	  lglpushstk (lgl, &lgl->seen, lit);
+	  lglpushstk (lgl, stk, lit);
+	  res = 0;
+	} else res = 1;
+      }
+    }
+  }
+  if (res && lgl->opts->poison.val && !av->poisoned) {
+    av->poisoned = 1;
+    lglpushstk (lgl, &lgl->poisoned, lit);
+  }
+  return res;
+}
+
+static int lglminclslit (LGL * lgl, int start, int local) {
+  int lit, tag, r0, r1, other, * p, * q, *top, old, level;
+  int poisoned, * rsn, found;
+  AVar * av, * bv;
+  assert (lglmarked (lgl, start));
+  lit = start;
+  level = lglevel (lgl, lit);
+  assert (level > 0);
+  if (level == lgl->level) return 0;
+  if (!lglusedtwice (lgl, lit)) return 0;
+  rsn = lglrsn (lgl, lit);
+  r0 = rsn[0];
+  tag = (r0 & MASKCS);
+  if (tag == DECISION) return 0;
+  old = lglcntstk (&lgl->seen);
+  assert (lglmtstk (&lgl->minstk));
+  for (;;) {
+    r1 = rsn[1];
+    if (tag == BINCS || tag == TRNCS) {
+      other = r0 >> RMSHFT;
+      if (lglpoison (lgl, other, &lgl->minstk, local)) goto FAILED;
+      if (tag == TRNCS && lglpoison (lgl, r1, &lgl->minstk, local))
+	goto FAILED;
+    } else {
+      assert (tag == LRGCS);
+      p = lglidx2lits (lgl, (r0 & REDCS), r1);
+      found = 0;
+      while ((other = *p++)) {
+	if (other == -lit) found++;
+	else if (lglpoison (lgl, other, &lgl->minstk, local)) goto FAILED;
+      }
+      assert (found == 1);
+    }
+    if (lglmtstk (&lgl->minstk)) { lglrelstk (lgl, &lgl->minstk); return 1; }
+    lit = lglpopstk (&lgl->minstk);
+    assert (lglavar (lgl, lit)->mark);
+    rsn = lglrsn (lgl, lit);
+    r0 = rsn[0];
+    tag = (r0 & MASKCS);
+  }
+FAILED:
+  lglclnstk (&lgl->minstk);
+  p = lgl->seen.top;
+  top = lgl->seen.top = lgl->seen.start + old;
+  while (p > top) {
+    lit = *--p;
+    av = lglavar (lgl, lit);
+    assert (av->mark);
+    av->mark = 0;
+    if (!lgl->opts->poison.val) continue;
+    poisoned = av->poisoned;
+    if (poisoned) continue;
+    rsn = lglrsn (lgl, lit);
+    r0 = rsn[0];
+    tag = (r0 & MASKCS);
+    assert (tag != DECISION);
+    r1 = rsn[1];
+    if (tag == BINCS || tag == TRNCS) {
+      other = r0 >> RMSHFT;
+      bv = lglavar (lgl, other);
+      if (bv->poisoned) poisoned = 1;
+      else if (tag == TRNCS) {
+	bv = lglavar (lgl, r1);
+	if (bv->poisoned) poisoned = 1;
+      }
+    } else {
+      assert (tag == LRGCS);
+      q = lglidx2lits (lgl, (r0 & REDCS), r1);
+      while (!poisoned && (other = *q++))
+	poisoned = lglavar (lgl, other)->poisoned;
+    }
+    if (!poisoned) continue;
+    assert (!av->poisoned);
+    av->poisoned = 1;
+    lglpushstk (lgl, &lgl->poisoned, lit);
+  }
+  return 0;
+}
+
+double lglmaxmb (LGL * lgl) {
+  REQINIT ();
+  return (lgl->stats->bytes.max + sizeof *lgl) / (double)(1<<20);
+}
+
+size_t lglbytes (LGL * lgl) {
+  REQINIT ();
+  return lgl->stats->bytes.current;
+}
+
+double lglmb (LGL * lgl) {
+  REQINIT ();
+  return (lgl->stats->bytes.current + sizeof *lgl) / (double)(1<<20);
+}
+
+static double lglavg (double n, double d) {
+  return d != 0 ? n / d : 0.0;
+}
+
+static double lglheight (LGL * lgl) {
+  return lgl->stats->jlevel.slow.val / (double)(1ull<<32);
+}
+
+static double lgltlevel (LGL * lgl) {
+  return lgl->stats->tlevel.val / (double)(1ull<<32);
+}
+
+static double lglglue (LGL * lgl) {
+  return lgl->stats->glue.slow.val / (double)(1ull<<32);
+}
+
+static void lglrephead (LGL * lgl) {
+  if (lgl->tid > 0) return;
+  lgl->repforcehead = 0;
+  lgl->repcntdown = REPMOD;
+  if (lgl->tid > 0) return;
+  if (lgl->cbs && lgl->cbs->msglock.lock)
+    lgl->cbs->msglock.lock (lgl->cbs->msglock.state);
+  assert (lgl->prefix);
+  fprintf (lgl->out, "%s\n", lgl->prefix);
+  fprintf (lgl->out, "%s%s"
+" seconds         irredundant            redundant clauses   glue"
+"   iterations\"      MB    stability\n",
+    lgl->prefix, !lgl->tid ? "  " : "");
+  fprintf (lgl->out, "%s%s"
+"         variables clauses conflicts  large ternary binary "
+"    jlevel       jlevel'  agility     tlevel\n",
+    lgl->prefix, !lgl->tid ? "  " : "");
+  fprintf (lgl->out, "%s\n", lgl->prefix);
+  fflush (lgl->out);
+  if (lgl->cbs && lgl->cbs->msglock.unlock)
+    lgl->cbs->msglock.unlock (lgl->cbs->msglock.state);
+}
+
+#ifndef NLGLOG
+static double lglitavg (LGL * lgl) {
+  return lgl->stats->its.avg.slow.val / (double)(1ull<<32);
+}
+#endif
+
+static double lglitder (LGL * lgl) {
+  return 10000.0 * lglavg (lgl->stats->its.avg.diff.smoothed.val / (double)(1ull<<32), lgl->stats->confs);
+}
+
+static double lgljlevelder (LGL * lgl) {
+  return lgl->stats->jlevel.diff.smoothed.val / (double)(1ll<<32);
+}
+
+static void lglrep (LGL * lgl, int level, char type) {
+  if (lgl->opts->verbose.val < level) return;
+  if ((level > 0 && lgl->repforcehead) || !lgl->repcntdown--)
+    lglrephead (lgl);
+  lglprt (lgl, level,
+    " %c"	// type
+    " %6.1f"	// time
+    " %7d"	// rem
+    " %8d"	// irr
+    " %9lld"	// confs
+    " %7d"	// lrg
+    " %6d"	// trn
+    " %5d"	// bin
+    " %4.0f"	// glue
+    " %5.0f"	// height
+    " %6.0f"	// it"
+    " %5.0f"	// jl'
+    " %4.0f"	// mb
+    " %3.0f"	// agility
+    " %5.0f"	// stability
+    " %6.0f"	// trail
+    ,
+    type,
+    lgl->opts->abstime.val ? lglgetime (lgl) : lglsec (lgl),
+    lglrem (lgl),
+    lgl->stats->irr.clauses.cur,
+    (LGLL) lgl->stats->confs,
+    lgl->stats->red.lrg,
+    lgl->stats->red.trn,
+    lgl->stats->red.bin,
+    lglglue (lgl),
+    lglheight (lgl),
+    lglitder (lgl),
+    lgljlevelder (lgl),
+    lglmb (lgl),
+    100.0*(lgl->stats->agility/(double)(1ll<<32)),
+    1000.0*(lgl->stats->stability.avg.val/(double)(1ll<<32)),
+    lgltlevel (lgl)
+    );
+  lgl->stats->reported++;
+}
+
+static void lglflshrep (LGL * lgl) {
+  if (!lgl->stats->reported) return;
+  if (lgl->stats->reported % REPMOD) lglrephead (lgl);
+  else lglprt (lgl, 1, "");
+}
+
+static void lglfitlir (LGL * lgl, Stk * lir) {
+  lglfitstk (lgl, lir);
+}
+
+static void lglchkred (LGL * lgl) {
+#ifndef NDEBUG
+  int glue, idx, sign, lit, thisum, sum, sum2, sum3;
+  int blit, tag, red, other, other2;
+  int * p, * c, * w, * eow;
+  HTS * hts;
+  Stk * lir;
+  if (lgl->mt) return;
+  sum = 0;
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    lir = lgl->red + glue;
+    thisum = 0;
+    for (c = lir->start; c < lir->top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      while (*p) p++;
+      assert (p - c >= 4);
+      thisum++;
+    }
+    assert (thisum == lgl->stats->lir[glue].clauses);
+    sum += thisum;
+  }
+  assert (sum == lgl->stats->red.lrg);
+  sum2 = sum3 = 0;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	red = blit & REDCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (!red || tag == LRGCS || tag == OCCS) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	if (tag == BINCS) sum2++;
+	else {
+	  assert (tag == TRNCS);
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	  sum3++;
+	}
+      }
+    }
+  assert (sum2 == lgl->stats->red.bin);
+  assert (sum3 == lgl->stats->red.trn);
+#endif
+}
+
+static void lglinitredl (LGL * lgl) {
+  lgl->limits->reduce.redlarge = lgl->opts->reduceinit.val;
+  lglprt (lgl, 2,
+    "[set-reduce-limit] initial reduce limit of %lld after %lld conflicts",
+    (LGLL) lgl->limits->reduce.redlarge, (LGLL) lgl->stats->confs);
+}
+
+static int lglmemout (LGL * lgl) {
+  size_t cur;
+  int res;
+  if (lgl->opts->memlim.val < 0) return 0;
+  cur = lgl->stats->bytes.current;
+  cur >>= 20;
+  res = (cur >= lgl->opts->memlim.val);
+  if (res)
+    lglprt (lgl, 2, "memory limit of %d MB hit after allocating %lld MB",
+      lgl->opts->memlim.val, (LGLL) cur);
+  return res;
+}
+
+static Val lgliphase (LGL * lgl, int lit) {
+  Val res = lglavar (lgl, lit)->phase;
+  if (lit < 0) res = -res;
+  return res;
+}
+
+static void lglretire (LGL * lgl) {
+  int count, ready, inactive, glue, * p, * c, act;
+  const int retireint = lgl->opts->retireint.val;
+  Stk * s;
+  assert (lgl->opts->retirenb.val);
+  count = ready = inactive = 0;
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    s = lgl->red + glue;
+    for (c = s->start; c < s->top; c = p + 1) {
+      act = *(p = c);
+      if (act <= NOTALIT + retireint) {
+	count++;
+	inactive++;
+	assert (lglisact (act));
+	if (act <= NOTALIT + 1) { act = NOTALIT; ready++; } else act--;
+	assert (lglisact (act));
+	*p++ = act;
+      } 
+      else if (act < REMOVED) {
+	count++;
+	act = NOTALIT + retireint + (act - NOTALIT - retireint)/2;
+	assert (lglisact (act));
+	*p++ = act;
+      } 
+      while (*p) p++;
+    }
+  }
+  lglprt (lgl, 2,
+    "[reduce-%d] %d ready to retire %.0f%%, %d inactive %.0f%%",
+    lgl->stats->reduced.count,
+    ready, lglpcnt (ready, count),
+    inactive, lglpcnt (inactive, count));
+}
+
+static int lglcmpagsl (LGL * lgl, PAGSL * a, PAGSL * b) {
+  int res;
+  if ((res = b->psm - a->psm)) return res;
+  if ((res = b->glue - a->glue)) return res;
+  if ((res = a->act - b->act)) return res;
+  if ((res = b->size - a->size)) return res;
+  if ((res = a->lidx - b->lidx)) return res;
+  return 0;
+}
+
+#define LGLCMPAGSL(A,B) lglcmpagsl (lgl, (A), (B))
+
+static void lglreduce (LGL * lgl, int forced) {
+  int * p, * q, * start, * c, ** maps, * sizes, * map, * eow, * rsn;
+  int nlocked, collected, sumcollected, nunlocked, moved, act, psm;
+  int glue, target, nkeep, retired, sumretired;
+  PAGSL * pagsls, * pagsl; int npagsls, szpagsls;
+  const int retirenb = lgl->opts->retirenb.val;
+  const int retiremin = lgl->opts->retiremin.val;
+  int size, idx, tag, red, i, blit;
+  int r0, lidx, src, dst, lit;
+  int inc, delta, npromoted;
+  char type = '-';
+  HTS * hts;
+  DVar * dv;
+  Stk * lir;
+  lglchkred (lgl);
+  lglstart (lgl, &lgl->times->reduce);
+  lgl->stats->reduced.count++;
+  if (retirenb) lglretire (lgl);
+  LOG (1, "starting reduction %d", lgl->stats->reduced.count);
+  delta = lgl->stats->red.lrg;
+  delta -= lgl->lrgluereasons;
+  delta -= lgl->stats->lir[0].clauses;
+  assert (delta >= 0);
+  if (delta > 3*lgl->limits->reduce.redlarge/2)
+    target = delta - lgl->limits->reduce.redlarge/2;
+  else target = delta/2;
+  if (target < 0) target = 0;
+  lglprt (lgl, 2,
+    "[reduce-%d] target is to collect %d clauses %.0f%%",
+    lgl->stats->reduced.count, target,
+    lglpcnt (target, lgl->stats->red.lrg));
+  NEW (maps, MAXGLUE);
+  NEW (sizes, MAXGLUE);
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    lir = lgl->red + glue;
+    size = lglcntstk (lir);
+    assert (!size || size >= 6);
+    size = (size + 5)/6;
+    sizes[glue] = size;
+    lglfitstk (lgl, lir);
+    NEW (maps[glue], size);
+    map = maps[glue];
+    for (i = 0; i < size; i++) map[i] = -2;
+  }
+  nlocked = 0;
+  for (i = 0; i < lglcntstk (&lgl->trail); i++) {
+    lit = lglpeek (&lgl->trail, i);
+    idx = abs (lit);
+    rsn = lglrsn (lgl, idx);
+    r0 = rsn[0];
+    red = r0 & REDCS;
+    if (!red) continue;
+    tag = r0 & MASKCS;
+    if (tag != LRGCS) continue;
+    lidx = rsn[1];
+    glue = lidx & GLUEMASK;
+    if (glue == MAXGLUE) continue;
+    lidx >>= GLUESHFT;
+#ifndef NLGLOG
+    lir = lgl->red + glue;
+    assert (lglpeek (lir, lidx) < REMOVED);
+    LOGCLS (5, lir->start + lidx,
+      "locking reason of literal %d glue %d clause",
+      lit, glue);
+#endif
+    lidx /= 6;
+    assert (maps);
+    assert (maps[glue]);
+    assert (lidx < sizes[glue]);
+    assert (maps[glue][lidx] == -2);
+    maps[glue][lidx] = -1;
+    nlocked++;
+  }
+  lglprt (lgl, 2,
+    "[reduce-%d] locked %d learned reason clauses %.0f%%",
+     lgl->stats->reduced.count,
+     nlocked, lglpcnt (nlocked, lgl->stats->red.lrg));
+  npromoted = 0;
+  while (!lglmtstk (&lgl->promote)) {
+    lidx = lglpopstk (&lgl->promote);
+    glue = lidx & GLUEMASK;
+    assert (glue < MAXGLUE);
+    if (!maps[glue]) { assert (!sizes[glue]); continue; }
+    assert (0 < glue), assert (glue < MAXGLUE);
+    lidx >>= GLUESHFT;
+    assert (lidx > 0);
+    lir = lgl->red + glue;
+    p = lir->start + lidx;
+    if (p >= lir->top) continue;
+    if (*p >= NOTALIT) continue;
+    if (!lglisact (p[-1])) continue;
+    if (maps[glue][lidx/6] == -1) continue;
+#ifndef NLGLOG
+    LOGCLS (5, lir->start + lidx,
+      "locking promoted glue %d clause",
+      glue);
+#endif
+    assert (lidx/6 < sizes[glue]);
+    maps[glue][lidx/6] = -1;
+    lgl->stats->promote.locked++;
+    npromoted++;
+  }
+  lglprt (lgl, 2,
+    "[reduce-%d] locked %d promoted learned clauses %.0f%%",
+    lgl->stats->reduced.count,
+    npromoted, lglpcnt (npromoted, lgl->stats->red.lrg));
+
+  szpagsls = lgl->stats->red.lrg;
+  NEW (pagsls, szpagsls);
+  retired = npagsls = 0;
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    lir = lgl->red + glue;
+    start = lir->start;
+    for (c = start; c < lir->top; c = p + 1) {
+      if ((act = *c++) == REMOVED) {
+	for (p = c; p < lir->top && *p == REMOVED; p++)
+	  ;
+	p--;
+	continue;
+      }
+      LGLCHKACT (act);
+      lidx = c - start;
+      act -= NOTALIT;
+      psm = 0;
+      for (p = c; (lit = *p); p++)
+	if (lgliphase (lgl, lit) >= 0) psm++;
+      size = p - c;
+      LOG (5, 
+         "clause red[%d][%d] has: psm %d, act %d, size %d",
+	 glue, lidx, psm, act, size);
+
+      if (maps[glue][lidx/6] == -1) continue;
+      assert (maps[glue][lidx/6] == -2);
+
+      if (retirenb && !act && glue >= retiremin) {
+	retired++;
+	maps[glue][lidx/6] = -3;
+	LOG (5, "retiring this inactive clause");
+	continue;
+      }
+
+      if (!glue && size <= lgl->opts->gluekeepsize.val) {
+        LOG (5, "keeping this glue 0 size %d clause", size);
+        maps[glue][lidx/6] = -1;
+        continue;
+      }
+
+      assert (npagsls < szpagsls);
+      pagsl = pagsls + npagsls++;
+      pagsl->psm = psm;
+      pagsl->act = act;
+      pagsl->glue = glue;
+      pagsl->size = size;
+      pagsl->lidx = lidx;
+    }
+  }
+  assert (npagsls <= szpagsls);
+  LOG (2,
+    "retiring %d learned clauses %.0f%%",
+    retired, lglpcnt (retired, lgl->stats->red.lrg));
+
+  SORT (PAGSL, pagsls, npagsls, LGLCMPAGSL);
+  LOG (1, "copied and sorted %d activities", npagsls);
+
+  nkeep = 0;
+  for (idx = target; idx < npagsls; idx++) {
+    pagsl = pagsls + idx;
+    lidx = pagsl->lidx;
+    glue = pagsl->glue;
+    assert (lidx/6 < sizes[glue]);
+    maps[glue][lidx/6] = -1;
+    nkeep++;
+    LOG (5, 
+      "marked clause red[%d][%d] to keep with psm %d, act %d, size %d",
+      glue, lidx, pagsl->psm, pagsl->act, pagsl->size);
+  }
+  DEL (pagsls, szpagsls);
+  LOG (1, "explicity marked %d additional clauses to keep", nkeep);
+  sumcollected = sumretired = 0;
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    lir = lgl->red + glue;
+    map = maps[glue];
+#ifndef NDEBUG
+    size = sizes[glue];
+#endif
+    q = start = lir->start;
+    collected = retired = 0;
+    for (c = start; c < lir->top; c = p + 1) {
+      act = *c++;
+      if (act == REMOVED) {
+	for (p = c; p < lir->top && *p == REMOVED; p++)
+	  ;
+	assert (p >= lir->top || *p < NOTALIT || lglisact (*p));
+	p--;
+	continue;
+      }
+      p = c;
+      LGLCHKACT (act);
+      src = (c - start)/6;
+      assert (src < size);
+      if (map[src] <= -2) {
+	assert (collected + retired < lgl->stats->lir[glue].clauses);
+	if (map[src] == -2) {
+	  collected++;
+	  LOGCLS (5, c, "collecting glue %d clause", glue);
+	} else {
+	  assert (map[src] == -3);
+	  retired++;
+	  LOGCLS (5, c, "retiring glue %d clause", glue);
+	}
+	lgldrupligdelclsaux (lgl, c);
+	while (*p) p++;
+      } else {
+	dst = q - start + 1;
+	map[src] = dst;
+	if (p == q) {
+	  while (*p) p++;
+	  q = p + 1;
+	} else {
+	  *q++ = act;
+	  LOGCLS (5, c, "moving from %d to %d glue %d clause",
+		  (c - start), dst, glue);
+	  while (*p) *q++ = *p++;
+	  *q++ = 0;
+	}
+      }
+    }
+    LOG (2, "collected %d glue %d clauses", collected, glue);
+    assert (sumcollected + sumretired <= lgl->stats->red.lrg);
+    assert (lgl->stats->lir[glue].clauses >= collected + retired);
+    lgl->stats->lir[glue].clauses -= collected + retired;
+    lgl->stats->lir[glue].reduced += collected;
+    lgl->stats->lir[glue].retired += retired;
+    sumcollected += collected;
+    sumretired += retired;
+    lir->top = q;
+    lglfitlir  (lgl, lir);
+  }
+  lglprt (lgl, 2,
+    "[reduce-%d] collected %d clauses %.0f%%, retired %d clauses %.0f%%", 
+    lgl->stats->reduced.count,
+    sumcollected, lglpcnt (sumcollected, lgl->stats->red.lrg),
+    sumretired, lglpcnt (sumretired, lgl->stats->red.lrg));
+  assert (sumcollected + sumretired <= lgl->stats->red.lrg);
+  lgl->stats->red.lrg -= sumcollected + sumretired;
+  lgl->stats->reduced.collected += sumcollected;
+  lgl->stats->reduced.retired += sumretired;
+  nunlocked = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglval (lgl, idx)) continue;
+    rsn = lglrsn (lgl, idx);
+    r0 = rsn[0];
+    red = r0 & REDCS;
+    if (!red) continue;
+    tag = r0 & MASKCS;
+    if (tag != LRGCS) continue;
+    lidx = rsn[1];
+    glue = lidx & GLUEMASK;
+    if (glue == MAXGLUE) continue;
+    src = (lidx >> GLUESHFT);
+    assert (src/6 < sizes[glue]);
+    dst = maps[glue][src/6];
+    assert (dst >= 0);
+    dst <<= GLUESHFT;
+    dst |= lidx & GLUEMASK;
+    rsn[1] = dst;
+    nunlocked++;
+  }
+  LOG (2, "unlocked %d reasons", nunlocked);
+  assert (nlocked == nunlocked);
+  collected = moved = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    dv = lgldvar (lgl, idx);
+    for (i = 0; i <= 1; i++) {
+      hts = dv->hts + i;
+      if (!hts->offset) continue;
+      q = lglhts2wchs (lgl, hts);
+      assert (hts->count >= 0);
+      eow = q + hts->count;
+      for (p = q; p < eow; p++) {
+	blit = *p;
+	red = blit & REDCS;
+	tag = blit & MASKCS;
+	if (red && tag == LRGCS) {
+	  lidx = *++p;
+	  glue = lidx & GLUEMASK;
+	  if (glue == MAXGLUE) {
+	    dst = lidx >> GLUESHFT;
+	  } else {
+	    src = lidx >> GLUESHFT;
+	    assert (src/6 < sizes[glue]);
+	    dst = maps[glue][src/6];
+	  }
+	  if (dst >= 0) {
+	    moved++;
+	    *q++ = blit;
+	    *q++ = (dst << GLUESHFT) | (lidx & GLUEMASK);
+	  } else collected++;
+	} else {
+	  *q++ = blit;
+	  if (tag != BINCS) {
+	    assert (tag == TRNCS || tag == LRGCS);
+	    *q++ = *++p;
+	  }
+	}
+      }
+      lglshrinkhts (lgl, hts, hts->count - (p - q));
+    }
+  }
+  LOG (1, "moved %d and collected %d occurrences", moved, collected);
+  for (glue = 0; glue < MAXGLUE; glue++)
+    DEL (maps[glue], sizes[glue]);
+  DEL (sizes, MAXGLUE);
+  DEL (maps, MAXGLUE);
+  if (lgl->opts->reducefixed.val) goto NOINC;
+  if (!lgl->limits->reduce.reset) lgl->limits->reduce.reset = 1;
+  if (lgl->stats->reduced.count >= lgl->limits->reduce.reset)
+    lgl->limits->reduce.reset <<= 1;
+  if ((lgl->opts->reducereset.val == 1 &&
+       lglispow2 (lgl->stats->reduced.count)) ||
+      (lgl->opts->reducereset.val == 2 &&
+       lglispow2 (lgl->stats->reduced.count &
+                  ((lgl->stats->reduced.count-1))))) {
+    lgl->limits->reduce.redlarge = 0;
+    inc = lgl->opts->reduceinc.val;
+    lgl->stats->reduced.reset++;
+    lglprt (lgl, 2, "[reduce-%d] reset", lgl->stats->reduced.count);
+  } else if (lglmemout (lgl)) {
+    inc = 0;
+    lglprt (lgl, 2,
+      "[reduce-%d] no increase of reduce limit since memory limit was hit",
+      lgl->stats->reduced.count);
+    lgl->stats->reduced.memlim++;
+  } else {
+    inc = lgl->opts->reduceinc.val;
+    lglprt (lgl, 2,
+      "[reduce-%d] increase of reduce limit by %d to %d",
+      lgl->stats->reduced.count, inc, lgl->limits->reduce.redlarge + inc);
+    lgl->stats->reduced.arith++;
+  }
+  LOG (1, "reduce increment %d", inc);
+  lgl->limits->reduce.redlarge += inc;
+  assert (forced || lgl->opts->reduce.val);
+NOINC:
+  lglrelstk (lgl, &lgl->learned);
+  lglrep (lgl, 1, type);
+  lglchkred (lgl);
+  lglstop (lgl);
+#ifndef NDEBUG
+  lglclnstk (&lgl->prevclause);
+  lgl->prevglue = -1;
+#endif
+}
+
+void lglreducecache (LGL * lgl) {
+  REQINITNOTFORKED ();
+  TRAPI ("reduce");
+  if (lgl->mt) return;
+  lglinitredl (lgl);
+  lglreduce (lgl, 1);
+  lglinitredl (lgl);
+  lglprt (lgl, 1, "[reduce-cache] new limit %d", lgl->limits->reduce.redlarge);
+  if (lgl->clone) lglreducecache (lgl->clone);
+}
+
+static void lgliflushcache (LGL * lgl, int keep) {
+  int idx, sign, lit, blit, tag, red, * w, * q, lidx, glue;
+  const int druplig = lgl->opts->druplig.val;
+  int bin, trn, lrg, start;
+  const int * p, * eow;
+  HTS * hts;
+  assert (1 <= keep), assert (keep <= 4);
+  if (lgl->level) lglbacktrack (lgl, 0);
+  bin = trn = lrg = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      q = w;
+      for (p = q; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	red = blit & REDCS;
+	if (red) {
+	  if (tag == BINCS) {
+	    if (keep < 2) {
+	      if (druplig) {
+		int other = blit >> RMSHFT;
+		if (idx < abs (other))
+		  lgldrupligdelclsarg (lgl, lit, other, 0);
+	      }
+	      continue;
+	    }
+	  } else if (tag == TRNCS) {
+	    if (keep < 3) {
+	      if (druplig) {
+		int other = blit >> RMSHFT;
+		if (idx < abs (other)) {
+		  int other2 = *p;
+		  if (idx < abs (other2))
+		    lgldrupligdelclsarg (lgl, lit, other, other2, 0);
+		}
+	      }
+	      continue;
+	    }
+	  } else {
+	    assert (tag == LRGCS);
+	    lidx = *p;
+	    glue = lidx & GLUEMASK;
+	    if (keep < 4 || glue > 0) {
+	      if (druplig) {
+                const int * c = lglidx2lits (lgl, red, lidx);
+		if (*c == lit)
+		  lgldrupligdelclsaux (lgl, c);
+	      }
+	      continue;
+	    }
+	  }
+	}
+	*q++ = blit;
+	if (tag == TRNCS || tag == LRGCS) *q++ = *p;
+      }
+      lglshrinkhts (lgl, hts, q - w);
+    }
+  }
+  if (keep < 2) bin = lgl->stats->red.bin, lgl->stats->red.bin = 0;
+  if (keep < 3) trn = lgl->stats->red.trn, lgl->stats->red.trn = 0;
+  start = (keep >= 4);
+  for (glue = start; glue < MAXGLUE; glue++) {
+    lrg += lgl->stats->lir[glue].clauses;
+    lgl->stats->lir[glue].clauses = 0;
+  }
+  assert (lrg <= lgl->stats->red.lrg), lgl->stats->red.lrg -= lrg;
+  lglrelstk (lgl, &lgl->learned);
+  for (glue = start; glue < MAXGLUE; glue++)
+    lglrelstk (lgl, lgl->red + glue);
+  lglprt (lgl, 1,
+    "[flush-cache] %d binary, %d ternary, %d large",
+    bin, trn, lrg);
+#ifndef NDEBUG
+  lglclnstk (&lgl->prevclause);
+  lgl->prevglue = -1;
+#endif
+}
+
+void lglflushcache (LGL * lgl) {
+  REQINITNOTFORKED ();
+  TRAPI ("flush");
+  if (lgl->mt) return;
+  lglinitredl (lgl);
+  lgliflushcache (lgl, 3);
+  lglinitscores (lgl);
+  lglinitredl (lgl);
+  lglprt (lgl, 1, "[flush-cache] new limit %d", lgl->limits->reduce.redlarge);
+  if (lgl->clone) lglflushcache (lgl->clone);
+}
+
+
+static void lglrmbwch (LGL * lgl, int lit, int other, int red) {
+  int * p, blit, blit1, * w, * eow, tag;
+  HTS * hts;
+  assert (!red || red == REDCS);
+  LOG (3, "removing %s binary watch %d blit %d",
+       lglred2str (red), lit, other);
+  hts = lglhts (lgl, lit);
+  assert (hts->count >= 1);
+  p = w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  lglrminc (lgl, w, eow);
+  blit1 = RMSHFTLIT (other) | red | BINCS;
+  for (;;) {
+    assert (p < eow);
+    blit = *p++;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) { p++; continue; }
+    if (tag == OCCS) { assert (lgl->dense); continue; }
+    assert (tag == BINCS);
+    if (blit == blit1) break;
+  }
+  while (p < eow) p[-1] = p[0], p++;
+  lglshrinkhts (lgl, hts, p - w - 1);
+}
+
+static int lglpopesched (LGL * lgl) {
+  Stk * s = &lgl->esched;
+  int res, last, cnt, * p;
+  EVar * ev;
+  assert (!lglmtstk (s));
+  res = *s->start;
+  assert (!lglifrozen (lgl, res));
+  LOGESCHED (4, res, "popped");
+  ev = lglevar (lgl, res);
+  assert (!ev->pos);
+  ev->pos = -1;
+  last = lglpopstk (s);
+  cnt = lglcntstk (s);
+  if (!cnt) { assert (last == res); return res; }
+  p = lglepos (lgl, last);
+  assert (*p == cnt);
+  *p = 0;
+  *s->start = last;
+  lgledown (lgl, last);
+  return res;
+}
+
+static void lgldecocc (LGL * lgl, int lit) {
+  int idx, sign, change;
+  EVar * ev;
+  if (!lgl->occs) return;
+  idx = abs (lit), sign = (lit < 0);
+  ev = lglevar (lgl, lit);
+  assert (ev->occ[sign] > 0);
+  ev->occ[sign] -= 1;
+  if (!lglisfree (lgl, lit)) return;
+  change = lglecalc (lgl, ev);
+  LOG (3, "dec occ of %d now occs[%d] = %d %d",
+       lit, idx,  ev->occ[0], ev->occ[1]);
+  if (ev->pos < 0) lglesched (lgl, idx);
+  else if (change < 0) lgleup (lgl, idx);
+  else if (change > 0) lgledown (lgl, idx);
+}
+
+static void lglrmbcls (LGL * lgl, int a, int b, int red) {
+  lglrmbwch (lgl, a, b, red);
+  lglrmbwch (lgl, b, a, red);
+  LOG (2, "removed %s binary clause %d %d", lglred2str (red), a, b);
+  lgldeclscnt (lgl, 2, red, 0);
+  if (!red && lgl->dense) lgldecocc (lgl, a), lgldecocc (lgl, b);
+}
+
+static void lglrmtcls (LGL * lgl, int a, int b, int c, int red) {
+  lglrmtwch (lgl, a, b, c, red);
+  lglrmtwch (lgl, b, a, c, red);
+  lglrmtwch (lgl, c, a, b, red);
+  LOG (2, "removed %s ternary clause %d %d %d", lglred2str (red), a, b, c);
+  lgldeclscnt (lgl, 3, red, 0);
+  if (!red && lgl->dense)
+    lgldecocc (lgl, a), lgldecocc (lgl, b), lgldecocc (lgl, c);
+}
+
+static void lgltrimlitstk (LGL * lgl, int red, int lidx) {
+  Stk * s;
+  int * p;
+  if (lgl->notrim) return;
+  s = lglidx2stk (lgl, red, lidx);
+  p = s->top;
+  while (p > s->start && p[-1] == REMOVED)
+    p--;
+  if (p < s->top) {
+    int64_t trimmed = s->top - p;
+#ifndef NLGLOG
+    if (red)
+       LOG (4,
+         "trimmed 'red[%d]' by %lld", 
+         (lidx & GLUEMASK), (LGLL) trimmed);
+    else LOG (4, "trimmed 'irr' by %lld", (LGLL) trimmed);
+#endif
+    lgl->stats->trims += trimmed;
+    s->top = p;
+    if (red) {
+      int glue = (lidx & GLUEMASK), maxlidx;
+      assert (s == &lgl->red[glue]);
+      maxlidx = (lglcntstk (s) << GLUESHFT) | glue;
+      for (p = lgl->learned.start; p < lgl->learned.top; p += 3) {
+       int olidx = *p, oglue = (olidx & GLUEMASK);
+       if (oglue == glue && olidx >= maxlidx) *p = INT_MIN;
+      }
+    }
+  }
+}
+
+static void lglrmlcls (LGL * lgl, int lidx, int red) {
+  int * c, * p, glue, lit;
+  assert (!red || red == REDCS);
+  glue = red ? (lidx & GLUEMASK) : 0;
+  c = lglidx2lits (lgl, red, lidx);
+  if (!red || glue < MAXGLUE) {
+    lglrmlwch (lgl, c[0], red, lidx);
+    lglrmlwch (lgl, c[1], red, lidx);
+  }
+  if (!red && lgl->dense) {
+    for (p = c; (lit = *p); p++) {
+      lglrmlocc (lgl, lit, red, lidx);
+      lgldecocc (lgl, lit);
+    }
+  }
+  if (red && glue < MAXGLUE) { LGLCHKACT (c[-1]); c[-1] = REMOVED; }
+  for (p = c; *p; p++) *p = REMOVED;
+  *p = REMOVED;
+  if (glue != MAXGLUE) lgldeclscnt (lgl, p - c, red, glue);
+  lgltrimlitstk (lgl, red, lidx);
+}
+
+static void lgldynsub (LGL * lgl, int lit, int r0, int r1) {
+  int red, tag, other, other2;
+  const int * c;
+  tag = r0 & MASKCS;
+  LOGREASON (2, lit, r0, r1, "removing on-the-fly subsumed");
+  red = r0 & REDCS;
+  if (red) lgl->stats->otfs.sub.red++;
+  else lgl->stats->otfs.sub.irr++;
+  if (tag == BINCS) {
+    lgl->stats->otfs.sub.bin++;
+    other = (r0 >> RMSHFT);
+    lgldrupligdelclsarg (lgl, lit, other, 0);
+    lglrmbcls (lgl, lit, other, red);
+  } else if (tag == TRNCS) {
+    lgl->stats->otfs.sub.trn++;
+    other = (r0 >> RMSHFT), other2 = r1;
+    lgldrupligdelclsarg (lgl, lit, other, other2, 0);
+    lglrmtcls (lgl, lit, other, other2, red);
+  } else { 
+    assert (tag == LRGCS);
+    lgl->stats->otfs.sub.lrg++;
+    c = lglidx2lits (lgl, red, r1);
+    lgldrupligdelclsaux (lgl, c);
+    lglrmlcls (lgl, r1, red);
+  }
+}
+
+
+static void lglunflict (LGL * lgl, int lit) {
+  lgl->conf.lit = lit;
+  lgl->conf.rsn[0] = RMSHFTLIT (lit) | UNITCS;
+  LOG (1, "inconsistent unary clause %d", lit);
+}
+
+static void lgldynstr (LGL * lgl, int del, int lit, int r0, int r1) {
+  int * p, * c, lidx, other, red, tag, glue, other2, other3, blit;
+  tag = r0 & MASKCS;
+  LOGREASON (2, lit, r0, r1,
+    "on-the-fly strengthening by removing %d from", del);
+  red = r0 & REDCS;
+  if (red) lgl->stats->otfs.str.red++;
+  else lgl->stats->otfs.str.irr++;
+  lgl->stats->otfs.total++;
+  lgl->stats->prgss++;
+  if (!red) lgl->stats->irrprgss++;
+  if (tag == BINCS) {
+    lgl->stats->otfs.str.bin++;
+    other = (del == lit) ? (r0 >> RMSHFT) : lit;
+    assert (other != del);
+    lgldrupligaddclsarg (lgl, REDCS, other, 0);
+    lgldrupligdelclsarg (lgl, del, other, 0);
+    lglrmbcls (lgl, del, other, red);
+    lglunflict (lgl, other);
+    return;
+  }
+  if (tag == TRNCS) {
+    lgl->stats->otfs.str.trn++;
+    if (lit == del) other = (r0 >> RMSHFT), other2 = r1;
+    else if (del == r1) other = lit, other2 = (r0 >> RMSHFT);
+    else other = lit, other2 = r1;
+    assert (del != other && del != other2);
+    lgldrupligaddclsarg (lgl, REDCS, other, other2, 0);
+    lgldrupligdelclsarg (lgl, del, other, other2, 0);
+    lglrmtcls (lgl, del, other, other2, red);
+    if (!red) lglincirr (lgl, 2);
+    else lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+    lglwchbin (lgl, other, other2, red);
+    lglwchbin (lgl, other2, other, red);
+    if (lglevel (lgl, other) < lglevel (lgl, other2)) SWAP (int, other, other2);
+    blit = RMSHFTLIT (other2) | BINCS | red;
+    lglbonflict (lgl, other, blit);
+    return;
+  }
+  assert (tag == LRGCS);
+  lgl->stats->otfs.str.lrg++;
+  lidx = r1;
+  glue = red ? (lidx & GLUEMASK) : 0;
+  c = lglidx2lits (lgl, red, lidx);
+  for (p = c; *p != del; p++)
+    assert (*p);
+  if (glue < MAXGLUE) {
+    lglrmlwch (lgl, c[0], red, lidx);
+    lglrmlwch (lgl, c[1], red, lidx);
+  }
+  while ((other = *++p)) p[-1] = other;
+  p[-1] = 0, *p = REMOVED;
+  lgltrimlitstk (lgl, red, lidx);
+  if (!red) assert (lgl->stats->irr.lits.cur), lgl->stats->irr.lits.cur--;
+  lglorderclsaux (lgl, c + 0);
+  lglorderclsaux (lgl, c + 1);
+  lgldrupligaddclsaux (lgl, REDCS, c);
+  assert (p - c > 3);
+  if (p - c == 4) {
+    assert (!c[3] && c[4] >= NOTALIT);
+    other = c[0], other2 = c[1], other3 = c[2];
+    if (red && glue < MAXGLUE) { LGLCHKACT (c[-1]); c[-1] = REMOVED; }
+    c[0] = c[1] = c[2] = c[3] = REMOVED;
+    lgltrimlitstk (lgl, red, lidx);
+    if (lglevel (lgl, other2) < lglevel (lgl, other3))
+      SWAP (int, other2, other3);
+    if (lglevel (lgl, other) < lglevel (lgl, other2))
+      SWAP (int, other, other2);
+    lglwchtrn (lgl, other, other2, other3, red);
+    lglwchtrn (lgl, other2, other, other3, red);
+    lglwchtrn (lgl, other3, other, other2, red);
+    if (red) {
+      if (glue < MAXGLUE) {
+	assert (lgl->stats->red.lrg > 0);
+	lgl->stats->red.lrg--;
+	assert (lgl->stats->lir[glue].clauses > 0);
+	lgl->stats->lir[glue].clauses--;
+      }
+      lgl->stats->red.trn++;
+      assert (lgl->stats->red.trn > 0);
+    }
+    lgltonflict (lgl, other, RMSHFTLIT (other2) | red | TRNCS, other3);
+  } else {
+    if (glue < MAXGLUE) {
+      LOG (3, "new head literal %d", c[0]);
+      (void) lglwchlrg (lgl, c[0], c[1], red, lidx);
+      LOG (3, "new tail literal %d", c[1]);
+      (void) lglwchlrg (lgl, c[1], c[0], red, lidx);
+    }
+    lglonflict (lgl, 0, c[0], red, lidx);
+  }
+}
+
+static void lglclnframes (LGL * lgl) {
+  while (!lglmtstk (&lgl->frames))
+    lglunuselevel (lgl, lglpopstk (&lgl->frames));
+}
+
+static void lglclnpoisoned (LGL * lgl) {
+  while (!lglmtstk (&lgl->poisoned)) {
+    int lit = lglpopstk (&lgl->poisoned);
+    AVar * av = lglavar (lgl, lit);
+    assert (!av->mark);
+    assert (av->poisoned);
+    av->poisoned = 0;
+  }
+}
+
+static void lglclnana (LGL * lgl) {
+#ifdef RESOLVENT
+  if (lglmaintainresolvent (lgl)) lglclnstk (&lgl->resolvent);
+#endif
+  lglclnstk (&lgl->clause);
+  lglpopnunmarkstk (lgl, &lgl->seen);
+  lglclnframes (lgl);
+}
+
+static void lglbumpdlit (LGL * lgl, int lit) {
+  int idx = abs (lit), mightneedtorescore = 0;
+  QVar * qv = lglqvar (lgl, idx);
+  Flt oldscore, newscore;
+  if (lgl->simp && !lgl->opts->bumpsimp.val) return;
+  if (qv->enqueued) {
+    assert (lglpeek (&lgl->queue.stk, qv->pos) == abs (lit));
+    lglpoke (&lgl->queue.stk, qv->pos, 0);
+    lgl->queue.mt++;
+    qv->enqueued = 0;
+    qv->pos = -1;
+    if (!lglval (lgl, lit)) lgldsched (lgl, idx);
+  }
+  oldscore = qv->score;
+  newscore = lgladdflt (oldscore, lgl->scinc);
+  LOG (3,
+    "bumping EVSIDS score of variable %d from %s to %s",
+    idx, lglscr2str (lgl, oldscore), lglscr2str (lgl, newscore));
+  assert (newscore > oldscore);
+  mightneedtorescore = 1;
+  qv->score = newscore;
+  if (lgldscheduled (lgl, idx)) lgldup (lgl, idx);
+  if (mightneedtorescore && newscore >= lgl->maxscore) lglrescorevars (lgl);
+}
+
+static void lglbumpreasonlit (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  if (av->mark) return;
+  if (!lglevel (lgl, lit)) return;
+  av->mark = 1;
+  lglpushstk (lgl, &lgl->seen, lit);
+  LOG (2, "also bumping reason literal %d", lit);
+}
+
+static void lglbumpreason (LGL * lgl, int lit) {
+  int * rsn, tag, other, found;
+  const int * p;
+  rsn = lglrsn (lgl, lit);
+  tag = rsn[0] & MASKCS;
+  if (tag == DECISION) return;
+  if (tag == BINCS || tag == TRNCS) {
+    lglbumpreasonlit (lgl, rsn[0] >> RMSHFT);
+    if (tag == TRNCS) lglbumpreasonlit (lgl, rsn[1]);
+  } else {
+    assert (tag == LRGCS);
+    p = lglidx2lits (lgl, (rsn[0] & REDCS), rsn[1]);
+    found = 0;
+    while ((other = *p++)) {
+      if (other == -lit) found++;
+      else lglbumpreasonlit (lgl, other);
+    }
+    assert (found == 1);
+  }
+}
+
+static void lglbumpreasonlits (LGL * lgl) {
+  int n = lglcntstk (&lgl->seen);
+  const int * p = lgl->clause.start;
+  while (*p) lglbumpreason (lgl, *p++);
+  for (p = lgl->seen.start + n; p < lgl->seen.top; p++) {
+    AVar * av = lglavar (lgl, *p);
+    assert (av->mark);
+    av->mark = 0;
+  }
+  LOG (2, "also bumping %d literals", (int)(lglcntstk (&lgl->seen) - n));
+}
+
+static int lglcmpbump (LGL * lgl, int a, int b) {
+#if 0
+  return lgltrail (lgl, b) - lgltrail (lgl, a);
+#else
+  return lgldcmp (lgl, a, b);
+#endif
+}
+
+#define LGLCMPBUMP(P,Q) lglcmpbump (lgl, *(P), *(Q))
+
+static void lglbumpseenlits (LGL * lgl) {
+  const int * p;
+  if (lgl->simp && !lgl->opts->bumpsimp.val) return;
+  lglstart (lgl, &lgl->times->bump);
+  lgl->stats->bump.count++;
+  if (lgl->opts->bumpreasonlits.val) lglbumpreasonlits (lgl);
+  SORT (int, lgl->seen.start, lglcntstk (&lgl->seen), LGLCMPBUMP);
+  for (p = lgl->seen.start; p < lgl->seen.top; p++)
+    lglbumpdlit (lgl, *p);
+  LOG (2, "bumped %d literals", lglcntstk (&lgl->seen));
+  lgl->stats->bump.lits += lglcntstk (&lgl->seen);
+  lglstop (lgl);
+}
+
+static void lglmincls (LGL * lgl, int uip, int glue) {
+  int origsize = lglcntstk (&lgl->clause) - 1;
+  int * p, * q, other, minimized, local;
+  if (!lgl->opts->minimize.val) return;
+  if (glue > lgl->opts->minlocalgluelim.val) return;
+  if (origsize > lgl->opts->minlocalsizelim.val) return;
+  lglstart (lgl, &lgl->times->mincls);
+  lgl->stats->mincls.min++;
+  q = lgl->clause.start;
+  minimized = 0;
+  local = lgl->opts->minimize.val <= 1 || 
+          glue > lgl->opts->minrecgluelim.val ||
+          origsize > lgl->opts->minrecsizelim.val;
+  assert (lglmtstk (&lgl->poisoned));
+  for (p = q; (other = *p); p++)
+    if (other != uip && lglminclslit (lgl, other, local)) {
+      LOG (2, "minimized literal %d", other);
+      minimized++;
+    } else *q++ = other;
+  *q++ = 0;
+  lglclnpoisoned (lgl);
+  assert (lgl->clause.top - q == minimized);
+  COVER (glue + 1 >= origsize && minimized > 0);	// unreachable ...
+  LOG (2, "clause minimized by %d literals", minimized);
+  LOGCLS (2, lgl->clause.start, "minimized clause");
+  lgl->clause.top = q;
+  lglstop (lgl);
+}
+
+static void lglsignedmarknpushseen (LGL *, int);
+static int lglsignedmarked (LGL *, int);
+
+static int lglcmpuiplitrail (LGL * lgl, int uip, int a, int b) {
+  if (a == uip) return -1;
+  if (b == uip) return 1;
+  return lgltrail (lgl, a) - lgltrail (lgl, b);
+}
+
+#define LGLCMPUIPLITRAIL(P,Q) lglcmpuiplitrail (lgl, uip, *(P), *(Q))
+
+static void lglredclsassign (LGL * lgl, int lit) {
+  assert (!lglmarked (lgl, lit)), assert (!lglifixed (lgl, lit));
+  lglmark (lgl, lit);
+  lglpushstk (lgl, &lgl->seen, lit);
+  LOG (3, "assigning literal %d for clause reduction", lit);
+}
+
+static int lglredclsmarked (LGL * lgl, int lit) {
+  int mark, val;
+  mark = lglmarked (lgl, lit);
+  if (mark) return mark;
+  val = lglifixed (lgl, lit);
+  if (val) return val;
+  return 0;
+}
+
+static void lglredcls (LGL * lgl, int uip, int glue, int * jlevelptr) {
+  int lit, cand, blit, tag, other, other2, count, size, reduced;
+  int * q, newjlevel, oldjlevel, level, sat, red, lidx, unit;
+  int dec, depth, props, mark, mark2, markcand, lrg;
+  const int * p, * w, * eow, * r, * l, * c;
+  HTS * hts;
+  const int maxdepth = lgl->opts->redclsmaxdepth.val;
+  const int maxprops = lgl->opts->redclsmaxprops.val;
+  const int maxlrg = lgl->opts->redclsmaxlrg.val;
+  const int maxdec = lgl->opts->redclsmaxdec.val;
+  const int type = lgl->opts->redclstype.val;
+  if (!lgl->opts->redcls.val) return;
+  if (glue > lgl->opts->redclsglue.val) return;
+  if (lglcntstk (&lgl->clause) >= lgl->opts->redclsize.val) return;
+  lglstart (lgl, &lgl->times->redcls);
+  lgl->stats->redcls.cls.tried++;
+  lglpopnunmarkstk (lgl, &lgl->seen);
+  size = lglcntstk (&lgl->clause) - 1;
+  assert (size >= 1);
+  SORT (int, lgl->clause.start, size, LGLCMPUIPLITRAIL);
+  assert (lglpeek (&lgl->clause, 0) == uip);
+#ifndef NLGLOG
+  if (lgl->opts->log.val >= 2) {
+    lglogstart (lgl, 2, "sorted clause before reducing");
+    for (p = lgl->clause.start; p < lgl->clause.top; p++) {
+      if (!(lit = *p)) continue;
+      fprintf (lgl->out, " %d (l%d,t%d)",
+        lit, lglevel (lgl, lit), lgltrail (lgl, lit));
+    }
+    lglogend (lgl);
+  }
+#endif
+  sat = reduced = 0;
+  assert (lgl->clause.start < lgl->clause.top);
+  assert (!lgl->clause.top[-1]);
+  dec = 0;
+  for (p = q = lgl->clause.start; p < lgl->clause.top; p++) {
+    if (!(cand = *p)) *q++ = cand;
+    else {
+      lgl->stats->redcls.lits.tried++;
+      markcand = lglredclsmarked (lgl, cand);
+      if (markcand > 0) {
+	LOG (3, "skipping true literal %d for clause reduction", cand);
+	lgl->stats->redcls.lits.sat++;
+	*q++ = cand;
+	sat = 1;
+      } else if (markcand < 0) {
+	LOG (3, "reducing clause by removing literal %d", cand);
+	lgl->stats->redcls.lits.red++;
+	reduced++;
+      } else {
+	assert (!markcand);
+	*q++ = cand;
+	assert (p + 1 < lgl->clause.top);
+	if (!p[1]) continue;
+	if (++dec > maxdec) continue;
+	LOG (3, "decision literal %d for clause reduction", -cand);
+	depth = props = lrg = 0;
+	count = lglcntstk (&lgl->seen);
+	lglredclsassign (lgl, -cand);
+	while (count < lglcntstk (&lgl->seen)) {
+	  if (props >= maxprops) break;
+	  if (depth >= maxdepth) break;
+	  lit = lglpeek (&lgl->seen, count++);
+	  if (lit) props++; else { depth++; continue; }
+	  assert (lglredclsmarked (lgl, lit) > 0);
+	  LOG (4, "propagating literal %d for clause reduction", lit);
+	  hts = lglhts (lgl, -lit);
+	  w = lglhts2wchs (lgl, hts);
+	  eow = w + hts->count;
+	  for (r = w; r < eow; r++) {
+	    blit = *r;
+	    tag = blit & MASKCS;
+	    if (tag == TRNCS || tag == LRGCS) r++;
+	    if (tag == BINCS) {
+	      other = blit >> RMSHFT;
+	      if (lglredclsmarked (lgl, other)) continue;
+	      lglredclsassign (lgl, other);
+	    } else if (tag == TRNCS) {
+	      if (cand != uip || type < 3) continue;
+	      other = blit >> RMSHFT;
+	      mark = lglredclsmarked (lgl, (other));
+	      if (mark > 0) continue;
+	      other2 = *r;
+	      mark2 = lglredclsmarked (lgl, other2);
+	      if (mark2 > 0) continue;
+	      if (mark2 < 0 && !mark) lglredclsassign (lgl, other);
+	      if (mark < 0 && !mark2) lglredclsassign (lgl, other2);
+	    } else {
+	      assert (tag == LRGCS);
+	      if (type < 4 || cand != uip) continue;
+	      if (++lrg >= maxlrg) continue;
+	      other = blit >> RMSHFT;
+	      mark = lglredclsmarked (lgl, other);
+	      if (mark > 0) continue;
+	      red = blit & REDCS;
+	      lidx = *r;
+	      c = lglidx2lits (lgl, red, lidx);
+	      unit = 0;
+	      for (l = c; (other = *l); l++) {
+		if (other == -lit) continue;
+		mark = lglredclsmarked (lgl, other);
+		if (mark > 0) break;
+		if (mark < 0) continue;
+		if (unit) break;
+		unit = other;
+	      }
+	      if (other || !unit) continue;
+	      lglredclsassign (lgl, unit);
+	    }
+	  }
+	  lglpushstk (lgl, &lgl->seen, 0);
+	}
+      }
+    }
+  }
+  if (sat) lgl->stats->redcls.cls.sat++;
+  lgl->clause.top = q;
+  LOG (2, "reduced clause by %d literals", reduced);
+  LOGCLS (2, lgl->clause.start, "reduced clause");
+  if (reduced) lgl->stats->redcls.cls.red++;
+  oldjlevel = *jlevelptr;
+  newjlevel = 0;
+  for (p = lgl->clause.start; p < lgl->clause.top; p++) {
+    if (!(lit = *p) || lit == uip) continue;
+    level = lglevel (lgl, lit);
+    assert (level != lgl->level);
+    if (level > newjlevel) newjlevel = level;
+  }
+  assert (newjlevel <= oldjlevel);
+  if (oldjlevel == newjlevel)
+    LOG (2, "jump level %d does not change", newjlevel);
+  else {
+    LOG (2, "jump level reduced to %d from %d", newjlevel, oldjlevel);
+    *jlevelptr = newjlevel;
+    lgl->stats->redcls.jlevel.red++;
+    lgl->stats->redcls.jlevel.sum += oldjlevel - newjlevel;
+  }
+  lglstop (lgl);
+}
+
+static void lgliassume (LGL * lgl, int lit) {
+  lgl->level++;
+  lglpushcontrol (lgl, lit);
+  assert (lglcntctk (&lgl->control) == lgl->level + 1);
+  LOG (2, "internally assuming %d", lit);
+  lglassign (lgl, lit, DECISION, 0);
+}
+
+static void lgldassume (LGL * lgl, int lit) {
+  LOG (1, "next assumed decision %d external %d", lit, lglexport (lgl, lit));
+  lgl->stats->decisions++;
+  lgliassume (lgl, lit);
+  assert (lgldecision (lgl, lit));
+}
+
+static int lglsubl (LGL * lgl, int lidx, int size, int glue) {
+  const int * c, * p;
+  int count, lit;
+  assert (lidx);
+  assert ((lidx & GLUEMASK) < MAXGLUE);
+  c = lglidx2lits (lgl, REDCS, lidx);
+  count = 0;
+  for (p = c; count < size && (lit = *p); p++) {
+    if (lit == REMOVED) return 1;
+    if (lglmarked (lgl, lit) > 0) count++;
+  }
+  lgl->stats->subl.tried++;
+  if (count < size) {
+    LOGCLS (4, c, "only %d literals shared in clause", count);
+    return 0;
+  }
+  assert (!lglrgforcing (lgl, REDCS, lidx));
+  LOGCLS (2, c,
+    "subsumed learned (scaled) glue %d clause",
+    (int)(lidx & GLUEMASK));
+  LOGCLS (2, lgl->clause.start,
+    "subsumed by new size %d glue %d scaled glue %d clause",
+    size, glue, lglscaleglue (lgl, glue));
+  lgl->stats->subl.sub++;
+  lgldrupligdelclsaux (lgl, c);
+  lglrmlcls (lgl, lidx, REDCS);
+  return 1;
+}
+
+static void lgldrive (
+  LGL * lgl, const char * type, int * forcedptr, 
+  int * glueptr, int * realglueptr, int * jlevelptr) {
+  int lit, jlevel, level, minlevel, maxlevel, glue, realglue, forced;
+  const int * p, * soc = lgl->clause.start, * eoc = lgl->clause.top - 1;
+  Ctr * c;
+  assert (soc <= eoc), assert (!*eoc);
+  forced = forcedptr ? *forcedptr : 0;
+#ifndef NDEBUG
+  for (p = soc; p < eoc; p++) {
+    level = lglevel (lgl, lit = *p);
+    assert (0 < level), assert (level <= lgl->level);
+    c = lgl->control.start + level;
+    assert (!c->used2);
+  }
+#endif
+#ifndef NLGLOG
+  if (lgl->opts->log.val >= 4) {
+    lglogstart (lgl, 2, "driving using clause");
+    for (p = soc; p < eoc; p++) {
+      lit = *p;
+      fprintf (lgl->out, " %d (l%d,t%d)",
+        lit, lglevel (lgl, lit), lgltrail (lgl, lit));
+    }
+    lglogend (lgl);
+  }
+#endif
+  maxlevel = -1, minlevel = lgl->level + 1;
+  for (p = soc; p < eoc; p++) {
+    level = lglevel (lgl, *p);
+    c = lgl->control.start + level;
+    if (!c->used2) {
+      if (level < minlevel) minlevel = level;
+      if (level > maxlevel) maxlevel = level;
+      c->used2 = 1;
+      LOG (4, "level %d used in clause", level);
+    } else if (c->used2 == 1) {
+      c->used2 = 2;
+      LOG (4, "level %d actually used (at least) twice in clause", level);
+    }
+  }
+  if (maxlevel >= 0) {
+    c = lgl->control.start + maxlevel;
+    assert (c->used2);
+    if (c->used2 > 1) {
+      assert (c->used2 == 2);
+      LOG (4, "maximum level %d used twice so no forced literal", maxlevel);
+      jlevel = maxlevel;
+      realglue = glue = -1;
+      for (p = soc; p < eoc; p++) {
+       level = lglevel (lgl, lit = *p);
+       c = lgl->control.start + level;
+       if (c->used2 || level == jlevel) {
+         if (level >= lgl->alevel) realglue++;
+         glue++;
+       }
+       c->used2 = 0;
+      } 
+      assert (realglue >= 0);
+      assert (glue >= 0);
+    } else {
+      assert (c->used2 == 1);
+      LOG (4, "maximum level %d used only once", maxlevel);
+      realglue = glue = jlevel = level = forced = 0;
+      for (p = soc; p < eoc; p++) {
+       level = lglevel (lgl, lit = *p);
+       c = lgl->control.start + level;
+       if (level == maxlevel) {
+         assert (c->used2 == 1);
+         forced = lit;
+       } else if (c->used2) {
+         if (level > jlevel) jlevel = level;
+         if (level >= lgl->alevel) realglue++;
+         glue++;
+       }
+       c->used2 = 0;
+      }
+      assert (!jlevel || minlevel <= jlevel);
+      assert (jlevel < maxlevel);
+      assert (forced);
+    }
+  } else glue = realglue = jlevel = forced = minlevel = maxlevel = 0;
+
+  for (p = soc; p < eoc; p++) {
+    level = lglevel (lgl, lit = *p);
+    assert (0 < level), assert (level <= lgl->level);
+    c = lgl->control.start + level;
+    if (c->used2) c->used2 = 0;
+  }
+
+  LOG (2, "%s minimum level %d", type, minlevel);
+  LOG (2, "%s maximum level %d", type, maxlevel);
+  LOG (2, "%s glue %d (real %d) covers %.0f%%", type, glue, realglue,
+       (float)(jlevel ? lglpcnt (glue, (jlevel - minlevel) + 1) : 100.0));
+  LOG (2, "%s jump level %d", type, jlevel);
+  LOG (2, "%s forced %d", type, forced);
+
+  if (glueptr) *glueptr = glue;
+  if (realglueptr) *realglueptr = realglue;
+  if (jlevelptr) *jlevelptr = jlevel;
+  if (forcedptr) *forcedptr = forced;
+}
+
+static void lgldeco (LGL * lgl, int jlevel, int uip) {
+  int * q, * r, lit, level, limlevel;
+#ifndef NDEBUG
+  int countabovejlevel = 0;
+#endif
+  Ctr * p;
+  assert (lgl->opts->deco.val == 1);
+  if (lgl->opts->deco1opt.val) {
+    for (limlevel = jlevel; limlevel > 1; limlevel--) {
+      p = lgl->control.start + limlevel;
+      if (p->used > 1) break;
+    }
+  } else limlevel = jlevel;
+  LOG (4,
+    "singly-used level limit %d for deco clause",
+    limlevel);
+  for (q = r = lgl->clause.start; q < lgl->clause.top; q++) {
+    if (!(lit = *q)) continue;
+    level = lglevel (lgl, lit);
+    assert (0 < level);
+    if (level > jlevel) {
+#ifndef NDEBUG
+      assert (!countabovejlevel);      // only for UIP
+      assert (lit == uip);
+      countabovejlevel++;
+#else
+      (void) uip;
+#endif
+      continue;
+    }
+    p = lgl->control.start + level;
+    assert (p->used >= 1);
+    if (level > limlevel && p->used == 1) {
+      LOG (4,
+        "keep singly-used level %d literal %d in deco clause",
+       level, lit);
+      *r++ = lit;
+    } else if (p->decision != -lit)
+      LOG (4,
+        "drop non-decision multi-used level %d literal %d in deco clause",
+       level, lit);
+  }
+  lgl->clause.top = r;
+  for (level = 1; level <= jlevel; level++) {
+    p = lgl->control.start + level;
+    assert (p < lgl->control.top);
+    if (level > limlevel && p->used == 1) continue;
+    lit = -p->decision;
+    assert (lgldecision (lgl, lit));
+    assert (lglevel (lgl, lit));
+    assert (lglevel (lgl, lit) <= jlevel);
+    lglpushstk (lgl, &lgl->clause, lit);
+    LOG (4,
+      "add level %d decision literal %d to deco clause",
+      level, lit);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+static const int64_t INT64MIN = LLONG_MIN;
+static const int64_t INT64MAX = LLONG_MAX;
+
+static int64_t lgleftshiftint64 (int64_t val, int shift) {
+  int64_t res;
+  assert (shift >= 0);
+       if (val == INT64MIN) res = INT64MIN;
+  else if (val == INT64MAX) res = INT64MAX;
+  else if (val > (INT64MAX >> shift)) res = INT64MAX;
+  else if (val < (INT64MIN >> shift)) res = INT64MIN;
+  else res = (int64_t)(((uint64_t) val) << shift);
+  assert (val < 0 || res >= val);
+  assert (val > 0 || res <= val);
+  return res;
+}
+
+static int64_t lglrightshiftint64 (int64_t val, int shift) {
+  int64_t res;
+  assert (shift >= 0);
+       if (val == INT64MIN) res = INT64MIN;
+  else if (val == INT64MAX) res = INT64MAX;
+  else res = val >> shift;
+  assert (val > 0 || res >= val);
+  assert (val < 0 || res <= val);
+  return res;
+}
+
+static int64_t lgladdint64 (int64_t a, int64_t b) {
+  int64_t res;
+       if (a == INT64MIN) res = INT64MIN;
+  else if (b == INT64MIN) res = INT64MIN;
+  else if (a == INT64MAX) res = INT64MAX;
+  else if (b == INT64MAX) res = INT64MAX;
+  else if (a >= 0 && b <= 0) res = a + b;
+  else if (a <= 0 && b >= 0) res = a + b;
+  else if (a < 0) {
+    assert (b < 0);
+    if (b < (INT64MIN - a)) res = INT64MIN;
+    else res = a + b;
+    assert (res <= a), assert (res <= b);
+  } else {
+    assert (a > 0), assert (b > 0);
+    if (b > (INT64MAX - a)) res = INT64MAX;
+    else res = a + b;
+    assert (res >= a), assert (res >= b);
+  }
+  return res;
+}
+
+static int64_t lglsubint64 (int64_t a, int64_t b) {
+  int64_t res;
+  if (b == INT64MIN) res = INT64MIN;
+  else res = lgladdint64 (a, -b);
+  return res;
+}
+
+static int lglvalidint64 (int64_t a) {
+  return a != INT64MIN && a != INT64MAX;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void lglinitema (LGL * lgl, EMA * ema, int shift) {
+  assert (0 <= shift), assert (shift <= 32);
+  ema->shift = shift;
+  ema->count = 0;
+  LOG (2, "initialized EMA shift %d", shift);
+}
+
+static void lglupdatema (LGL * lgl, EMA * ema, int64_t input, int left) {
+  int64_t oldval, tmpval, newval, add, sub;
+  const int shift = ema->count;
+  oldval = ema->val;
+  if (shift < ema->shift) ema->count++;
+  assert (lglvalidint64 (oldval));
+  if (!lglvalidint64 (input)) goto DONE;
+  sub = lglrightshiftint64 (oldval, shift);
+  if (!lglvalidint64 (sub)) goto DONE;
+  tmpval = lglsubint64 (oldval, sub);
+  if (!lglvalidint64 (tmpval)) goto DONE;
+  if (left) add = lgleftshiftint64 (input, 32 - shift);
+  else add = lglrightshiftint64 (input, shift);
+  if (!lglvalidint64 (add)) goto DONE;
+  newval = lgladdint64 (tmpval, add);
+  if (!lglvalidint64 (newval)) goto DONE;
+  ema->val = newval;
+DONE:
+#ifndef NLGLOG
+  if (left)
+    LOG (2,
+      "EMA (left) input %lld old %g shift %d new %g",
+      (LGLL) input,
+      oldval/(double)(1ll<<32),
+      ema->shift,
+      ema->val/(double)(1ll<<32));
+  else
+    LOG (2,
+      "EMA (right) input %g old %g shift %d new %g",
+      input/(double)(1ll<<32),
+      oldval/(double)(1ll<<32),
+      ema->shift,
+      ema->val/(double)(1ll<<32));
+#else
+  ;
+#endif
+}
+
+#ifndef NLGLDEMA
+
+static void lglinitdema (LGL * lgl, DEMA * dema, int shift) {
+  lglinitema (lgl, &dema->ema[0], shift);
+  lglinitema (lgl, &dema->ema[1], shift);
+  LOG (2, "initialized DEMA shift %d", shift);
+}
+
+static void lglupdatedema (LGL * lgl, DEMA * dema, int input) {
+#ifndef NLGLOG
+  int64_t oldval = dema->val;
+#endif
+  int64_t newval, val0, val1;
+  lglupdatema (lgl, &dema->ema[0], input, 1);
+  if (!lglvalidint64 (val0 = dema->ema[0].val)) goto DONE;
+  lglupdatema (lgl, &dema->ema[1], val0, 0);
+  if (!lglvalidint64 (val1 = dema->ema[1].val)) goto DONE;
+  newval = lglsubint64 (lgleftshiftint64 (val0, 1), val1);
+  if (!newval) goto DONE;
+  dema->val = newval;
+DONE:
+  LOG (2,
+    "DEMA input %lld old %g shift %d new %g",
+    (LGLL) input,
+    oldval/(double)(1ll<<32),
+    dema->ema[0].shift,
+    dema->val/(double)(1ll<<32));
+}
+
+#endif
+
+static void lglinitmacd (LGL * lgl, MACD * macd,
+                         int fast, int slow, int smooth) {
+  assert (0 <= fast), assert (fast <= 32);
+  assert (0 <= slow), assert (slow <= 32);
+  assert (0 <= smooth), assert (smooth <= 32);
+  lglinitmacdema (lgl, &macd->fast, fast);
+  lglinitmacdema (lgl, &macd->slow, slow);
+  lglinitema (lgl, &macd->diff.smoothed, smooth);
+  LOG (2, "initialized MACD fast %d slow %d smooth %d", fast, slow, smooth);
+}
+
+static void lglupdatemacd (LGL * lgl, MACD * macd, int64_t input) {
+#if !defined(NDEBUG) || !defined(NLGLOG)
+  int64_t oldactual = macd->diff.actual;
+  int64_t oldsmoothed = macd->diff.smoothed.val;
+#endif
+  int64_t newactual;
+  assert (lglvalidint64 (oldsmoothed));
+  assert (lglvalidint64 (oldactual));
+  lglupdatemacdema (lgl, &macd->fast, input);
+  lglupdatemacdema (lgl, &macd->slow, input);
+  newactual = lglsubint64 (macd->fast.val, macd->slow.val);
+  if (!lglvalidint64 (newactual)) goto DONE;
+  macd->diff.actual = newactual;
+  lglupdatema (lgl, &macd->diff.smoothed, newactual, 0);
+DONE:
+  LOG (2,
+"updated MACD input %lld actual/smoothed: old %g/%g, new %g/%g",
+    (LGLL) input,
+    oldactual/(double)(1ll<<32),
+    oldsmoothed/(double)(1ll<<32),
+    macd->diff.actual/(double)(1ll<<32),
+    macd->diff.smoothed.val/(double)(1ll<<32));
+}
+
+static void lglupdstab (LGL * lgl) {
+  int assigned = lglcntstk (&lgl->trail);
+  int changed = lgl->stats->stability.changed;
+  int topassigned = lglevel2trail (lgl, 1);
+  int nontopassigned = assigned - topassigned;
+  int64_t difference, shifted, fraction;
+  lgl->stats->stability.count++;
+  lglprt (lgl, 2,
+    "[stability-%lld] %d assigned, %d non-top %.1f%%, %d changed %.2f%%",
+    (LGLL) lgl->stats->stability.count,
+    assigned,
+    nontopassigned, lglpcnt (nontopassigned, assigned),
+    changed, lglpcnt (changed, nontopassigned));
+  assert (lgl->level > 0);
+  assert (lgl->stats->stability.level > 0);
+  assert (lgl->stats->stability.level <= lgl->level);
+  assert (nontopassigned >= 0);
+  if (!nontopassigned) fraction = 0;
+  else {
+    assert (nontopassigned >= changed);
+    difference = nontopassigned - changed;
+    shifted = difference << 32;
+    fraction = shifted / nontopassigned;
+  }
+  lglupdatema (lgl, &lgl->stats->stability.avg, fraction, 0);
+  lgl->stats->stability.level = 0;
+  lglprt (lgl, 2,
+    "[stability-%lld] unchanged fraction %.3f%% new stability %.3f%%",
+    (LGLL) lgl->stats->stability.count,
+    100.0 * fraction/(double)(1ll<<32),
+    100.0 * lgl->stats->stability.avg.val / (double)(1ll<<32));
+}
+
+static void lglinitavg (AVG * avg) {
+  avg->val = avg->count = 0;
+}
+
+static void lglupdateavg (LGL * lgl, AVG * avg, int input) {
+  int64_t oldval = avg->val, newval = oldval, shifted, diff;
+  shifted = lgleftshiftint64 (input, 32);
+  if (!lglvalidint64 (shifted)) goto DONE;
+  diff = lglsubint64 (shifted, oldval);
+  if (!lglvalidint64 (diff)) goto DONE;
+  diff /= ++avg->count;
+  newval = lgladdint64 (oldval, diff);
+  if (!lglvalidint64 (newval)) goto DONE;
+  avg->val = newval;
+DONE:
+  LOG (2,
+    "AVG input %d old %g new %g count %lld",
+    input,
+    oldval/(double)(1ll<<32),
+    newval/(double)(1ll<<32),
+    avg->count);
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglblockrestart (LGL * lgl) {
+  const int64_t   actual = ((int64_t)lglcntstk (&lgl->trail)) << 32;
+  const int64_t smoothed = lgl->stats->tlevel.val;
+  const int64_t  percent = lgl->opts->restartblocklim.val;
+  int64_t limit;
+  int blocking;
+  if (lgl->stats->confs < lgl->limits->restart.confs) return 0;
+  if (lgl->stats->confs < lgl->opts->restartblockbound.val) return 0;
+  assert (percent);
+  assert (lglvalidint64 (smoothed));
+  limit = (smoothed < 0 ? -smoothed : smoothed);
+  assert (limit >= 0);
+  if (!lglvalidint64 (limit)) return 0;
+  limit /= 100;
+  if (INT64MAX/percent < limit) return 0;
+  limit *= percent;
+  blocking = (limit < actual);
+  LOG (2,
+    "%s restart MACD %g * %.2f = %g %s %g at %lld conflicts",
+    (blocking ? "blocking" : "not blocking"),
+    smoothed/(double)(1ll<<32),
+    lgl->opts->restartblocklim.val/100.0,
+    limit/(double)(1ll<<32),
+    blocking ? "<" : ">=",
+    actual/(double)(1ll<<32),
+    (LGLL) lgl->stats->confs);
+  return blocking;
+}
+
+static void lglrndcls (LGL * lgl, int len, int prune) {
+  int64_t delta;
+  if (len == 2) {
+    lglrep (lgl, 1 + !prune, prune ? 'B' : 'b');
+    lgl->stats->bins++;
+  }
+  if (len == 3) {
+    lglrep (lgl, 1 + !prune, prune ? 'T' : 't');
+    lgl->stats->trns++;
+  }
+  delta = lgl->stats->confs - lgl->confatlastit;
+  LOG (1, "iteration delta %lld", (LGLL) delta);
+  lglupdatemacd (lgl, &lgl->stats->its.avg, delta);
+  if (len == 1) {
+    int delay = lgl->opts->simpitdelay.val;
+    lgl->confatlastit = lgl->stats->confs;
+    lgl->stats->its.count++;
+    lglrep (lgl, 1, prune ? 'I' : 'i');
+    if (delta > 0) delay /= delta;
+    if (delay > 0) {
+      lgl->limits->simp.confs += delay;
+      LOG (1, "delaying simplification by %d conflicts", delay);
+    }
+  }
+  LOG (1, "iteration interval average %.0f", lglitavg (lgl));
+}
+
+static int lglana (LGL * lgl) {
+  int open, resolved, tag, lit, uip, r0, r1, other, other2, * p, * q, lidx;
+  int size, savedsize, resolventsize, level, red, glue, realglue;
+  int jlevel, mlevel, nmlevel, origsize, redsize, tlevel;
+  int len, * rsn;
+#ifdef RESOLVENT
+  AVar * av;
+#endif
+  if (lgl->mt) return 0;
+  if (lgl->failed) return 0;
+  if (!lgl->conf.lit) return 1;
+  if (!lgl->level) { lglmt (lgl); return 0; }
+  lglstart (lgl, &lgl->times->analysis);
+  if (lgl->sweeping) lgl->stats->sweep.confs++;
+  else assert (!lgl->simp), lgl->stats->confs++;
+RESTART:
+  tlevel = lglcntstk (&lgl->trail);
+  assert (lgl->conf.lit);
+  assert (lglmtstk (&lgl->seen));
+  assert (lglmtstk (&lgl->clause));
+  assert (lglmtstk (&lgl->resolvent));
+#ifndef NDEBUG
+  if (lgl->opts->check.val > 0) lglchkclnvar (lgl);
+#endif
+  open = 0;
+  lit = lgl->conf.lit, r0 = lgl->conf.rsn[0], r1 = lgl->conf.rsn[1];
+  savedsize = resolved = 0;
+  open += lglpull (lgl, lit);
+  LOG (2, "starting analysis with reason of literal %d", lit);
+  for (;;) {
+    LOGREASON (2, lit, r0, r1, "analyzing");
+    if (resolved++) {
+#ifdef RESOLVENT
+      if (lglmaintainresolvent (lgl)) {
+	LOG (2, "removing %d from resolvent", -lit);
+	lglrmstk (&lgl->resolvent, -lit);
+	LOGRESOLVENT (3, "resolvent after removing %d is", -lit);
+      }
+#endif
+    }
+    assert (lglevel (lgl, lit) == lgl->level);
+    tag = r0 & MASKCS;
+    if (tag == BINCS || tag == TRNCS) {
+      other = r0 >> RMSHFT;
+      size = lglevel (lgl, other) ? 2 : 1;
+      if (lglpull (lgl, other)) open++;
+      if (tag == TRNCS) {
+	if (lglevel (lgl, r1)) size++;
+	if (lglpull (lgl, r1)) open++;
+      }
+    } else {
+      assert (tag == LRGCS);
+      red = r0 & REDCS;
+      p = lglidx2lits (lgl, red, r1);
+      size = 0;
+      while ((other = *p++)) {
+	if (lglevel (lgl, other)) size++;
+	if (lglpull (lgl, other)) open++;
+      }
+      if (red) lglbumpnupdatelidx (lgl, r1);
+    }
+    LOG (3, "open %d antecendents %d learned %d resolved %d",
+	 open-1, size, lglcntstk (&lgl->clause), lglcntstk (&lgl->resolvent));
+    assert (open > 0);
+    resolventsize = open + lglcntstk (&lgl->clause);
+#ifdef RESOLVENT
+    LOGRESOLVENT (2, "resolvent");
+    if (lglmaintainresolvent (lgl))
+      assert (lglcntstk (&lgl->resolvent) == resolventsize);
+#endif
+    if (lgl->opts->otfs.val &&
+	(resolved >= 2) &&
+	resolventsize > 1 &&
+	(resolventsize < size || (resolved==2 && resolventsize<savedsize))) {
+      int sl = 0, s0 = 0, s1 = 0, del;
+      int cl = lgl->conf.lit;
+      int c0 = lgl->conf.rsn[0];
+      int c1 = lgl->conf.rsn[1];
+      assert (resolved >= 2);
+      del = lit;
+      if (resolved > 2) ;
+      else if (resolventsize >= size) del = -lit, lit = cl, r0 = c0, r1 = c1;
+      else if (resolventsize >= savedsize) ;
+      else {
+	if (r0 & REDCS) {
+	  sl = lit, s0 = r0, s1 = r1;
+	  del = -lit, lit = cl, r0 = c0, r1 = c1;
+	} else sl = cl, s0 = c0, s1 = c1;
+      }
+      lgldynstr (lgl, del, lit, r0, r1);
+      if (sl) lgldynsub (lgl, sl, s0, s1);
+      lit = lgl->conf.lit;
+      r0 = lgl->conf.rsn[0];
+      r1 = lgl->conf.rsn[1];
+      assert (lglevel (lgl, lit) == lgl->level);
+      tag = r0 & MASKCS;
+      if (tag == UNITCS) {
+	mlevel = lglevel (lgl, lit);
+	nmlevel = 1;
+	jlevel = 0;
+      } else if (tag == BINCS) {
+	jlevel = lglevel (lgl, lit);
+	other = r0 >> RMSHFT;
+	mlevel = lglevel (lgl, other);
+	if (jlevel > mlevel) { nmlevel = 1; SWAP (int, mlevel, jlevel); }
+	else if (jlevel == mlevel) nmlevel = 2;
+	else assert (jlevel < mlevel), nmlevel = 1;
+      } else if (tag== TRNCS) {
+	jlevel = lglevel (lgl, lit);
+	other = r0 >> RMSHFT;
+	level = lglevel (lgl, other);
+	other2 = r1;
+	mlevel = lglevel (lgl, other2);
+	if (jlevel > mlevel) SWAP (int, jlevel, mlevel);
+	if (level > mlevel) SWAP (int, level, mlevel);
+	if (level > jlevel) SWAP (int, level, jlevel);
+	assert (mlevel >= jlevel);
+	assert (jlevel >= level);
+	if (mlevel == jlevel) nmlevel = 2 + (jlevel == level);
+	else assert (mlevel > jlevel), nmlevel = 1;
+	assert (nmlevel == 1 + (mlevel == jlevel) + (mlevel == level));
+      } else {
+	mlevel = lglevel (lgl, lit), nmlevel = 1, jlevel = 0;
+	assert (tag == LRGCS);
+	red = r0 & REDCS;
+	p = lglidx2lits (lgl, red, r1);
+	while (jlevel < lgl->level && (other = *p++)) {
+	  if (other == lit) continue;
+	  assert (other != -lit);
+	  level = lglevel (lgl, other);
+	  if (level < mlevel) {
+	    if (level > jlevel) jlevel = level;
+	    continue;
+	  }
+	  if (level == mlevel) nmlevel++;
+	  else {
+	    assert (level > mlevel);
+	    jlevel = mlevel;
+	    mlevel = level;
+	    nmlevel = 1;
+	  }
+	}
+	if (red) lglbumpnupdatelidx (lgl, r1);
+      }
+      if (nmlevel >= 2) {
+	LOG (2, "restarting analysis after on-the-fly strengthening");
+	lgl->stats->otfs.restarting++;
+	lglclnana (lgl);
+	if (lgl->level > mlevel) lglbacktrack (lgl, mlevel);
+	goto RESTART;
+      }
+      assert (nmlevel == 1);
+      assert (mlevel > jlevel);
+      assert (lglevel (lgl, lit) == mlevel);
+      LOGREASON (2, lit, r0, r1,
+	"driving %d at level %d through strengthened", lit, jlevel);
+      lgl->stats->otfs.driving++;
+      lglbacktrack (lgl, jlevel);
+      if (tag == LRGCS && (r0 & REDCS) && (r1 & GLUEMASK) == MAXGLUE) {
+	// Note, that 'lit' is unassigned by 'backtrack' above and thus if
+	// it's reason is at the end of the MAXGLUE stack, then the reason
+	// becomes invalid.  See the corresponding 'assert' in 'lglassign'.
+	// Our original incorrect fix to this problem was to simply increase
+	// the size of the stack to point after the zero sentinel, which
+	// however produces garbage on the MAXGLUE stack and thus we only
+	// follow this idea if the reason of 'lit' is exactly after the
+	// current end of the MAXGLUE stack. If it starts before the end
+	// nothing has to be done.  Otherwise we have to move the reason
+	// literals and update the reason.
+	p = lglidx2lits (lgl, REDCS, r1);
+	if (p > lgl->red[MAXGLUE].top) {
+	  rsn = lglrsn (lgl, lit);
+	  r1 = lglcntstk (&lgl->red[MAXGLUE]);
+	  r1 <<= GLUESHFT;
+	  r1 |= MAXGLUE;
+	  rsn[1] = r1;
+	  for (q = lgl->red[MAXGLUE].top; *p; p++) {
+	    assert (q < p);
+	    *q++ = *p;
+	  }
+	  *q++ = 0;
+	  lgl->red[MAXGLUE].top = q;
+	} else if (p == lgl->red[MAXGLUE].top) {
+	  while (*p) { assert (*p < NOTALIT); p++; }
+	  if (++p > lgl->red[MAXGLUE].top) lgl->red[MAXGLUE].top = p;
+	}
+      }
+      lglassign (lgl, lit, r0, r1);
+      len = INT_MAX;
+      goto DONE;
+    }
+    savedsize = size;
+    while (!lglmarked (lgl, lit = lglpopstk (&lgl->trail)))
+      lglunassign (lgl, lit);
+    lglunassign (lgl, lit);
+    if (!--open) { uip = -lit; break; }
+    LOG (2, "analyzing reason of literal %d next", lit);
+    rsn = lglrsn (lgl, lit);
+    r0 = rsn[0], r1 = rsn[1];
+  }
+  assert (uip);
+  LOG (2, "adding UIP %d at same level %d to 1st UIP clause",
+       uip, lgl->level);
+  lglpushstk (lgl, &lgl->clause, uip);
+  assert (lglmarked (lgl, uip));
+#ifdef RESOLVENT
+  LOGRESOLVENT (3, "final resolvent before flushing fixed literals");
+  if (lglmaintainresolvent  (lgl)) {
+    int * q = lgl->resolvent.start;
+    for (p = q; p < lgl->resolvent.top; p++)
+      if (lglevel (lgl, (other = *p)))
+	*q++ = other;
+    lgl->resolvent.top = q;
+    LOGRESOLVENT (2, "final resolvent after flushing fixed literals");
+    assert (lglcntstk (&lgl->resolvent) == lglcntstk (&lgl->clause));
+    for (p = lgl->clause.start; p < lgl->clause.top; p++)
+      assert (lglavar (lgl, *p)->mark > 0);
+    for (p = lgl->resolvent.start; p < lgl->resolvent.top; p++) {
+      av = lglavar (lgl, *p); assert (av->mark > 0); av->mark = -av->mark;
+    }
+    for (p = lgl->clause.start; p < lgl->clause.top; p++)
+      assert (lglavar (lgl, *p)->mark < 0);
+    for (p = lgl->resolvent.start; p < lgl->resolvent.top; p++) {
+      av = lglavar (lgl, *p); assert (av->mark < 0); av->mark = -av->mark;
+    }
+    lglclnstk (&lgl->resolvent);
+  }
+#endif
+  lglpushstk (lgl, &lgl->clause, 0);
+  LOGCLS (2, lgl->clause.start, "1st UIP clause");
+
+  lgldrive (lgl, "preliminary", 0, &glue, 0, &jlevel);
+  assert (glue == lglcntstk (&lgl->frames));
+
+  origsize = lglcntstk (&lgl->clause) - 1;
+  assert (glue + 1 <= origsize);
+  lglbumpseenlits (lgl);
+  lgl->stats->lits.nonmin += origsize;
+  redsize = jlevel + 1;
+  if (origsize == 2) {
+    lgl->stats->mincls.bin++;
+    LOGCLS (2, lgl->clause.start, "binary 1st UIP clause not minimized");
+  } else if (glue + 1 == origsize) {
+    lgl->stats->mincls.size++;
+    LOGCLS (2, lgl->clause.start,
+      "size %d 1st UIP clause with glue %d can not be minimized",
+      origsize, glue);
+  } else if (jlevel > 1 &&
+      lgl->opts->deco.val &&
+      redsize < 2*origsize/3 &&
+      glue > lgl->opts->decolim.val) {
+    assert (origsize > 2);
+    lgl->stats->mincls.deco++;
+    lgl->stats->deco.sum.orig += origsize;
+    lgldeco (lgl, jlevel, uip);
+    lglpushstk (lgl, &lgl->clause, uip);
+    lgl->stats->deco.sum.red += lglcntstk (&lgl->clause);
+    lglpushstk (lgl, &lgl->clause, 0);
+    LOGCLS (2, lgl->clause.start,
+      "size %d 1st UIP clause discarded for size %d decision-only clause",
+      origsize, redsize);
+  } else {
+    lglmincls (lgl, uip, glue);
+    lglredcls (lgl, uip, glue, &jlevel);
+  }
+
+  lgldrive (lgl, "final", &uip, &glue, &realglue, &jlevel);
+  
+  if (uip && lglrsn (lgl, uip)[0]) lgl->stats->uips++;
+  else if (jlevel + 1 == lgl->level) lgl->stats->decflipped++;
+
+  lglbumpscinc (lgl);
+
+  lglbacktrack (lgl, jlevel);
+
+  len = lglcntstk (&lgl->clause) - 1;
+  lgl->stats->clauses.glue += glue;
+  lgl->stats->clauses.realglue += realglue;
+  lgl->stats->lits.learned += len;
+  lgl->stats->clauses.learned++;
+
+  if (!lgl->simp) {
+    LOG (2, "updating AVG glue");
+    lglupdateavg (lgl, &lgl->stats->avglue, realglue);
+    LOG (2, "updating MACD restart glue");
+    lglupdatemacd (lgl, &lgl->stats->glue, realglue);
+    LOG (2, "updating MACD jump level");
+    lglupdatemacd (lgl, &lgl->stats->jlevel, jlevel);
+    LOG (2, "updating EMA trail level");
+    lglupdatema (lgl, &lgl->stats->tlevel, tlevel, 1);
+    if (lgl->opts->restartblock.val == 1 && lglblockrestart (lgl)) {
+      lgl->limits->restart.confs =
+        lgl->stats->confs + lgl->opts->restartint.val;
+      lgl->stats->restarts.blocked++;
+    }
+#ifndef NLGLFILES
+    {
+      static FILE * macdfile = 0;
+      if (!macdfile) macdfile = fopen ("/tmp/macd", "w");
+      fprintf (macdfile,
+       "%lld %d"
+       " %g %g %g"
+       "\n",
+       (LGLL) lgl->stats->confs,
+       realglue,
+       lgl->stats->glue.fast.val/(double)(1ll<<32),
+       lgl->stats->avglue.val/(double)(1ll<<32),
+       lgl->stats->glue.slow.val/(double)(1ll<<32)
+       );
+
+      fflush (macdfile);
+    }
+#endif
+  }
+
+  lgldrupligaddcls (lgl, REDCS);
+  lidx = lgladdcls (lgl, REDCS, realglue, 1);
+
+#ifndef NDEBUG
+  if (!lglmtstk (&lgl->prevclause)) {
+    for (p = lgl->prevclause.start, q = lgl->clause.start; *p; p++, q++)
+      if (*p != *q) break;
+    assert (*q != *p);
+  }
+  lglclnstk (&lgl->prevclause);
+  for (p = lgl->clause.start; *p; p++)
+    lglpushstk (lgl, &lgl->prevclause, *p);
+  lglpushstk (lgl, &lgl->prevclause, 0);
+  lgl->prevglue = lglscaleglue (lgl, realglue);
+#endif
+  if (lgl->opts->subl.val) {
+    lglstart (lgl, &lgl->times->subl);
+    lgl->stats->subl.count++;
+    lglpopnunmarkstk (lgl, &lgl->seen);
+    size = lglcntstk (&lgl->clause) - 1;
+    if (size > 1) {
+      unsigned sig = 0;
+      p = lgl->clause.start;
+      while ((lit = *p++)) {
+       sig |= (1u << (lglulit (lit) & 31));
+       lglmark (lgl, lit);
+      }
+      q = lgl->learned.start;
+      for (p = q; p < lgl->learned.top; p += 3) {
+       int olidx = p[0], osize = p[1];
+       unsigned osig = (unsigned) p[2];
+       if (olidx < 0) continue;
+       if (osize <= size ||
+           (sig & ~osig) ||
+           !lglsubl (lgl, olidx, size, glue))
+         *q++ = olidx, *q++ = osize, *q++ = (int) osig;
+      }
+      lgl->learned.top = q;
+      if (lidx && (lidx & GLUEMASK) < MAXGLUE) {
+       lgl->stats->subl.cands++;
+       lglpushstk (lgl, &lgl->learned, lidx);
+       lglpushstk (lgl, &lgl->learned, size);
+       lglpushstk (lgl, &lgl->learned, (int) sig);
+       if (lglcntstk (&lgl->learned) / 3 > lgl->opts->subl.val) {
+         q = lgl->learned.start;
+         for (p = q + 3; p < lgl->learned.top; p++) *q++ = *p;
+         lgl->learned.top = q;
+       }
+      } 
+      p = lgl->clause.start;
+      while ((lit = *p++)) lglunmark (lgl, lit);
+    }
+    lglstop (lgl);
+  }
+
+  if (lgl->cbs &&
+      lgl->cbs->cls.produce.fun &&
+      glue <= lgl->opts->synclsglue.val &&
+      lglcntstk (&lgl->clause) - 1 <= lgl->opts->synclslen.val) {
+    assert (lglmtstk (&lgl->eclause));
+    for (p = lgl->clause.start; *p; p++)
+      lglpushstk (lgl, &lgl->eclause, lglexport (lgl, *p));
+    lglpushstk (lgl, &lgl->eclause, 0);
+    LOGCLS (2, lgl->eclause.start,
+      "exporting external redundant glue %d length %d clause", 
+      glue, lglcntstk (&lgl->clause) -1);
+    lgl->stats->sync.cls.produced++;
+    lgl->cbs->cls.produce.fun (lgl->cbs->cls.produce.state,
+                               lgl->eclause.start, glue);
+    lglclnstk (&lgl->eclause);
+  }
+
+DONE:
+
+  if (!lgl->simp) lglrndcls (lgl, len, 0);
+  lglclnana (lgl);
+  lglstop (lgl);
+
+  return 1;
+}
+
+static void lglincrestart (LGL * lgl) {
+  Stats * s = lgl->stats;
+  int64_t delta;
+  int pen = 0;
+  delta = lgl->opts->restartint.val;
+  if (lgl->opts->restartfixed.val) goto NOPEN;
+  LOG (2, "initial next restarting delta %lld", (LGLL) delta);
+  if (lgl->opts->restartpen1.val && s->confs > 500000 &&
+      (!s->its.count || s->confs/s->its.count > 100000)) {
+    lglprt (lgl, 2,
+      "[restart-%lld] few iterations after 500000 conflicts",
+      (LGLL) lgl->stats->restarts.count);
+    pen++;
+  }
+  if (lgl->opts->restartpen2.val && s->confs > 50000 &&
+      (!s->bins || s->confs/s->bins > 10000)) {
+    lglprt (lgl, 2,
+      "[restart-%lld] few binaries after 50000 conflicts",
+      (LGLL) lgl->stats->restarts.count);
+    pen++;
+  }
+  if (lgl->opts->restartpen3.val && s->confs > 5000 &&
+      (!s->trns || s->confs/s->trns > 1000)) {
+    lglprt (lgl, 2,
+      "[restart-%lld] few ternaries after 5000 conflicts",
+      (LGLL) lgl->stats->restarts.count);
+    pen++;
+  }
+  if (lgl->opts->restartpenstab.val && s->confs > 50000) {
+    int64_t glue = (s->glue.slow.val >> 32);
+    if (glue < 20) {
+      int64_t stab = s->stability.avg.val;
+      int peninc = 0;
+      assert (stab <= (1ll << 32));
+      stab *= 100000;
+      stab >>= 32;
+      if (stab > 98000) peninc++;
+      if (stab > 99000) peninc++;
+      if (stab > 99500) peninc++;
+      if (stab > 99750) peninc++;
+      if (stab > 99875) peninc++;
+      pen += peninc;
+      lglprt (lgl, 2,
+	"[restart-%lld] "
+	"stability %lld glue %d after 50000 conflicts (penalty increase %d)",
+	(LGLL) lgl->stats->restarts.count, stab, glue, peninc);
+    }
+  }
+NOPEN:
+  delta <<= pen;
+  lgl->stats->restarts.delta.pen += pen;
+  lgl->stats->restarts.delta.delta += delta;
+  lgl->stats->restarts.delta.count++;
+  lgl->limits->restart.confs = lgl->stats->confs + delta;
+  lglprt (lgl, 2,
+    "[restart-%lld] next restart %lld delta %lld (penalty %d)",
+    (LGLL) lgl->stats->restarts.count,
+    (LGLL) lgl->limits->restart.confs, (LGLL) delta, pen);
+  lglrep (lgl, 2, 'R');
+}
+
+static void lglqueueflush (LGL * lgl) {
+  int before, mt, after, nonfree;
+  const int * p, * start;
+  int * q, lit, found;
+  QVar * qv;
+  lgl->stats->queue.flushed++;
+  found = nonfree = mt = 0;
+  before = lglcntstk (&lgl->queue.stk);
+  assert (lgl->mt <= before);
+  start = q = lgl->queue.stk.start;
+  for (p = q; p < lgl->queue.stk.top; p++) {
+    if (!(lit = *p)) {
+      mt++;
+      continue;
+    }
+    qv = lglqvar (lgl, lit);
+    assert (qv->enqueued);
+    assert (qv->pos == (p - start));
+    if (!lglisfree (lgl, lit)) {
+      qv->enqueued = 0;
+      qv->pos = -1;
+      nonfree++;
+    } else {
+      qv->pos = (q - start);
+      if (!found && lgl->queue.next >= (p - start))
+	found = 1, lgl->queue.next = qv->pos;
+      *q++ = lit;
+    }
+  }
+  lgl->queue.stk.top = q;
+  if (!found) lgl->queue.next = lglcntstk (&lgl->queue.stk) - 1;
+  assert (mt == lgl->queue.mt);
+  lgl->queue.mt = 0;
+  after = lglcntstk (&lgl->queue.stk);
+  assert (before == after + nonfree + mt);
+  lglprt (lgl, 2,
+    "[flush-queue-%d] flushed %d = %d mt + %d nonfree (resized %d to %d)",
+    lgl->stats->queue.flushed, mt + nonfree, mt, nonfree, before, after);
+}
+
+static int lglnextdecision (LGL * lgl, int updatestats) {
+  int res = 0;
+#ifndef NDEBUG
+  int start;
+#endif
+  QVar * qv;
+  if (!lgl->unassigned) return 0;
+  lglstart (lgl, &lgl->times->decide);
+  lglstart (lgl, &lgl->times->heapdecision);
+  while (!res && !lglmtstk (&lgl->dsched)) {
+    int next = lgltopdsched (lgl);
+    if (!lglval (lgl, next) && lglisfree (lgl, next)) res = next;
+    else lglpopdsched (lgl);
+  }
+  lglstop (lgl);
+  if (!res) {
+    lglstart (lgl, &lgl->times->queuedecision);
+    assert (!lglmtstk (&lgl->queue.stk));
+    if (lglcntstk (&lgl->queue.stk) < 2*lgl->queue.mt) lglqueueflush (lgl);
+#ifndef NDEBUG
+    start = lgl->queue.next;
+#endif
+    for (;;) {
+      res = lglpeek (&lgl->queue.stk, lgl->queue.next);
+      if (res) {
+	qv = lglqvar (lgl, res);
+	assert (qv->enqueued);
+	assert (qv->pos == lgl->queue.next);
+	if (!lglisfree (lgl, res)) {
+	  lglpoke (&lgl->queue.stk, lgl->queue.next, 0);
+	  lgl->queue.mt++;
+	  qv->enqueued = 0;
+	  qv->pos = -1;
+	} else if (!lglval (lgl, res)) {
+	  if (updatestats) lgl->stats->qdecs++;
+	  break;
+	}
+      }
+      lgl->queue.next--;
+      if (lgl->queue.next < 0)
+	lgl->queue.next = lglcntstk (&lgl->queue.stk) - 1;
+      ASSERT (lgl->queue.next != start);
+    }
+    lglstop (lgl);
+  } else if (updatestats) lgl->stats->hdecs++;
+  assert (res);
+  lglstop (lgl);
+  LOG (2, "next decision would be %d", res);
+  return res;
+}
+
+static int lglreusetrail (LGL * lgl) {
+  int next = 0, res = 0, prev, level;
+  const Ctr * p;
+  if (!lgl->opts->reusetrail.val) return 0;
+  if (!(next = lglnextdecision (lgl, 0))) return 0;
+  for (p = lgl->control.start + 1; p < lgl->control.top; p++) {
+    prev = p->decision;
+    assert (lgldecision (lgl, prev));
+    if (!lglassumption (lgl, prev) && lgldcmp (lgl, prev, next) < 0) break;
+    level = lglevel (lgl, prev);
+    assert (level == p - lgl->control.start);
+    assert (res + 1 == level);
+    res = level;
+  }
+  if (res)
+    lglprt (lgl, 3,
+      "[reuse-trail] reusing level %d from current level %d",
+      res, lgl->level);
+  else
+    lglprt (lgl, 3,
+      "[reuse-trail] can not reuse any level from current level %d",
+      lgl->level);
+  return res;
+}
+
+static void lglrestart (LGL * lgl) {
+  int level, kept;
+  assert (lgl->opts->restart.val);
+  lglstart (lgl, &lgl->times->restart);
+  level = lglreusetrail (lgl);
+  if (level < lgl->alevel) level = lgl->alevel;
+  else if (level > lgl->alevel) {
+    kept = (100*level) / lgl->level;
+    lgl->stats->restarts.kept.sum += kept;
+    lgl->stats->restarts.kept.count++;
+  }
+  if (level < lgl->level) {
+    int oldlevel = lgl->level;
+    lglbacktrack (lgl, level);
+    LOG (2, "setting stability level to %d", oldlevel);
+    lgl->stats->stability.level = oldlevel;
+    assert (lgl->stats->stability.level > 0);
+    lgl->stats->stability.changed = 0;
+    lgl->stats->restarts.count++;
+  } else {
+    lgl->stats->restarts.reused++;
+    lgl->stats->restarts.skipped++;
+  }
+  lglincrestart (lgl);
+  lglstop (lgl);
+}
+
+static void lgldefrag (LGL * lgl) {
+  int * wchs, i, idx, bit, ldsize, size, * start, * q, * end;
+  const int * p, * eow, * w;
+  unsigned offset;
+  long nwchs;
+  HTS * hts;
+  lglstart (lgl, &lgl->times->defrag);
+  lgl->stats->defrags++;
+  nwchs = lglcntstk (&lgl->wchs->stk);
+  NEW (wchs, nwchs);
+  memcpy (wchs, lgl->wchs->stk.start, nwchs * sizeof *wchs);
+  for (i = 0; i < MAXLDFW; i++) lgl->wchs->start[i] = UINT_MAX;
+  lgl->wchs->free = 0;
+  start = lgl->wchs->stk.start;
+  assert (nwchs >= 1);
+  assert (start[0] == (int) UINT_MAX);
+  offset = 1;
+  for (idx = 2; idx < lgl->nvars; idx++)
+  for (bit = 0; bit <= 1; bit++) {
+    hts = lgl->dvars[idx].hts + bit;
+    if (!hts->offset) { assert (!hts->count); continue; }
+    ldsize = lglceild (hts->count);
+    size = (1 << ldsize);
+    assert (size >= hts->count);
+    w = wchs + hts->offset;
+    hts->offset = offset;
+    eow = w + hts->count;
+    q = start + offset;
+    for (p = w; p < eow; p++) *q++ = *p;
+    offset += size;
+    end = start + offset;
+    while (q < end) *q++ = 0;
+  }
+  DEL (wchs, nwchs);
+  q = start + offset;
+  *q++ = (int) UINT_MAX;
+  assert (q <= lgl->wchs->stk.top);
+  lgl->wchs->stk.top = q;
+  lglfitstk (lgl, &lgl->wchs->stk);
+  lgl->limits->dfg = lgl->stats->pshwchs + lgl->opts->defragint.val;
+  lglrep (lgl, 2, 'F');
+  lglstop (lgl);
+}
+
+static void lgldis (LGL * lgl) {
+  int blit, nblit, tag, red, * p, * q, * eow, * w;
+  int idx, sign, lit, other, other2;
+  Stk bins, trns;
+  Val val, val2;
+  HTS * hts;
+  assert (!lgl->level);
+  CLR (bins); CLR (trns);
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = idx * sign;
+      hts = lglhts (lgl, lit);
+      if (!hts->offset) continue;
+      val = lglval (lgl, lit);
+      assert (hts->count > 0);
+      if (lgl->mt || val || lgliselim (lgl, lit)) {
+	lglshrinkhts (lgl, hts, 0);
+	continue;
+      }
+      assert (lglisfree (lgl, lit));
+      assert (lglmtstk (&bins));
+      assert (lglmtstk (&trns));
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	red = blit & REDCS;
+	if (tag == OCCS) continue;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	other = blit >> RMSHFT;
+	val = lglval (lgl, other);
+	if (val > 0) continue;
+	if (lgliselim (lgl, other)) continue;
+	if (tag == BINCS) {
+	  assert (!val);
+	  lglpushstk (lgl, &bins, blit);
+	  continue;
+	}
+	assert (tag == TRNCS);
+	other2 = *p;
+	val2 = lglval (lgl, other2);
+	if (val2 > 0) continue;
+	if (lgliselim (lgl, other2)) continue;
+	if (val < 0) {
+	  assert (val < 0 && !val2);
+	  nblit = red | RMSHFTLIT (other2) | BINCS;
+	  lglpushstk (lgl, &bins, nblit);
+	  if (abs (lit) < abs (other2)) {
+	    lgldrupligaddclsarg (lgl, REDCS, lit, other2, 0);
+	    lgldrupligdelclsarg (lgl, lit, other, other2, 0);
+	  }
+	  continue;
+	}
+	if (val2 < 0) {
+	  assert (!val && val2 < 0);
+	  nblit = red | RMSHFTLIT (other) | BINCS;
+	  lglpushstk (lgl, &bins, nblit);
+	  if (abs (lit) < abs (other)) {
+	    lgldrupligaddclsarg (lgl, REDCS, lit, other, 0);
+	    lgldrupligdelclsarg (lgl, lit, other, other2, 0);
+	  }
+	  continue;
+	}
+	assert (!val && !val2);
+	lglpushstk (lgl, &trns, blit);
+	lglpushstk (lgl, &trns, other2);
+      }
+      q = w;
+      for (p = bins.start; p != bins.top; p++) *q++ = *p;
+      for (p = trns.start; p != trns.top; p++) *q++ = *p;
+      lglshrinkhts (lgl, hts, q - w);
+      lglclnstk (&bins);
+      lglclnstk (&trns);
+    }
+  lglrelstk (lgl, &bins);
+  lglrelstk (lgl, &trns);
+  lglrelstk (lgl, &lgl->learned);
+}
+
+static int lglcmphase (LGL * lgl, int a, int b) {
+  return lgliphase (lgl, b) - lgliphase (lgl, a);
+}
+
+#define LGLCMPHASE(A,B) lglcmphase (lgl, *(A), *(B))
+
+static void lglconnaux (LGL * lgl, int glue) {
+  int lit, collect, lidx, size, origsize, red, act;
+  const int druplig = lgl->opts->druplig.val;
+  const int * p, * c, * start, * top;
+  Stk * stk, saved;
+  int * q, * d;
+  Val val;
+  if (glue >= 0) {
+    assert (glue < MAXGLUE);
+    red = REDCS;
+    stk = lgl->red + glue;
+  } else red = 0, stk = &lgl->irr;
+  start = q = stk->start;
+  top = stk->top;
+  CLR (saved);
+  for (c = q; c < top; c = p + 1) {
+    act = *c;
+    if (act == REMOVED) {
+      for (p = c + 1; p < top && *p == REMOVED; p++)
+	;
+      assert (p >= top || *p < NOTALIT || lglisact (*p));
+      p--;
+      continue;
+    }
+    if (lglisact (act)) assert (glue >= 0), *q++ = *c++;
+    else assert (glue < 0), act = -1;
+    d = q;
+    collect = 0;
+    lglclnstk (&saved);
+    for (p = c; assert (p < top), (lit = *p); p++) {
+      assert (lit < NOTALIT);
+      if (druplig) lglpushstk (lgl, &saved, lit);
+      if (collect) continue;
+      val = lglval (lgl, lit);
+      if (lgliselim (lgl, lit)) {
+	assert (lgl->eliminating || lgl->blocking);
+	collect = 1;
+      } else if (val > 0) collect = 1;
+      else if (!val) *q++ = lit;
+    }
+
+    size = q - d;
+    origsize = p - c;
+    assert (!druplig || origsize == lglcntstk (&saved));
+    assert (size <= origsize);
+
+    if (druplig && !collect && size > 1 && size < origsize)
+      *q = 0, lgldrupligaddclsaux (lgl, REDCS, d);
+
+    if (collect || p == c + 1) {
+      q = d - (act >= 0);
+    } else if (!size) {
+      q = d - (act >= 0);
+      if (!lgl->mt) {
+	LOG (1, "empty clause during connection garbage collection phase");
+	lglmt (lgl);
+      }
+    } else if (size == 1) {
+      q = d - (act >= 0);
+      LOG (1, "unit during garbage collection");
+      lglunit (lgl, d[0]);
+    } else if (size == 2) {
+      q = d - (act >= 0);
+      lglwchbin (lgl, d[0], d[1], red);
+      lglwchbin (lgl, d[1], d[0], red);
+    } else if (size == 3) {
+      q = d - (act >= 0);
+      lglwchtrn (lgl, d[0], d[1], d[2], red);
+      lglwchtrn (lgl, d[1], d[0], d[2], red);
+      lglwchtrn (lgl, d[2], d[0], d[1], red);
+    } else {
+      assert (size > 3);
+      if (lgl->opts->sortlits.val) SORT (int, d, size, LGLCMPHASE);
+      *q++ = 0;
+      lidx = d - start;
+      if (red) {
+	assert (lidx <= MAXREDLIDX);
+	lidx <<= GLUESHFT;
+	assert (0 <= lidx);
+	lidx |= glue;
+      }
+      (void) lglwchlrg (lgl, d[0], d[1], red, lidx);
+      (void) lglwchlrg (lgl, d[1], d[0], red, lidx);
+    }
+    if (druplig && (collect || origsize != size)) {
+      lglpushstk (lgl, &saved, 0);
+      lgldrupligdelclsaux (lgl, saved.start);
+    }
+  }
+  stk->top = q;
+  lglrelstk (lgl, &saved);
+}
+
+static void lglconsavedbin (LGL * lgl) {
+  int satisfied, eliminated, size, val0, val1, nunits = 0, nmt = 0;
+  const int druplig = lgl->opts->druplig.val, * p;
+  assert (lgl->rmredbintrn);
+  for (p = lgl->saved.bin.start; p < lgl->saved.bin.top; p += 2) {
+    assert (p + 1 < lgl->saved.bin.top);
+    satisfied = eliminated = val0 = val1 = 0;
+         if ((val0 = lglval (lgl, p[0])) > 0) satisfied = 1;
+    else if ((val1 = lglval (lgl, p[1])) > 0) satisfied = 1;
+    else if (lgliselim (lgl, p[0])) eliminated = 1;
+    else if (lgliselim (lgl, p[1])) eliminated = 1;
+    assert (!eliminated || lgl->eliminating || lgl->blocking);
+    if (satisfied || eliminated) size = INT_MAX;
+    else if (val0 < 0 && val1 < 0) {
+      nmt++;
+      size = 0;
+      if (!lgl->mt) {
+	LOG (1, "empty clause connecting saved binary clauses");
+	lglmt (lgl);
+      }
+    } else if (!val0 && val1 < 0) {
+      size = 1;
+      LOG (1, "unit during connecting saved binary clauses");
+      lglunit (lgl, p[0]);
+      nunits++;
+    } else if (val0 < 0 && !val1) {
+      size = 1;
+      LOG (1, "unit during connecting saved binary clauses");
+      lglunit (lgl, p[1]);
+      nunits++;
+    } else {
+      assert (!val0), assert (!val1);
+      size = 2;
+      lglwchbin (lgl, p[0], p[1], REDCS);
+      lglwchbin (lgl, p[1], p[0], REDCS);
+    }
+    if (druplig && (satisfied || eliminated || size < 2))
+      lgldrupligdelclsarg (lgl, p[0], p[1], 0);
+  }
+  lglprt (lgl, 
+    2 - (nmt || nunits),
+    "[gc-%d] reconnected %d binary clauses (produced %d empty %d units)",
+    lgl->stats->gcs, lglcntstk (&lgl->saved.bin)/2, nmt, nunits);
+  lglrelstk (lgl, &lgl->saved.bin);
+}
+
+static void lglconsavedtrn (LGL * lgl) {
+  const int druplig = lgl->opts->druplig.val, * p;
+  int satisfied, eliminated, size, val0, val1, val2;
+  int nmt = 0, nunits = 0, nbins = 0;
+  assert (lgl->rmredbintrn);
+  for (p = lgl->saved.trn.start; p < lgl->saved.trn.top; p += 3) {
+    assert (p + 1 < lgl->saved.trn.top);
+    satisfied = eliminated = val0 = val1 = val2 = 0;
+         if ((val0 = lglval (lgl, p[0])) > 0) satisfied = 1;
+    else if ((val1 = lglval (lgl, p[1])) > 0) satisfied = 1;
+    else if ((val2 = lglval (lgl, p[2])) > 0) satisfied = 1;
+    else if (lgliselim (lgl, p[0])) eliminated = 1;
+    else if (lgliselim (lgl, p[1])) eliminated = 1;
+    else if (lgliselim (lgl, p[2])) eliminated = 1;
+    assert (!eliminated || lgl->eliminating || lgl->blocking);
+    if (satisfied || eliminated) size = INT_MAX;
+    else if (val0 < 0 && val1 < 0 && val2 < 0) {
+      nmt++;
+      size = 0;
+      if (!lgl->mt) {
+	LOG (1, "empty clause connecting saved ternary clauses");
+	lglmt (lgl);
+      }
+    } else if (!val0 && val1 < 0 && val2 < 0) {
+      size = 1;
+      LOG (1, "unit during connecing saved ternary clauses");
+      lglunit (lgl, p[0]);
+      nunits++;
+    } else if (val0 < 0 && !val1 && val2 < 0) {
+      size = 1;
+      LOG (1, "unit during connecing saved ternary clauses");
+      lglunit (lgl, p[1]);
+      nunits++;
+    } else if (val0 < 0 && val1 < 0 && !val2) {
+      size = 1;
+      LOG (1, "unit during connecing saved ternary clauses");
+      lglunit (lgl, p[2]);
+      nunits++;
+    } else if (!val0 && !val1 && val2 < 0) {
+      size = 2;
+      nbins++;
+      lglwchbin (lgl, p[0], p[1], REDCS);
+      lglwchbin (lgl, p[1], p[0], REDCS);
+      if (druplig) lgldrupligaddclsarg (lgl, REDCS, p[0], p[1], 0);
+    } else if (!val0 && val1 < 0 && !val2) {
+      size = 2;
+      nbins++;
+      lglwchbin (lgl, p[0], p[2], REDCS);
+      lglwchbin (lgl, p[2], p[0], REDCS);
+      if (druplig) lgldrupligaddclsarg (lgl, REDCS, p[0], p[2], 0);
+    } else if (val0 < 0 && !val1 && !val2) {
+      size = 2;
+      nbins++;
+      lglwchbin (lgl, p[1], p[2], REDCS);
+      lglwchbin (lgl, p[2], p[1], REDCS);
+      if (druplig) lgldrupligaddclsarg (lgl, REDCS, p[1], p[2], 0);
+    } else {
+      size = 3;
+      assert (!val0), assert (!val1), assert (!val2);
+      lglwchtrn (lgl, p[0], p[1], p[2], REDCS);
+      lglwchtrn (lgl, p[1], p[0], p[2], REDCS);
+      lglwchtrn (lgl, p[2], p[0], p[1], REDCS);
+    }
+    if (druplig && (satisfied || eliminated || size < 3))
+      lgldrupligdelclsarg (lgl, p[0], p[1], p[2], 0);
+  }
+  lglprt (lgl, 
+    2 - (nmt || nunits), // || nbins), // NOTE would be too verbose ...
+    "[gc-%d] reconnected %d ternary clauses "
+    " (produced %d empty %d units %d binary)",
+    lgl->stats->gcs, lglcntstk (&lgl->saved.trn)/3, nmt, nunits, nbins);
+  lglrelstk (lgl, &lgl->saved.trn);
+}
+
+static void lglfullyconnected (LGL * lgl) {
+  if (!lgl->notfullyconnected) return;
+  LOG (1, "switching to fully connected mode");
+  lgl->notfullyconnected  = 0;
+}
+
+static void lglcon (LGL * lgl) {
+  int glue;
+  for (glue = -1; glue < MAXGLUE; glue++) lglconnaux (lgl, glue);
+  lglfullyconnected (lgl);
+}
+
+static void lglconsaved (LGL * lgl) {
+  if (lgl->rmredbintrn) {
+    lglconsavedbin (lgl);
+    lglconsavedtrn (lgl);
+    lgl->rmredbintrn = 0;
+    if (!lgl->mt && !lglbcpcomplete (lgl)) {
+      lglfullyconnected (lgl);
+      if (!lglbcp (lgl)) {
+	LOG (1, "empty clause generated propagating reconnected unit");
+	lglmt (lgl);
+      }
+    }
+  } else
+    assert (lglmtstk (&lgl->saved.bin)),
+    assert (lglmtstk (&lgl->saved.trn));
+}
+
+static void lglcount (LGL * lgl) {
+  int idx, sign, lit, tag, blit, red, other, other2, glue, count;
+  const int * p, * w, * c, * eow;
+  HTS * hts;
+  Stk * lir;
+  lgl->stats->irr.clauses.cur = 0;
+  lgl->stats->irr.lits.cur = 0;
+  lgl->stats->red.bin = 0;
+  lgl->stats->red.trn = 0;
+  lgl->stats->red.lrg = 0;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      if (!hts->offset) continue;
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	red = blit & REDCS;
+	tag = blit & MASKCS;
+	if (tag == LRGCS || tag == TRNCS) p++;
+	if (tag == LRGCS) continue;
+	assert (tag == BINCS || tag == TRNCS);
+	other = blit >> RMSHFT;
+	assert (abs (other) != abs (lit));
+	if (abs (lit) >= abs (other)) continue;
+	assert (2 == BINCS && 3 == TRNCS);
+	if (tag == TRNCS) {
+	  other2 = *p;
+	  assert (abs (other2) != abs (lit));
+	  assert (abs (other2) != abs (other));
+	  if (abs (lit) >= abs (other2)) continue;
+	}
+	if (!red) {
+	  lgl->stats->irr.clauses.cur++;
+	  if (tag == BINCS) lgl->stats->irr.lits.cur += 2;
+	  else assert (tag == TRNCS), lgl->stats->irr.lits.cur += 3;
+	} else if (tag == BINCS) lgl->stats->red.bin++;
+	else assert (tag == TRNCS), lgl->stats->red.trn++;
+      }
+    }
+  assert (lgl->stats->red.bin >= 0 && lgl->stats->red.trn >= 0);
+  for (c = lgl->irr.start; c < lgl->irr.top; c = p + 1) {
+    if (*(p = c) >= REMOVED) continue;
+    while (*p) p++;
+    lgl->stats->irr.lits.cur += p - c;
+    lgl->stats->irr.clauses.cur++;
+  }
+  LOG (1, "counted %d irredundant clauses with %d literals",
+       lgl->stats->irr.clauses.cur, lgl->stats->irr.lits.cur);
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    lir = lgl->red + glue;
+    count = 0;
+    for (c = lir->start; c < lir->top; c++)
+      if (!*c) count++;
+    if (count)
+      LOG (1, "counted %d redundant clauses with glue %d", count, glue);
+    lgl->stats->red.lrg += count;
+    lgl->stats->lir[glue].clauses = count;
+  }
+  assert (lgl->stats->red.lrg >= 0);
+  if (lgl->stats->red.bin)
+    LOG (1, "counted %d binary redundant clauses altogether",
+	 lgl->stats->red.bin);
+  if (lgl->stats->red.trn)
+    LOG (1, "counted %d ternary redundant clauses altogether",
+	 lgl->stats->red.trn);
+  if (lgl->stats->red.lrg)
+    LOG (1, "counted %d large redundant clauses altogether",
+	 lgl->stats->red.lrg);
+}
+
+static int lglilit (int ulit) {
+  int res = ulit/2;
+  assert (res >= 1);
+  if (ulit & 1) res = -res;
+  return res;
+}
+
+static void lgljwh (LGL * lgl) {
+  int idx, sign, lit, tag, blit, other, other2, red, size, glue;
+  const int *p, * w, * eow, * c;
+  Val val, tmp, tmp2;
+  HTS * hts;
+  Stk * s;
+  Flt inc;
+  CLN (lgl->jwh, 2*lgl->nvars);
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      val = lglval (lgl, lit);
+      if (val > 0) continue;
+      hts = lglhts (lgl, lit);
+      if (!hts->offset) continue;
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	if (!lgl->opts->jwhred.val && red) continue;
+	if (lgl->opts->jwhred.val == 2 && !red) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < abs (lit)) continue;
+	tmp = lglval (lgl, other);
+	if (tmp > 0) continue;
+	if (tag == BINCS) {
+	  assert (!tmp);
+	  inc = lglflt (-2, 1);
+	  lglincjwh (lgl, lit, inc);
+	  lglincjwh (lgl, other, inc);
+	} else {
+	  assert (tag == TRNCS);
+	  other2 = *p;
+	  if (abs (other2) < abs (lit)) continue;
+	  tmp2 = lglval (lgl, other2);
+	  if (tmp2 > 0) continue;
+	  assert ((val > 0) + (tmp > 0) + (tmp2 > 0) == 0);
+	  assert ((val < 0) + (tmp < 0) + (tmp2 < 0) <= 1);
+	  size = 3 + val + tmp + tmp2;
+	  assert (2 <= size && size <= 3);
+	  inc = lglflt (-size, 1);
+	  if (!val) lglincjwh (lgl, lit, inc);
+	  if (!tmp) lglincjwh (lgl, other, inc);
+	  if (!tmp2) lglincjwh (lgl, other2, inc);
+	}
+      }
+    }
+  for (glue = -1; glue < MAXGLUE; glue++) {
+    if (!lgl->opts->jwhred.val && glue >= 0) continue;
+    if (lgl->opts->jwhred.val == 2 && glue < 0) continue;
+    if (glue < 0) s = &lgl->irr;
+    else s = &lgl->red[glue];
+    for (c = s->start; c < s->top; c = p + 1) {
+      if (*(p = c) >= NOTALIT) continue;
+      val = -1;
+      size = 0;
+      while ((other = *p)) {
+	tmp = lglval (lgl, other);
+	if (tmp > val) val = tmp;
+	if (!tmp) size++;
+	p++;
+      }
+      if (val > 0) continue;
+      inc = lglflt (-size, 1);
+      for (p = c; (other = *p); p++)
+	if (!lglval (lgl, other))
+	  lglincjwh (lgl, other, inc);
+    }
+  }
+}
+
+static int * lglis (LGL * lgl) {
+  int idx, sign, lit, tag, blit, other, other2, red, * res;
+  const int *p, * w, * eow, * c;
+  Val val, tmp, tmp2;
+  HTS * hts;
+  Stk * s;
+  NEW (res, 2*lgl->nvars);
+  res += lgl->nvars;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      val = lglval (lgl, lit);
+      if (val > 0) continue;
+      hts = lglhts (lgl, lit);
+      if (!hts->offset) continue;
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	if (red) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < abs (lit)) continue;
+	tmp = lglval (lgl, other);
+	if (tmp > 0) continue;
+	if (tag == BINCS) {
+	  assert (!tmp);
+	  res[lit]++,
+	  res[other]++;
+	} else {
+	  assert (tag == TRNCS);
+	  other2 = *p;
+	  if (abs (other2) < abs (lit)) continue;
+	  tmp2 = lglval (lgl, other2);
+	  if (tmp2 > 0) continue;
+	  assert ((val > 0) + (tmp > 0) + (tmp2 > 0) == 0);
+	  assert ((val < 0) + (tmp < 0) + (tmp2 < 0) <= 1);
+	  if (!val) res[lit]++;
+	  if (!tmp) res[other]++;
+	  if (!tmp2) res[other2]++;
+	}
+      }
+    }
+  s = &lgl->irr;
+  for (c = s->start; c < s->top; c = p + 1) {
+    p = c;
+    if (*p >= NOTALIT) continue;
+    val = -1;
+    while ((other = *p)) {
+      tmp = lglval (lgl, other);
+      if (tmp > val) val = tmp;
+      p++;
+    }
+    if (val > 0) continue;
+    for (p = c; (other = *p); p++)
+      if (!lglval (lgl, other))
+	res[other]++;
+  }
+  return res;
+}
+
+static int lglsetjwhbias (LGL * lgl, int idx) {
+  AVar * av = lglavar (lgl, idx);
+  Flt pos, neg;
+  int bias;
+  idx = abs (idx);
+  pos = lgl->jwh[lglulit (idx)];
+  neg = lgl->jwh[lglulit (-idx)];
+  if (av->phase) return av->phase;
+  bias = (pos > neg) ? 1 : -1;
+  if (av->bias == bias) return bias;
+  av->bias = bias;
+  lgl->stats->phase.set++;
+  if (bias > 0) lgl->stats->phase.pos++; else lgl->stats->phase.neg++;
+  LOG (1, "JW bias %d (pos %s, neg %s)", 
+       bias * idx, lglflt2str (lgl, pos), lglflt2str (lgl, neg));
+  return bias;
+}
+
+static void lglsetbias (LGL * lgl, int idx, int bias) {
+  AVar * av = lglavar (lgl, idx);
+  assert (abs (bias) == 1);
+  if (av->phase) return;
+  av->bias = bias;
+  lgl->stats->phase.set++;
+  if (bias > 0) lgl->stats->phase.pos++; else lgl->stats->phase.neg++;
+  LOG (1, "set bias %d explicitly", bias * idx);
+}
+
+static void lglsetallphases (LGL * lgl) {
+  int res = 1, idx;
+  for (idx = 2; res && idx < lgl->nvars; idx++)
+    res = (!lglisfree (lgl, idx) || lglavar (lgl, idx)->phase);
+  lgl->allphaseset = res;
+}
+
+static void lglflushphases (LGL * lgl) {
+  int idx, flushed = 0;
+  AVar * av;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    av = lglavar (lgl, idx);
+    av->phase = 0;
+    flushed++;
+  }
+  lglprt (lgl, 1, "[flushphases] %d phases reset", flushed);
+  lgl->allphaseset = !flushed;
+  lgl->flushphases = 0;
+}
+
+static int lgluckyphase (LGL * lgl) {
+  int pos = 0, neg = 0, lit, idx, count = 0, res = 0;
+  int negrest, posrest;
+  const int * p, * c;
+  for (c = lgl->irr.start; c < lgl->irr.top; c = p + 1) {
+    int foundpos = 0, foundneg = 0;
+    if (*(p = c) >= NOTALIT) continue;
+    while ((lit = *p)) {
+      if (lit > 0) foundpos = 1;
+      if (lit < 0) foundneg = 1;
+      p++;
+    }
+    if (foundpos) pos++;
+    if (foundneg) neg++;
+    count++;
+  }
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    HTS * hts = lglhts (lgl, idx);
+    const int * p, * w, * eow;
+    w = lglhts2wchs (lgl, hts);
+    eow = w + hts->count;
+    for (p = w; p < eow; p++) {
+      int blit = *p, red, other;
+      int tag = blit & MASKCS;
+      if (tag == TRNCS || tag == LRGCS) p++;
+      if (tag == LRGCS) continue;
+      red = blit & REDCS;
+      if (red) continue;
+      other = blit >> RMSHFT;
+      if (abs (other) < idx) continue;
+      if (tag == TRNCS) {
+	int other2 = *p;
+	if (abs (other2) < idx) continue;
+	if (other < 0 || other2 < 0) neg++;
+      } else if (other < 0) neg++;
+      count++;
+      pos++;
+    }
+    hts = lglhts (lgl, -idx);
+    w = lglhts2wchs (lgl, hts);
+    eow = w + hts->count;
+    for (p = w; p < eow; p++) {
+      int blit = *p, red, other;
+      int tag = blit & MASKCS;
+      if (tag == TRNCS || tag == LRGCS) p++;
+      if (tag == LRGCS) continue;
+      red = blit & REDCS;
+      if (red) continue;
+      other = blit >> RMSHFT;
+      if (abs (other) < idx) continue;
+      if (tag == TRNCS) {
+	int other2 = *p;
+	if (abs (other2) < idx) continue;
+	if (other > 0 || other2 > 0) pos++;
+      } else if (other > 0) pos++;
+      count++;
+      neg++;
+    }
+  }
+  assert (count >= neg);
+  negrest = count - neg;
+  assert (count >= pos);
+  posrest = count - pos;
+  assert (count == lgl->stats->irr.clauses.cur);
+  lglprt (lgl, 1,
+    "[phase-count-%d] %d negative %.1f%% of %d except %d %.1f%%",
+    lgl->stats->phase.count,
+    neg, lglpcnt (neg, count), count, negrest, lglpcnt (negrest, count));
+  lglprt (lgl, 1,
+    "[phase-count-%d] %d positive %.1f%% of %d except %d %.1f%%",
+    lgl->stats->phase.count,
+    pos, lglpcnt (pos, count), count, posrest, lglpcnt (posrest, count));
+  if (neg >= count) {
+    res = -1;
+    lglprt (lgl, 1,
+      "[phase-count-%d] all clauses contain a negative literal",
+      lgl->stats->phase.count);
+  } else if (pos >= count) {
+    res = 1;
+    lglprt (lgl, 1,
+      "[phase-count-%d] all clauses contain a positive literal",
+      lgl->stats->phase.count);
+  } else if (lgl->stats->phase.count <= lgl->opts->phaseluckmaxround.val) {
+    int lim = lgl->opts->phaselucklim.val * (count / 1000);
+    int fac = lgl->opts->phaseluckfactor.val;
+    if (negrest <= lim &&
+	negrest <= posrest &&
+	posrest/fac >= negrest/100) {
+      res = -1;
+      lglprt (lgl, 1,
+	"[phase-count-%d] less non-negative clauses %d than limit %d (%.1f%%)",
+	lgl->stats->phase.count,
+	negrest, lim, lgl->opts->phaselucklim.val / 10.0);
+      lglprt (lgl, 1,
+	"[phase-count-%d] non-pos/non-neg = %d/%d = %.2f >= %.2f = %d/100",
+	lgl->stats->phase.count,
+	posrest, negrest, posrest/(double)negrest, fac/100.0, fac);
+    } else if (posrest <= lim && 
+               posrest <= negrest &&
+               negrest/fac >= posrest/100) {
+      res = 1;
+      lglprt (lgl, 1,
+	"[phase-count-%d] less non-positive clauses %d than limit %d (%.1f%%)",
+	lgl->stats->phase.count,
+	posrest, lim, lgl->opts->phaselucklim.val / 1000.0);
+      lglprt (lgl, 1,
+	"[phase-count-%d] non-neg/non-pos = %d/%d = %.2f >= %.2f = %d/100",
+	lgl->stats->phase.count,
+	negrest, posrest, negrest/(double)posrest, fac/100.0, fac);
+    }
+  } else
+      lglprt (lgl, 1,
+	"[phase-count-%d] skipping relative phase luck test",
+        lgl->stats->phase.count);
+  if (res)
+    lglprt (lgl, 1,
+      "[lucky-phase-%d] forcing lucky phase %d",
+      lgl->stats->phase.count,
+      res);
+  return res;
+}
+
+static void lglphase (LGL * lgl) {
+  int64_t set = lgl->stats->phase.set;
+  int64_t pos = lgl->stats->phase.pos;
+  int64_t neg = lgl->stats->phase.neg;
+  int idx, lucky;
+  lglstart (lgl, &lgl->times->phase);
+  if (lgl->flushphases) lglflushphases (lgl);
+  if (lgl->opts->phase.val) goto DONE;
+  lglsetallphases (lgl);
+  if (lgl->allphaseset) goto DONE;
+  lgl->stats->phase.count++;
+  lgljwh (lgl);
+  if ((lucky = lgluckyphase (lgl)))
+    for (idx = 2; idx < lgl->nvars; idx++)
+      lglsetbias (lgl, idx, lucky);
+  else
+    for (idx = 2; idx < lgl->nvars; idx++)
+      lglsetjwhbias (lgl, idx);
+  set = lgl->stats->phase.set - set;
+  pos = lgl->stats->phase.pos - pos;
+  neg = lgl->stats->phase.neg - neg;
+  lglprt (lgl, 1,
+     "[phase-%d] phase bias: %lld positive %.0f%%, %lld negative %.0f%%",
+     lgl->stats->phase.count,
+     (LGLL) pos, lglpcnt (pos, set),
+     (LGLL) neg, lglpcnt (neg, set));
+DONE:
+  lglstop (lgl);
+}
+
+static int lglmaplit (int * map, int lit) {
+  return map [ abs (lit) ] * lglsgn (lit);
+}
+
+static void lglmapstk (LGL * lgl, int * map, Stk * lits) {
+  int * p, * eol;
+  eol = lits->top;
+  for (p = lits->start; p < eol; p++)
+    *p = lglmaplit (map, *p);
+}
+
+static void lglmapqueue (LGL * lgl, int * map) {
+  int idx, found, * q, src, dst;
+  const int * p, * start;
+  QVar * qv;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    qv = lglqvar (lgl, idx);
+    if (!qv->enqueued) continue;
+    qv->pos = -1;
+  }
+  found = 0;
+  start = q = lgl->queue.stk.start;
+  for (p = q; p < lgl->queue.stk.top; p++) {
+    if (!(src = *p)) continue;
+    assert (1 < src);
+    dst = lglmaplit (map, src);
+    if (dst < 0) dst = -dst;
+    if (dst <= 1) continue;
+    qv = lglqvar (lgl, dst);
+    if (!qv->enqueued) continue;
+    if (qv->pos >= 0) continue;
+    qv->pos = (q - start);
+    assert (qv->pos >= 0);
+    if (!found && lgl->queue.next >= (p - start))
+      found = 1, lgl->queue.next = qv->pos;
+    *q++ = dst;
+  }
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    qv = lglqvar (lgl, idx);
+    if (!qv->enqueued) continue;
+    if (qv->pos >= 0) continue;
+    assert (q < lgl->queue.stk.top);
+    qv->pos = (q - start);
+    assert (qv->pos >= 0);
+    *q++ = idx;
+  }
+  lgl->queue.stk.top = q;
+  lglfitstk (lgl, &lgl->queue.stk);
+  if (!found) lgl->queue.next = lglcntstk (&lgl->queue.stk) - 1;
+  lgl->queue.mt = 0;
+}
+
+static void lglmapglue (LGL * lgl, int * map, Stk * lits) {
+  int * p, * eol;
+  eol = lits->top;
+  for (p = lits->start; p < eol; p++)
+    if (!lglisact (*p)) *p = lglmaplit (map, *p);
+}
+
+static void lglmaplits (LGL * lgl, int * map) {
+  int glue;
+  lglmapstk (lgl, map, &lgl->irr);
+  for (glue = 0; glue < MAXGLUE; glue++)
+    lglmapglue (lgl, map, &lgl->red[glue]);
+}
+
+static void lglmapvars (LGL * lgl, int * map, int nvars) {
+  int i, oldnvars = lgl->nvars, sign, udst, idst, usrc, isrc;
+  DVar * dvars;
+  QVar * qvars;
+  AVar * avars;
+  Val * vals;
+  int * i2e;
+  Flt * jwh;
+
+  if (nvars > 2) assert (nvars <= oldnvars);
+  else nvars = 0;
+
+  DEL (lgl->doms, 2*lgl->szvars);
+  NEW (lgl->doms, 2*nvars);
+
+  NEW (vals, nvars);
+  for (i = 2; i < oldnvars; i++)
+    if (lglisfree (lgl, i))
+      vals[map[i]] = lgl->vals[i];
+  DEL (lgl->vals, lgl->szvars);
+  lgl->vals = vals;
+
+  NEW (i2e, nvars);
+  for (i = 2; i < oldnvars; i++)
+    if (lglisfree (lgl, i))
+      i2e[map[i]] = lgl->i2e[i];
+  DEL (lgl->i2e, lgl->szvars);
+  lgl->i2e = i2e;
+
+  NEW (dvars, nvars);
+  for (i = 2; i < oldnvars; i++)
+    if (lglisfree (lgl, i))
+      dvars[map[i]] = lgl->dvars[i];
+  DEL (lgl->dvars, lgl->szvars);
+  lgl->dvars = dvars;
+
+  NEW (qvars, nvars);
+  for (i = 2; i < oldnvars; i++)
+    if (lglisfree (lgl, i))
+      qvars[map[i]] = lgl->qvars[i];
+  DEL (lgl->qvars, lgl->szvars);
+  lgl->qvars = qvars;
+
+  NEW (jwh, 2*nvars);
+  for (i = 2; i < oldnvars; i++)
+    if (lglisfree (lgl, i))
+      for (sign = -1; sign <= 1; sign += 2) {
+	  isrc = sign * i;
+	  idst = sign * map[i];
+	  usrc = lglulit (isrc);
+	  udst = lglulit (idst);
+	  jwh[udst] = lgladdflt (jwh[udst], lgl->jwh[usrc]);
+	}
+  DEL (lgl->jwh, 2*lgl->szvars);
+  lgl->jwh = jwh;
+
+  NEW (avars, nvars);	  	
+  for (i = 2; i < oldnvars; i++)
+    if (lglisfree (lgl, i))
+      avars[map[i]] = lgl->avars[i];
+  DEL (lgl->avars, lgl->szvars);
+  lgl->avars = avars;              // Last since 'lglisfree' depends on it !!!
+
+  lgl->nvars = lgl->szvars = nvars;
+  lgl->stats->fixed.current = 0;
+}
+
+static void lglmaphts (LGL * lgl, int * map) {
+  int idx, sign, lit, * w, *eow, * p, other, other2, blit, tag, red;
+  int newblit, newother, newother2;
+  HTS * hts;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      if (!hts->count) continue;
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	assert (tag == BINCS || tag == TRNCS || tag == LRGCS);
+	red = blit & REDCS;
+	other = blit >> RMSHFT;
+	newother = lglmaplit (map, other);
+	newblit = RMSHFTLIT (newother) | tag | red;
+	*p = newblit;
+	if (tag == BINCS) continue;
+	other2 = *++p;
+	if (tag == LRGCS) continue;
+	assert (tag == TRNCS);
+	newother2 = lglmaplit (map, other2);
+	*p = newother2;
+      }
+    }
+}
+
+static void lglmaptrail (LGL * lgl, int * map) {
+  int * p, * q, src, dst;
+  for (p = lgl->trail.start; p < lgl->trail.top; p++)
+    if (lglevel (lgl, *p) > 0) break;
+  for (q = lgl->trail.start; p < lgl->trail.top; p++) {
+    src = *p;
+    assert (lglevel (lgl, src) > 0);
+    dst = lglmaplit (map, src);
+    *q++ = dst;
+  }
+  lgl->trail.top = q;
+  lgl->flushed = lgl->next2 = lgl->next = lglcntstk (&lgl->trail);
+}
+
+static int lglptrjmp (int * repr, int max, int start) {
+#ifndef NDEBUG
+  int prev = 0, count = 0;
+#endif
+  int next, idx, res, sgn, tmp;
+  assert (repr);
+  next = start;
+  do {
+    res = next;
+    idx = abs (res);
+    assert (idx <= max);
+    sgn = lglsgn (res);
+    next = repr[idx];
+    next *= sgn;
+#ifndef NDEBUG
+    if (prev || next) assert (prev != next);
+    prev = res;
+    assert (count <= max);
+#endif
+  } while (next);
+  tmp = start;
+  while (tmp != res) {
+    idx = abs (tmp), sgn = lglsgn (tmp);
+    next = repr[idx] * sgn;
+    repr[idx] = sgn * res;
+    tmp = next;
+  }
+  return res;
+}
+
+static int lglirepr (LGL * lgl, int lit) {
+  assert (lgl->repr);
+  return lglptrjmp (lgl->repr, lgl->nvars - 1, lit);
+}
+
+static void lglmapext (LGL * lgl, int * map) {
+  int eidx, ilit, mlit;
+  Ext * ext;
+  for (eidx = 1; eidx <= lgl->maxext; eidx++) (void) lglerepr (lgl, eidx);
+  for (eidx = 1; eidx <= lgl->maxext; eidx++) {
+    ext = lgl->ext + eidx;
+    if (!ext->imported) continue;
+    if (ext->equiv) {
+      LOG (3, "mapping external %d to equivalent external %d",
+	   eidx, ext->repr);
+      continue;
+    }
+    ilit = ext->repr;
+    mlit = lglmaplit (map, ilit);
+    LOG (3, "mapping external %d to internal %d", eidx, mlit);
+    ext->repr = mlit;
+  }
+}
+
+static void lglsignedmark (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  int bit = 1 << (lit < 0);
+  if (av->mark & bit) return;
+  av->mark |= bit;
+}
+
+static void lglsignedunmark (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  int bit = 1 << (lit < 0);
+  if (!(av->mark & bit)) return;
+  av->mark &= ~bit;
+}
+
+static int lglsignedmarked (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  int bit = 1 << (lit < 0);
+  return av->mark & bit;
+}
+
+static void lglmapass (LGL * lgl, int * map) {
+  int * p, * q, iass, mass, flushed;
+  unsigned bit;
+  AVar * av;
+  if (abs (lgl->failed) != 1) lgl->failed = lglmaplit (map, lgl->failed);
+  for (p = q = lgl->assume.start; p < lgl->assume.top; p++) {
+    iass = *p;
+    mass = lglmaplit (map, iass);
+    if (mass == 1) continue;
+    if (mass == -1) {
+      if (lgl->failed != -1) {
+#ifndef NDEBUG
+	int * r;
+	for (r = lgl->eassume.start; r < lgl->eassume.top; r++)
+	  if (lglimport (lgl, *r) == -1) break;
+	assert (r < lgl->eassume.top);
+#endif
+	LOG (2, "enforcing a failed assumption");
+	lgl->failed = -1;
+      }
+      continue;
+    }
+    LOG (2, "mapping previous internal assumption %d to %d", iass, mass);
+    av = lglavar (lgl, mass);
+    bit = 1u << (mass < 0);
+    if (!(av->assumed & bit)) {
+      LOG (2, "assuming new representative %d instead of %d", mass, iass);
+      av->assumed |= bit;
+    }
+    *q++ = mass;
+  }
+  lgl->assume.top = q;
+  flushed = 0;
+  for (p = q = lgl->assume.start; p < lgl->assume.top; p++) {
+    iass = *p;
+    if (lglsignedmarked (lgl, iass)) { flushed++; continue; }
+    lglsignedmark (lgl, iass);
+    *q++ = iass;
+  }
+  lgl->assume.top = q;
+  for (p = lgl->assume.start; p < lgl->assume.top; p++) {
+    iass = *p;
+    assert (lglsignedmarked (lgl, iass));
+    lglsignedunmark (lgl, iass);
+  }
+  if (flushed)
+    LOG (2, "flushed %d duplicated internal assumptions", flushed);
+}
+
+static void lglmaplkhdscore (LGL * lgl, int * map, int oldnvars) {
+  LKHD * oldlkhdscore = lgl->tlk->lkhd, score;
+  int idx, src, sign, dst;
+  NEW (lgl->tlk->lkhd, 2*lgl->nvars);
+  lgl->tlk->lkhd += lgl->nvars;
+  for (idx = oldnvars-1; idx >= 2; idx--) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      src = sign * idx;
+      dst = lglmaplit (map, src);
+      if (abs (dst) <= 1) continue;
+      score = oldlkhdscore[src];
+      LOG (2, "mapping look-ahead score %s of %d as score of %d",
+	   lglflt2str (lgl, score), src, dst);
+      lgl->tlk->lkhd[dst] = score;
+    }
+  }
+  oldlkhdscore -= oldnvars;
+  DEL (oldlkhdscore, 2*oldnvars);
+}
+
+static int lglmapsize (LGL * lgl) {
+  int size = 0, idx;
+  for (idx = 2; idx < lgl->nvars; idx++) 
+    if (lglisfree (lgl, idx)) size++;
+  LOG (1, "mapping %d remaining variables", size);
+  return size;
+}
+
+static void lglmapnonequiv (LGL * lgl, int * map, int size) {
+  int count = 0, idx;
+  AVar * av;
+  Val val;
+  map[0] = 0, map[1] = 1;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (map[idx]) continue;
+    av = lglavar (lgl, idx);
+    if (av->type == FREEVAR) {
+      assert (idx > 0);
+      if (map[idx]) { assert (map[idx] < idx); continue; }
+      LOG (3, "mapping free %d to %d", idx, count + 2);
+      map[idx] = count + 2;
+      count++;
+    } else if (av->type == EQUIVAR) {
+      assert (lgl->repr);
+      assert (!map[idx]);
+    } else if (av->type == FIXEDVAR) {
+      val = lgl->vals[idx];
+      assert (val);
+      LOG (3, "mapping assigned %d to %d", idx, (int) val);
+      map[idx] = val;
+    } else {
+      assert (av->type == ELIMVAR);
+      assert (!lglifrozen (lgl, idx));
+      map[idx] = 0;
+    }
+  }
+  assert (count == size);
+}
+
+static void lglmapequiv (LGL * lgl, int * map) {
+  int idx, repr, dst;
+  AVar * av;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (map[idx]) continue;
+    av = lglavar (lgl, idx);
+    if (av->type == ELIMVAR) continue;
+    assert (av->type == EQUIVAR);
+    assert (lgl->repr);
+    assert (!map[idx]);
+    repr = lglirepr (lgl, idx);
+    assert (repr != idx);
+    assert (map[abs (repr)]);
+    dst = lglmaplit (map, repr);
+    LOG (3, "mapping equivalent %d to %d", idx, dst);
+    map[idx] = dst;
+  }
+}
+
+static int64_t lglsteps (LGL * lgl) {
+  int64_t res = lgl->stats->steps;
+#ifndef NDEBUG
+  // Note, this would be bulky and slow ...
+  int64_t steps = 0;
+  steps += lgl->stats->bca.steps;
+  steps += lgl->stats->blk.steps;
+  steps += lgl->stats->card.steps;
+  steps += lgl->stats->cce.steps;
+  steps += lgl->stats->elm.copies;
+  steps += lgl->stats->elm.resolutions;
+  steps += lgl->stats->elm.steps;
+  steps += lgl->stats->gauss.steps.elim;
+  steps += lgl->stats->gauss.steps.extr;
+  steps += lgl->stats->prb.basic.steps;
+  steps += lgl->stats->prb.simple.steps;
+  steps += lgl->stats->prb.treelook.steps;
+  steps += lgl->stats->props.lkhd;
+  steps += lgl->stats->props.search;
+  steps += lgl->stats->props.simp;
+  steps += lgl->stats->sweep.steps;
+  steps += lgl->stats->trd.steps;
+  steps += lgl->stats->ternres.steps;
+  steps += lgl->stats->unhd.steps;
+  assert (steps == res);
+#endif
+  return res;
+}
+
+static void lgltrep (LGL * lgl) {
+  int64_t steps, i;
+  double t;
+  if (!lgl->opts->trep.val) return;
+  if (lgl->opts->verbose.val) return;
+  steps = lglsteps (lgl);
+  if (steps < lgl->limits->trep.steps) return;
+  lgl->limits->trep.steps += lgl->opts->trepint.val;
+  t = lgl->opts->abstime.val ? lglgetime (lgl) : lglsec (lgl);
+  if (t < lgl->limits->trep.time) return;
+  lglrep (lgl, 0, (lgl->simp ? 'P' : 'S'));
+  i = lgl->limits->trep.time;
+  do {
+         if (!i)         i = 1;
+    else if (i == 1)     i = 2;
+    else if (i == 2)     i = 5;
+    else if (i < 10)     i = 10;
+    else if (i < 60)     i += 10;
+    else if (i < 300)    i += 60;
+    else if (i < 900)    i += 300;
+    else if (i < 7200)   i += 900;
+    else                 i += 3600;
+  } while (i < t);
+  lgl->limits->trep.time = i;
+}
+
+static int lglterminate (LGL * lgl) {
+  int64_t steps;
+  int res;
+  lgltrep (lgl);
+  if (!lgl->cbs) return 0;
+  if (!lgl->cbs->term.fun) return 0;
+  if (lgl->cbs->term.done) return 1;
+  steps = lglsteps (lgl);
+  if (steps < lgl->limits->term.steps) return 0;
+  res = lgl->cbs->term.fun (lgl->cbs->term.state);
+  if (res) lgl->cbs->term.done = res;
+  else lgl->limits->term.steps = steps + lgl->opts->termint.val;
+  return  res;
+}
+
+static void lglmap (LGL * lgl) {
+  int size, * map, oldnvars, mapsize;
+#ifndef NDEBUG
+  lglrelstk (lgl, &lgl->prevclause);
+#endif
+  lglrelstk (lgl, &lgl->promote);
+  assert (!lgl->level);
+  lgldreschedule (lgl);
+  size = lglmapsize (lgl);
+  oldnvars = lgl->nvars;
+  mapsize = lglmax (oldnvars, 2);
+  NEW (map, mapsize);
+  lglmapnonequiv (lgl, map, size);
+  lglmapequiv (lgl, map);
+  lglmaptrail (lgl, map);
+  lglmapvars (lgl, map, size + 2);
+  lglmaplits (lgl, map);
+  lglmapstk (lgl, map, &lgl->dsched);
+  lglmapqueue (lgl, map);
+  lglmapext (lgl, map);
+  lglmapass (lgl, map);
+  if (lgl->treelooking && lgl->tlk && lgl->tlk->lkhd)
+    lglmaplkhdscore (lgl, map, oldnvars);
+  assert (lglmtstk (&lgl->clause));
+  lglmaphts (lgl, map);
+  DEL (map, mapsize);
+  if (lgl->repr) DEL (lgl->repr, oldnvars);
+  lgl->unassigned = size;
+  lgldreschedule (lgl);
+#ifndef NLGLDRUPLIG
+  lgl->drupligunit = 0;
+#endif
+}
+
+static int lglgcnotnecessary (LGL * lgl) {
+  if (lgl->forcegc) return 0;
+  if (lgl->notfullyconnected) return 0;
+  return lgl->stats->fixed.sum <= lgl->limits->gc.fixed;
+}
+
+static void lglcompact (LGL * lgl) {
+  int glue;
+  lglfitstk (lgl, &lgl->assume);
+#ifndef NDEBUG
+  lglfitstk (lgl, &lgl->prevclause);
+#endif
+  lglfitstk (lgl, &lgl->clause);
+  lglfitstk (lgl, &lgl->eclause);
+  lglfitstk (lgl, &lgl->dsched);
+  lglfitstk (lgl, &lgl->queue.stk);
+  lglfitstk (lgl, &lgl->eassume);
+  lglfitstk (lgl, &lgl->extend);
+  lglfitstk (lgl, &lgl->learned);
+  lglfitstk (lgl, &lgl->frames);
+  lglfitstk (lgl, &lgl->promote);
+#ifndef NCHKSOL
+  lglfitstk (lgl, &lgl->orig);
+#endif
+  lglfitstk (lgl, &lgl->trail);
+  lgldefrag (lgl);
+  lglfitstk (lgl, &lgl->wchs->stk);
+
+  lglfitstk (lgl, &lgl->irr);
+  for (glue = 0; glue <= MAXGLUE; glue++)
+    lglfitlir (lgl, lgl->red + glue);
+  lglrelstk (lgl, &lgl->lcaseen);
+  lglrelstk (lgl, &lgl->resolvent);
+  lglrelstk (lgl, &lgl->minstk);
+  lglrelstk (lgl, &lgl->poisoned);
+  lglrelstk (lgl, &lgl->seen);
+  lglrelstk (lgl, &lgl->esched);
+  lglrelstk (lgl, &lgl->saved.bin);
+  lglrelstk (lgl, &lgl->saved.trn);
+}
+
+static void lglgc (LGL * lgl) {
+  if (lgl->mt) return;
+  lglchkred (lgl);
+  if (lglgcnotnecessary (lgl)) return;
+  lglstart (lgl, &lgl->times->gc);
+  lglchkbcpclean (lgl, "gc");
+  lglrep (lgl, 2, 'g');
+  lgl->stats->gcs++;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  lglconsaved (lgl);
+  do {			// Note, need to go into loop even if 'lgl->mt'!
+    lgldis (lgl);
+    lglcon (lgl);
+    if (lgl->mt) break;
+    if (lglbcpcomplete (lgl)) break;
+    if (lglbcp (lgl)) continue;
+    assert (!lgl->mt);
+    LOG (1, "empty clause after propagating garbage collection unit");
+    lglmt (lgl);
+  } while (!lgl->mt);
+  lglcount (lgl);
+  lglmap (lgl);
+
+  lglcompact (lgl);
+
+  lgl->limits->gc.fixed = lgl->stats->fixed.sum;
+
+  lglchkred (lgl);
+  lglrep (lgl, 2, 'c');
+  lglstop (lgl);
+}
+
+static int lgltopgc (LGL * lgl) {
+  if (lgl->mt) return 0;
+  assert (!lgl->forcegc && !lgl->allowforce);
+  lgl->forcegc = lgl->allowforce = 1;
+  lglgc (lgl);
+  assert (lgl->forcegc && lgl->allowforce);
+  lgl->forcegc = lgl->allowforce = 0;
+  return !lgl->mt;
+}
+
+static int lglrandec (LGL * lgl) {
+  unsigned size, pos, start, delta;
+  int lit;
+  lgl->limits->randec = lgl->stats->decisions;
+  lgl->limits->randec += lgl->opts->randecint.val/2;
+  lgl->limits->randec += lglrand (lgl) % lgl->opts->randecint.val;
+  assert (lgl->nvars > 2);
+  size = lgl->nvars - 2;
+  if (!size) return 0;
+  pos = start = lglrand (lgl) % size;
+  lit = 2 + pos;
+  assert (2 <= lit && lit < lgl->nvars);
+  if (lglval (lgl, lit)) {
+    delta = lglrand (lgl) % size;
+    if (size == 1) return 0;
+    if (!delta) delta++;
+    while (lglgcd (delta, size) != 1)
+      if (++delta == size) delta = 1;
+    do {
+      pos += delta;
+      if (pos >= size) pos -= size;
+      if (pos == start) return 0;
+      lit = pos + 2;
+      assert (2 <= lit && lit < lgl->nvars);
+    } while (lglval (lgl, lit));
+  }
+  lgl->stats->randecs++;
+  return lit;
+}
+
+static int lgladecide (LGL * lgl) {
+  int res, val;
+  while (lgl->assumed < lglcntstk (&lgl->assume)) {
+    res = lglpeek (&lgl->assume, lgl->assumed);
+    val = lglcval (lgl, res);
+    if (val > 0) LOG (3, "assumption %d already satisfied", res);
+    lgl->assumed++;
+    LOG (3, "new assumption queue level %d", lgl->assumed);
+    assert (val >= 0);
+    if (!val) return res;
+  }
+  return 0;
+}
+
+static int lgldefphase (LGL * lgl, int idx) {
+  int bias, res;
+  AVar * av;
+  assert (idx > 0);
+  av = lglavar (lgl, idx);
+  bias = lgl->opts->phase.val;
+  if (!bias) bias = av->bias;
+  if (!bias) bias = lglsetjwhbias (lgl, idx);
+  if (lgl->opts->phasesave.val) {
+    if (!(res = av->phase)) res = av->phase = bias;
+    else if (lgl->opts->phasesave.val < 0) res = -res;
+  } else res = bias;
+  return res;
+}
+
+static int lgldecidephase (LGL * lgl, int lit) {
+  int res = abs (lit);
+  AVar * av = lglavar (lgl, lit);
+  if (av->fase) return av->fase * res;
+  if (lgldefphase (lgl, res) <= 0) res = -res;
+  if (lgl->opts->randphase.val &&
+      lgl->limits->randphase <= lgl->stats->decisions) {
+    LOG (1, "flipping phase due to random phases enabled");
+    lgl->limits->randphase = lgl->stats->decisions;
+    lgl->limits->randphase += lgl->opts->randphaseint.val/2;
+    lgl->limits->randphase += lglrand (lgl) % lgl->opts->randphaseint.val;
+    lgl->stats->randphases++;
+    res = -res;
+  }
+  return res;
+}
+
+static int lglhasbins (LGL * lgl, int lit) {
+  int blit, tag, other, other2, val, val2, implied;
+  const int * p, * w, * eos, * q;
+  HTS * hts;
+  assert (!lgl->level);
+  assert (lglisfree (lgl, lit));
+  hts = lglhts (lgl, lit);
+  w = lglhts2wchs (lgl, hts);
+  eos = w + hts->count;
+  for (p = w; p < eos; p++) {
+    if (lgl->treelooking) INCSTEPS (prb.treelook.steps);
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == BINCS) {
+      other = blit >> RMSHFT;
+      val = lglval (lgl, other);
+      assert (val >= 0);
+      if (!val) return 1;
+    } else if (tag == TRNCS) {
+      other = blit >> RMSHFT;
+      other2= *++p;
+      val = lglval (lgl, other);
+      val2 = lglval (lgl, other2);
+      assert (val >= 0 || val2 >= 0);
+      if (val > 0 || val2 > 0) continue;
+      if (!val && val2 < 0) return 1;
+      if (val < 0 && !val2) return 1;
+    } else {
+      assert (tag == LRGCS);
+      q = lglidx2lits (lgl, (blit & REDCS), *++p);
+      implied = 0;
+      while ((other = *q++)) {
+	if (other == lit) continue;
+	val = lglval (lgl, other);
+	if (val > 0) break;
+	if (val < 0) continue;
+	if (implied) break;
+	implied = other;
+      }
+      if (other) continue;
+      if (implied) return 1;
+    }
+  }
+  return 0;
+}
+
+static int lglprunedecide (LGL *);
+
+static int lgldecide (LGL * lgl) {
+  int lit;
+  lglchkbcpclean (lgl, "decide");
+  if (!lgl->unassigned) return 0;
+  if ((lit = lgladecide (lgl))) {
+    LOG (2, "using assumption %d as decision", lit);
+    lgl->alevel = lgl->level + 1;
+    LOG (2, "new assumption decision level %d", lgl->alevel);
+  } else if (!(lit = lglprunedecide (lgl))) {
+    if (lgl->stats->stability.level > 0 &&
+        lgl->stats->stability.level <= lgl->level)
+      lglupdstab (lgl);
+    if (lgl->opts->randec.val &&
+	lgl->limits->randec <= lgl->stats->decisions) {
+      lit = lglrandec (lgl);
+      lit = lgldecidephase (lgl, lit);
+      LOG (2, "random decision %d", lit);
+    } else {
+      lit = lglnextdecision (lgl, 1);
+      lit = lgldecidephase (lgl, lit);
+    }
+  }
+  if (lit && lit != INT_MIN) lgldassume (lgl, lit);
+  return 1;
+}
+
+static void lgldcpdis (LGL * lgl) {
+  int idx, sign, lit, tag, blit, red, other, other2, i;
+  const int * w, * p, * eow;
+  Val val;
+  HTS * hts;
+  Stk * s;
+  NEW (lgl->dis, 1);
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      if (!hts->offset) continue;
+      assert (hts->count > 0);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      hts->count = hts->offset = 0;
+      val = lglval (lgl, lit);
+      if (val > 0) continue;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	val = lglval (lgl, other);
+	if (val > 0) continue;
+	red = blit & REDCS;
+	if (red && !lglisfree (lgl, other)) continue;
+	if (tag == BINCS) {
+	  s = red ? &lgl->dis->red.bin : &lgl->dis->irr.bin;
+	} else {
+	  assert (tag == TRNCS);
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	  val = lglval (lgl, other2);
+	  if (val > 0) continue;
+	  if (red && !lglisfree (lgl, other2)) continue;
+	  s = red ? &lgl->dis->red.trn : &lgl->dis->irr.trn;
+	  lglpushstk (lgl, s, other2);
+	}
+	lglpushstk (lgl, s, other);
+	lglpushstk (lgl, s, lit);
+	lglpushstk (lgl, s, 0);
+      }
+    }
+  lglrststk (&lgl->wchs->stk, 2);
+  lgl->wchs->stk.top[-1] = (int) UINT_MAX;
+  for (i = 0; i < MAXLDFW; i++) lgl->wchs->start[i] = UINT_MAX;
+  lgl->wchs->free = 0;
+  lglrelstk (lgl, &lgl->learned);
+}
+
+static void lgldcpclnstk (LGL * lgl, int red, Stk * s) {
+  int oldsz, newsz, lit, mark, satisfied, repr, act, changed;
+  const int druplig = lgl->opts->druplig.val;
+  const int * p, * c, * eos = s->top;
+  int * start, * q, * r, * d;
+  Stk * t, saved;
+  Val val;
+  CLR (saved);
+  q = start = s->start;
+  for (c = q; c < eos; c = p + 1) {
+    act = *c;
+    if (act == REMOVED) {
+      for (p = c + 1; p < eos && *p == REMOVED; p++)
+	;
+      assert (p >= eos || *p < NOTALIT || lglisact (*p));
+      p--;
+      continue;
+    }
+    if (lglisact (act)) *q++ = *c++; else act = -1;
+    d = q;
+    satisfied = changed = 0;
+#ifndef NDEBUG
+    for (p = c; assert (p < eos), (lit = *p); p++) {
+      assert (!lglavar (lgl, lit)->mark);
+      repr = lglirepr (lgl, lit);
+      assert (abs (repr) == 1 || !lglavar (lgl, lit)->mark);
+    }
+#endif
+    lglclnstk (&saved);
+    for (p = c; assert (p < eos), (lit = *p); p++) {
+      assert (lit < NOTALIT);
+      if (druplig) lglpushstk (lgl, &saved, lit);
+      if (satisfied) continue;
+      repr = lglirepr (lgl, lit);
+      val = lglcval (lgl, repr);
+      if (val > 0) { satisfied = 1; continue; }
+      if (val < 0) { changed = 1; continue; }
+      mark = lglmarked (lgl, repr);
+      if (mark < 0) { satisfied = 1; continue; }
+      if (mark > 0) { changed = 1; continue; }
+      if (lit != repr) changed = 1;
+      lglmark (lgl, repr);
+      *q++ = repr;
+    }
+    oldsz = p - c;
+    for (r = d; r < q; r++) lglunmark (lgl, *r);
+    newsz = q - d;
+    assert (satisfied || newsz == oldsz || changed);
+    if (druplig && !satisfied && newsz > 1 && changed)
+      *q = 0, lgldrupligaddclsaux (lgl, REDCS, d);
+    if (satisfied || !oldsz) { q = d - (act >= 0); continue; }
+    if (newsz >= 4) {
+      assert (act < 0 || d[-1] == act);
+      *q++ = 0;
+      assert (d <= c);
+    } else if (!newsz) {
+      LOG (1, "found empty clause while cleaning decomposition");
+      lglmt (lgl);
+      q = d - (act >= 0);
+    } else if (newsz == 1) {
+      LOG (1, "new unit %d while cleaning decomposition", d[0]);
+      lglunit (lgl, d[0]);
+      q = d - (act >= 0);
+    } else if (newsz == 2) {
+      t = red ? &lgl->dis->red.bin : &lgl->dis->irr.bin;
+      if (s != t) {
+	lglpushstk (lgl, t, d[0]);
+	lglpushstk (lgl, t, d[1]);
+	lglpushstk (lgl, t, 0);
+	q = d - (act >= 0);
+      } else *q++ = 0;
+    } else {
+      assert (newsz == 3);
+      t = red ? &lgl->dis->red.trn : &lgl->dis->irr.trn;
+      if (s != t) {
+	lglpushstk (lgl, t, d[0]);
+	lglpushstk (lgl, t, d[1]);
+	lglpushstk (lgl, t, d[2]);
+	lglpushstk (lgl, t, 0);
+	q = d - (act >= 0);
+      } else *q++ = 0;
+    }
+    if (druplig && (satisfied || changed)) {
+      lglpushstk (lgl, &saved, 0);
+      lgldrupligdelclsaux (lgl, saved.start);
+    }
+  }
+  s->top = q;
+  lglrelstk (lgl, &saved);
+}
+
+static void lgldcpconnaux (LGL * lgl, int red, int glue, Stk * s) {
+  int * start = s->start, * q, * d, lit, size, lidx, act;
+  const int * p, * c, * eos = s->top;
+  assert (red == 0 || red == REDCS);
+  assert (!glue || red);
+  q = start;
+  for (c = q; c < eos; c = p + 1) {
+    if (lglisact (act = *c)) *q++ = *c++; else act = -1;
+    d = q;
+    for (p = c; (lit = *p); p++) {
+      assert (!lgl->repr[abs (lit)]);
+      assert (!lgl->vals[abs (lit)]);
+      *q++ = lit;
+    }
+    size = q - d;
+    if (size == 2) {
+      q = d - (act >= 0);
+      lglwchbin (lgl, d[0], d[1], red);
+      lglwchbin (lgl, d[1], d[0], red);
+    } else if (size == 3) {
+      q = d - (act >= 0);
+      lglwchtrn (lgl, d[0], d[1], d[2], red);
+      lglwchtrn (lgl, d[1], d[0], d[2], red);
+      lglwchtrn (lgl, d[2], d[0], d[1], red);
+    } else {
+      assert (size > 3);
+      *q++ = 0;
+      lidx = d - start;
+      if (red) {
+	assert (lidx <= MAXREDLIDX);
+	lidx <<= GLUESHFT;
+	assert (0 <= lidx);
+	lidx |= glue;
+      }
+      (void) lglwchlrg (lgl, d[0], d[1], red, lidx);
+      (void) lglwchlrg (lgl, d[1], d[0], red, lidx);
+    }
+  }
+  s->top = q;
+}
+
+static void lgldcpcon (LGL * lgl) {
+  Stk * lir;
+  int glue;
+  lgldcpconnaux (lgl, 0, 0, &lgl->dis->irr.bin);
+  lgldcpconnaux (lgl, REDCS, 0, &lgl->dis->red.bin);
+  lgldcpconnaux (lgl, 0, 0, &lgl->dis->irr.trn);
+  lgldcpconnaux (lgl, REDCS, 0, &lgl->dis->red.trn);
+  lglrelstk (lgl, &lgl->dis->irr.bin);
+  lglrelstk (lgl, &lgl->dis->irr.trn);
+  lglrelstk (lgl, &lgl->dis->red.bin);
+  lglrelstk (lgl, &lgl->dis->red.trn);
+  DEL (lgl->dis, 1);
+  lgldcpconnaux (lgl, 0, 0, &lgl->irr);
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    lir = lgl->red + glue;
+    lgldcpconnaux (lgl, REDCS, glue, lir);
+  }
+  lglfullyconnected (lgl);
+}
+
+static void lgldcpcln (LGL * lgl) {
+  int glue, old, rounds = 0;
+  Stk * lir;
+  do {
+    rounds++;
+    old = lgl->stats->fixed.current;
+    lgldcpclnstk (lgl, 0, &lgl->irr);
+    lgldcpclnstk (lgl, 0, &lgl->dis->irr.bin);
+    lgldcpclnstk (lgl, 0, &lgl->dis->irr.trn);
+    lgldcpclnstk (lgl, REDCS, &lgl->dis->red.bin);
+    lgldcpclnstk (lgl, REDCS, &lgl->dis->red.trn);
+    for (glue = 0; glue < MAXGLUE; glue++) {
+      lir = lgl->red + glue;
+      lgldcpclnstk (lgl, REDCS, lir);
+    }
+  } while (old < lgl->stats->fixed.current);
+  LOG (1, "iterated %d decomposition cleaning rounds", rounds);
+}
+
+static void lglepush (LGL * lgl, int ilit) {
+  int elit = ilit ? lglexport (lgl, ilit) : 0;
+  lglpushstk (lgl, &lgl->extend, elit);
+  LOG (4, "pushing external %d internal %d", elit, ilit);
+}
+
+static void lglemerge (LGL * lgl, int ilit0, int ilit1) {
+  int elit0 = lglexport (lgl, ilit0), elit1 = lglexport (lgl, ilit1);
+  int repr0 = lglerepr (lgl, elit0), repr1 = lglerepr (lgl, elit1);
+  Ext * ext0 = lglelit2ext (lgl, repr0);
+  Ext * ext1 = lglelit2ext (lgl, repr1);
+#ifndef NDEBUG
+  int repr = repr1;
+#endif
+  assert (abs (repr0) != abs (repr1));
+  if (repr0 < 0) {
+#ifndef NLGLOG
+    repr0 *= -1;
+#endif
+    repr1 *= -1;
+  }
+  ext0->equiv = 1;
+  ext0->repr = repr1;
+  if (ext1->aliased) ext0->aliased = 1;
+  LOG (2, "merging external literals %d and %d", repr0, repr1);
+  assert (lglerepr (lgl, elit0) == repr);
+  assert (lglerepr (lgl, elit1) == repr);
+  assert (!(ext0->frozen || ext0->tmpfrozen) ||
+	    ext1->frozen || ext1->tmpfrozen);
+  lglepush (lgl, -ilit0); lglepush (lgl, ilit1); lglepush (lgl, 0);
+  lglepush (lgl, ilit0); lglepush (lgl, -ilit1); lglepush (lgl, 0);
+  lgldrupligaddclsarg (lgl, REDCS, -ilit0, ilit1, 0);
+  lgldrupligaddclsarg (lgl, REDCS, ilit0, -ilit1, 0);
+}
+
+static void lglimerge (LGL * lgl, int lit, int repr) {
+  int idx = abs (lit);
+  AVar * av = lglavar (lgl, idx);
+  assert (!lglifrozen (lgl, lit) || lglifrozen (lgl, repr));
+  if (lit < 0) repr = -repr;
+  assert (av->type == FREEVAR);
+  assert (lgl->repr);
+  av->type = EQUIVAR;
+  lgl->repr[idx] = repr;
+  lgl->stats->prgss++;
+  lgl->stats->irrprgss++;
+  lgl->stats->equiv.sum++;
+  lgl->stats->equiv.current++;
+  assert (lgl->stats->equiv.sum > 0);
+  assert (lgl->stats->equiv.current > 0);
+  lglemerge (lgl, idx, repr);
+}
+
+static void lglfreezer (LGL * lgl) {
+  int frozen, melted, tmpfrozen, elit, erepr, ilit;
+  Ext * ext, * rext;
+  int * p, eass;
+  if (lgl->frozen) return;
+  for (elit = 1; elit <= lgl->maxext; elit++)
+    lgl->ext[elit].tmpfrozen = 0;
+  tmpfrozen = frozen = 0;
+  if (!lglmtstk (&lgl->eassume)) {
+    for (p = lgl->eassume.start; p < lgl->eassume.top; p++) {
+      eass = *p;
+      ext = lglelit2ext (lgl, eass);
+      assert (!ext->melted);
+      assert (!ext->eliminated);
+      assert (!ext->blocking);
+      if (!ext->frozen && !ext->tmpfrozen) {
+	ext->tmpfrozen = 1;
+	tmpfrozen++;
+	LOG (2, "temporarily freezing external assumption %d", eass);
+	erepr = lglerepr (lgl, eass);
+	rext = lglelit2ext (lgl, erepr);
+	if (ext != rext && !rext->frozen && !rext->tmpfrozen) {
+	  assert (!rext->equiv);
+	  assert (!rext->eliminated);
+	  // assert (!rext->blocking);
+	  LOG (2,
+	    "temporarily freezing external assumption literal %d", erepr);
+	  rext->tmpfrozen = 1;
+	  tmpfrozen++;
+	}
+      }
+    }
+  }
+  for (elit = 1; elit <= lgl->maxext; elit++) {
+    ext = lglelit2ext (lgl, elit);
+    if (!ext->frozen) continue;
+    frozen++;
+    assert (!ext->melted);
+    assert (!ext->eliminated);
+    assert (!ext->blocking);
+    erepr = lglerepr (lgl, elit);
+    rext = lglelit2ext (lgl, erepr);
+    if (ext == rext) continue;
+    if (rext->frozen) continue;
+    if (rext->tmpfrozen) continue;
+    // assert (!rext->melted);
+    assert (!rext->equiv);
+    assert (!rext->eliminated);
+    // assert (!rext->blocking);
+    LOG (2, "temporarily freezing external literal %d", erepr);
+    rext->tmpfrozen = 1;
+    tmpfrozen++;
+  }
+  melted = 0;
+  for (elit = 1; elit <= lgl->maxext; elit++) {
+    ext = lglelit2ext (lgl, elit);
+    if (ext->frozen) continue;
+    if (ext->melted) continue;
+    if (ext->tmpfrozen) continue;
+    if (!ext->imported) continue;
+    LOG (2, "permanently melted external %d", elit);
+    ext->melted = 1;
+    melted++;
+  }
+  LOG (2, "found %d frozen external variables", frozen);
+  LOG (2, "temporarily frozen %d external variables", tmpfrozen);
+  LOG (2, "permanently melted %d external variables", melted);
+  lgl->frozen = 1;
+  LOG (2, "frozen solver");
+  melted = frozen = 0;
+  for (ilit = 2; ilit < lgl->nvars; ilit++) {
+    if (!lglisfree (lgl, ilit)) continue;
+    if (lglifrozen (lgl, ilit)) frozen++; else melted++;
+  }
+  lgl->allfrozen = !melted;
+  if (lgl->allfrozen) 
+    lglprt (lgl, 1, "[freezer] all %d free variables frozen", frozen);
+  else
+    lglprt (lgl, 1,
+      "[freezer] frozen %d variables out of %d free variables %.0f%%",
+      frozen, frozen + melted, lglpcnt (frozen, frozen + melted));
+}
+
+static int lglcmprepr (LGL * lgl, int a, int b) {
+  int f = lglifrozen (lgl, a), g = lglifrozen (lgl, b), res;
+  if ((res = g - f)) return res;
+  if ((res = (abs (a) - abs (b)))) return res;
+  return a - b;
+}
+
+static int lgltarjan (LGL * lgl) {
+  int * dfsimap, * mindfsimap, idx, oidx, sign, lit, blit, tag, other;
+  int dfsi, mindfsi, ulit, uother, tmp, repr, res, sgn, frozen;
+  const int * p, * w, * eow;
+  Stk stk, component;
+  AVar * av;
+  HTS * hts;
+  if (lgl->mt) return 0;
+  if (!lgl->nvars) return 1;
+  assert (lgl->frozen);
+  dfsi = 0;
+  NEW (dfsimap, 2*lgl->nvars);
+  NEW (mindfsimap, 2*lgl->nvars);
+  NEW (lgl->repr, lgl->nvars);
+  CLR (stk); CLR (component);
+  res = 1;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      ulit = lglulit (lit);
+      tmp = dfsimap[ulit];
+      if (tmp) continue;
+      lglpushstk (lgl, &stk, lit);
+      while (!lglmtstk (&stk)) {
+	lit = lglpopstk (&stk);
+	if (lit) {
+	  ulit = lglulit (lit);
+	  if (dfsimap[ulit]) continue;
+	  dfsimap[ulit] = mindfsimap[ulit] = ++dfsi;
+	  lglpushstk (lgl, &component, lit);
+	  assert (dfsi > 0);
+	  lglpushstk (lgl, &stk, lit);
+	  lglpushstk (lgl, &stk, 0);
+	  hts = lglhts (lgl, -lit);
+	  if (!hts->offset) continue;
+	  assert (hts->count > 0);
+	  w = lglhts2wchs (lgl, hts);
+	  eow = w + hts->count;
+	  for (p = w; p < eow; p++) {
+	    blit = *p;
+	    tag = blit & MASKCS;
+	    if (tag != BINCS) { p++; continue; }
+	    other = blit >> RMSHFT;
+	    uother = lglulit (other);
+	    tmp = dfsimap[uother];
+	    if (tmp) continue;
+	    lglpushstk (lgl, &stk, other);
+	  }
+	} else {
+	  assert (!lglmtstk (&stk));
+	  lit = lglpopstk (&stk);
+	  ulit = lglulit (lit);
+	  mindfsi = dfsimap[ulit];
+	  assert (mindfsi);
+	  hts = lglhts (lgl, -lit);
+	  w = lglhts2wchs (lgl, hts);
+	  eow = w + hts->count;
+	  for (p = w; p < eow; p++) {
+	    blit = *p;
+	    tag = blit & MASKCS;
+	    if (tag != BINCS) { p++; continue; }
+	    other = blit >> RMSHFT;
+	    uother = lglulit (other);
+	    tmp = mindfsimap[uother];
+	    if (tmp >= mindfsi) continue;
+	    mindfsi = tmp;
+	  }
+	  if (mindfsi == dfsimap[ulit]) {
+	    repr = lit;
+	    frozen = lglifrozen (lgl, repr);
+	    for (p = component.top - 1; (other = *p) != lit; p--) {
+	      if (lglcmprepr (lgl, other, repr) < 0) repr = other;
+	      if (!frozen && lglifrozen (lgl, other)) frozen = 1;
+	    }
+	    while ((other = lglpopstk (&component)) != lit) {
+	      mindfsimap[lglulit (other)] = INT_MAX;
+	      if (other == repr) continue;
+	      if (other == -repr) {
+		LOG (1, "empty clause since repr[%d] = %d", repr, other);
+		lgldrupligaddclsarg (lgl, REDCS, repr, 0);
+		lglmt (lgl); res = 0; goto DONE;
+	      }
+	      sgn = lglsgn (other);
+	      oidx = abs (other);
+	      tmp = lgl->repr[oidx];
+	      if (tmp == sgn * repr) continue;
+	      LOG (2, "repr[%d] = %d", oidx, sgn * repr);
+	      if (tmp) {
+		LOG (1, "empty clause since repr[%d] = %d and repr[%d] = %d",
+		     oidx, tmp, oidx, sgn * repr);
+		lgldrupligaddclsarg (lgl, REDCS, repr, 0);
+		lglmt (lgl); res = 0; goto DONE;
+	      } else {
+		av = lglavar (lgl, oidx);
+		assert (sgn*oidx == other);
+		if (av->type == FREEVAR) lglimerge (lgl, other, repr);
+		else assert (av->type == FIXEDVAR);
+	      }
+	    }
+	    mindfsimap[lglulit (lit)] = INT_MAX;
+	    if (frozen) {
+	      LOG (2, "equivalence class of %d is frozen", repr);
+	      assert (lglifrozen (lgl, repr));
+	    }
+	  } else mindfsimap[ulit] = mindfsi;
+	}
+      }
+    }
+  }
+DONE:
+  lglrelstk (lgl, &stk);
+  lglrelstk (lgl, &component);
+  DEL (mindfsimap, 2*lgl->nvars);
+  DEL (dfsimap, 2*lgl->nvars);
+  if (!res) DEL (lgl->repr, lgl->nvars);
+  if (lgl->mt) lgldrupligaddclsarg (lgl, REDCS, 0);
+  return res;
+}
+
+static int lglsyncunits (LGL * lgl) {
+  int * units, * eou, * p, elit, erepr, ilit, res, count = 0;
+  void (*produce)(void*, int);
+  int64_t steps;
+  Ext * ext;
+  Val val;
+  if (lgl->mt) return 0;
+  if (!lgl->cbs) return 1;
+  if (!lgl->cbs->units.consume.fun) return 1;
+  assert (!lgl->simp || !lgl->level);
+  steps = lglsteps (lgl);
+  if (steps < lgl->limits->sync.steps) return 1;
+  lgl->limits->sync.steps = steps + lgl->opts->syncunint.val;
+  lgl->stats->sync.units.consumed.calls++;
+  lgl->cbs->units.consume.fun (lgl->cbs->units.consume.state, &units, &eou);
+  if (units == eou) return 1;
+  lgl->stats->sync.units.consumed.tried++;
+  produce = lgl->cbs->units.produce.fun;
+  lgl->cbs->units.produce.fun = 0;
+  for (p = units; !lgl->mt && p < eou; p++) {
+    elit = *p;
+    erepr = lglerepr (lgl, elit);
+    ext = lglelit2ext (lgl, erepr);
+    assert (!ext->equiv);
+    ilit = ext->repr;
+    if (!ilit) continue;
+    if (erepr < 0) ilit = -ilit;
+    if (ilit == 1) continue;
+    if (ilit == -1) val = -1;
+    else {
+      assert (abs (ilit) > 1);
+      val = lglval (lgl, ilit);
+      if (val && lglevel (lgl, ilit)) val = 0;
+    }
+    if (val == 1) continue;
+    if (val == -1) {
+      LOG (1, "mismatching synchronized external unit %d", elit);
+      if (lgl->level > 0) lglbacktrack (lgl, 0);
+      lglmt (lgl);
+    } else if (!lglisfree (lgl, ilit)) continue;
+    else {
+      assert (!val);
+      if (lgl->level > 0) lglbacktrack (lgl, 0);
+      lglunit (lgl, ilit);
+      LOG (2, "importing internal unit %d external %d",
+	   lgl->tid, ilit, elit);
+      count++;
+    }
+  }
+  lgl->cbs->units.produce.fun = produce;
+  if (lgl->cbs->units.consumed.fun)
+    lgl->cbs->units.consumed.fun (lgl->cbs->units.consumed.state, count);
+  if (count) lgl->stats->sync.units.consumed.actual++;
+  if (lgl->mt) return 0;
+  if (count) LOG (1, "imported %d units", count);
+  if (!count) return 1;
+  assert (!lgl->level);
+  res = lglbcp (lgl);
+  if(!res && !lgl->mt) lglmt (lgl);
+  return res;
+}
+
+static int lglelitblockingoreliminated (LGL * lgl, int elit) {
+  Ext * ext = lglelit2ext (lgl, elit);
+  return ext->blocking || ext->eliminated;
+}
+
+static int lglsynclsexist (LGL * lgl) {
+  int len, lit, blit, tag, other, other2;
+  int * s, * p, * w, * eow;
+  HTS * hts;
+  len = lglcntstk (&lgl->clause);
+  assert (!len || lgl->clause.top[-1]);
+  if (len <= 1) return 0;
+  s = lgl->clause.start;
+  for (p = s + 1; p + 1 < lgl->clause.top; p++) {
+    assert (lglmarked (lgl, *p) > 0);
+    if (lglhts (lgl, *s)->count > lglhts (lgl, *p)->count)
+      SWAP (int, *s, *p);
+  }
+  hts = lglhts (lgl, (lit = *s));
+  assert (lglmarked (lgl, lit) > 0);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    if (tag == BINCS) {
+      other = blit >> RMSHFT;
+      if (lglmarked (lgl, other) > 0) return 1;
+    } else {
+      assert (tag == TRNCS);
+      if (len <= 2) continue;
+      other = blit >> RMSHFT;
+      if (lglmarked (lgl, other) > 0) return 1;
+      other2 = *p;
+      if (lglmarked (lgl, other2) > 0) return 1;
+    }
+  }
+  return 0;
+}
+
+static int lglsyncls (LGL * lgl) {
+  int maxlevel, level, nonfalse, numtrue, res, delta, glue, consumed;
+  int * cls, elit, erepr, tmp, ilit, len, newglue;
+  const int * p;
+  int64_t rate;
+  if (lgl->mt) return 0;
+  if (!lgl->cbs) return 1;
+  if (!lgl->cbs->cls.consume.fun) return 1;
+  assert (!lgl->simp);
+  if (lgl->stats->confs < lgl->limits->sync.confs) return 1;
+  delta = lgl->opts->synclsint.val;
+  if (lgl->stats->sync.cls.consumed.calls) {
+    rate = 100*lgl->stats->sync.cls.consumed.tried;
+    rate /= lgl->stats->sync.cls.consumed.calls;
+    LOG (2, "syncls tried/calls = %lld/%lld = %d%%",
+      (LGLL) lgl->stats->sync.cls.consumed.tried,
+      (LGLL) lgl->stats->sync.cls.consumed.calls,
+      rate);
+    if (rate) delta /= rate;
+  }
+  lgl->limits->sync.confs = lgl->stats->confs + delta;
+  lgl->stats->sync.cls.consumed.calls++;
+  consumed = 0;
+RESTART:
+  lgl->cbs->cls.consume.fun (lgl->cbs->cls.consume.state, &cls, &glue);
+  if (!cls) return 1;
+  lgl->stats->sync.cls.consumed.tried++;
+  LOGCLS (2, cls, "trying to import external clause");
+  assert (lglmtstk (&lgl->clause));
+  maxlevel = nonfalse = numtrue = 0;
+#ifndef NDEBUG
+  for (p = cls; (elit = *p); p++) {
+    ilit = lglimport (lgl, elit);
+    if (abs (ilit) <= 1) continue;
+    assert (!lglmarked (lgl, ilit));
+  }
+#endif
+  for (p = cls; (elit = *p); p++) {
+    erepr = lglerepr (lgl, elit);
+    if (lglelitblockingoreliminated (lgl, erepr)) break;
+    ilit = lglimport (lgl, erepr);
+    if (!ilit) break;
+    if (ilit == 1) break;
+    if (ilit == -1) continue;
+    tmp = lglifixed (lgl, ilit);
+    if (tmp > 0) break;
+    if (tmp < 0) continue;
+    tmp = lglmarked (lgl, ilit);
+    if (tmp > 0) continue;
+    if (tmp < 0) break;
+    lglpushstk (lgl, &lgl->clause, ilit);
+    lglmark (lgl, ilit);
+    tmp = lglval (lgl, ilit);
+    if (tmp > 0) numtrue++;
+    else if (!tmp) nonfalse++;
+    else if ((level = lglevel (lgl, ilit)) > maxlevel) maxlevel = level;
+  }
+  res = 1;
+  if (!elit && lglsynclsexist (lgl)) elit = INT_MAX;
+  for (p = lgl->clause.start; p < lgl->clause.top; p++)
+    lglunmark (lgl, *p);
+  if (elit) goto DONE;
+  len = lglcntstk (&lgl->clause);
+  if (!numtrue && nonfalse <= 1) {
+    if (len <= 1 || maxlevel <= 1) level = 0;
+    else {
+      level = 0;
+      for (p = lgl->clause.start; p < lgl->clause.top; p++) {
+	ilit = *p;
+	tmp = lglval (lgl, ilit);
+	assert (tmp <= 0);
+	if (!tmp) continue;
+	tmp = lglevel (lgl, ilit);
+	if (tmp < maxlevel && tmp > level) level = tmp;
+      }
+    }
+    if (level < lgl->level) {
+      LOG (2, "importing clause requires to backtrack to level %d", level);
+      lglbacktrack (lgl, level);
+    }
+  }
+  lglpushstk (lgl, &lgl->clause, 0);
+  newglue = glue;
+  LOGCLS (2, lgl->clause.start,
+    "successfully imported as glue %d redundant glue %d length %d clause",
+    newglue, glue, len);
+  lgl->stats->sync.cls.consumed.actual++;
+  lgldrupligaddcls (lgl, 0);			// TODO?
+  lgladdcls (lgl, REDCS, newglue, !numtrue);
+  consumed++;
+  if (lgl->mt) res = 0;
+  else res = lglbcpsearch (lgl);
+DONE:
+  lglclnstk (&lgl->clause);
+  if (res && lgl->opts->synclsall.val) goto RESTART;
+  if (lgl->cbs->cls.consumed.fun)
+    lgl->cbs->cls.consumed.fun (lgl->cbs->cls.consumed.state, consumed);
+  return res;
+}
+
+static int lglprbpull (LGL * lgl, int lit, int probe) {
+  AVar * av;
+  assert (lgl->level == 1);
+  av = lglavar (lgl, lit);
+  if (av->mark) return 0;
+  if (!lglevel (lgl, lit)) return 0;
+  assert (lglevel (lgl, lit) == 1);
+  av->mark = 1;
+  lglpushstk (lgl, &lgl->seen, -lit);
+  LOG (3, "pulled in literal %d during probing analysis", -lit);
+  return 1;
+}
+
+static int lglprbana (LGL * lgl, int probe) {
+  int open, lit, r0, r1, tag, red, other, res, * p, * rsn;
+  assert (lgl->level == 1);
+  assert (lgl->conf.lit);
+  assert (lglmtstk (&lgl->seen));
+  lit = lgl->conf.lit;
+  r0 = lgl->conf.rsn[0], r1 = lgl->conf.rsn[1];
+  open = lglprbpull (lgl, lit, probe);
+  LOG (2, "starting probing analysis with reason of literal %d", lit);
+  for (;;) {
+    assert (lglevel (lgl, lit) == 1);
+    tag = r0 & MASKCS;
+    if (tag == BINCS || tag == TRNCS) {
+      other = r0 >> RMSHFT;
+      if (lglprbpull (lgl, other, probe)) open++;
+      if (tag == TRNCS && lglprbpull (lgl, r1, probe)) open++;
+    } else {
+      assert (tag == LRGCS);
+      red = r0 & REDCS;
+      p = lglidx2lits (lgl, red, r1);
+      while ((other = *p++)) open += lglprbpull (lgl, other, probe);
+    }
+    LOG (3, "open %d antecedents in probing analysis", open-1);
+    assert (open > 0);
+    while (!lglmarked (lgl, lit = lglpopstk (&lgl->trail)))
+      lglunassign (lgl, lit);
+    lglunassign (lgl, lit);
+    if (!--open) { res = lit; break; }
+    LOG (2, "analyzing reason of literal %d in probing analysis next", lit);
+    rsn = lglrsn (lgl, lit);
+    r0 = rsn[0], r1 = rsn[1];
+  }
+  assert (res);
+  if (res == probe)
+    LOG (2, "probing analysis returns the probe %d as 1st UIP", probe);
+  else
+    LOG (2, "probing analysis returns different 1st UIP %d and not probe %d",
+	 res, probe);
+  lglpopnunmarkstk (lgl, &lgl->seen);
+  return res;
+}
+
+static int lglederef (LGL * lgl, int elit) {
+  int ilit, res;
+  Ext * ext;
+  assert (elit);
+  if (abs (elit) > lgl->maxext) return -1;
+  ext = lglelit2ext (lgl, elit);
+  if (!(res = ext->val)) {
+    assert (!ext->equiv);
+    ilit = ext->repr;
+    res = ilit ? lglcval (lgl, ilit) : -1;
+  }
+  if (elit < 0) res = -res;
+  return res;
+}
+
+static int lgldecomp (LGL *); // TODO move
+
+static int lglhasbin (LGL * lgl, int a, int b) {
+  int blit, tag, other, res = 0;
+  const int * w, * eow, * p;
+  int64_t inc;
+  HTS * ha, * hb;
+  ha = lglhts (lgl, a);
+  hb = lglhts (lgl, b);
+  if (hb->count < ha->count) {
+    SWAP (int, a, b); SWAP (HTS *, ha, hb);
+  }
+  w = lglhts2wchs (lgl, ha);
+  eow = w + ha->count;
+  for (p = w; !res && p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == OCCS) continue;
+    if (tag == TRNCS || tag == LRGCS) { p++; continue; }
+    assert (tag == BINCS);
+    other = blit >> RMSHFT;
+    if (other == b) res = 1;
+  }
+  inc = 2 + (int)(p - w);
+  if (lgl->card) ADDSTEPS (card.steps, inc);
+  if (lgl->simpleprobing) ADDSTEPS (prb.simple.steps, inc);
+  return res;
+}
+
+static void lglwrkinit (LGL * lgl, int posonly, int fifo) {
+  int size, lit;
+  NEW (lgl->wrk, 1);
+  lgl->wrk->fifo = fifo;
+  size = lgl->wrk->size = lgl->nvars;
+  if (posonly) {
+    NEW (lgl->wrk->pos, size);
+    lgl->wrk->posonly = 1;
+  } else {
+    NEW (lgl->wrk->pos, 2*size);
+    lgl->wrk->pos += size;
+    for (lit = -size + 1; lit < -1; lit++) lgl->wrk->pos[lit] = -1;
+  }
+  for (lit = 2; lit < size; lit++) lgl->wrk->pos[lit] = -1;
+}
+
+static void lglwrkreset (LGL * lgl) {
+  lglrelstk (lgl, &lgl->wrk->queue);
+  if (lgl->wrk->posonly) DEL (lgl->wrk->pos, lgl->wrk->size);
+  else {
+    lgl->wrk->pos -= lgl->wrk->size;
+    DEL (lgl->wrk->pos, 2*lgl->wrk->size);
+  }
+  DEL (lgl->wrk, 1);
+}
+
+static void lglwrkcompact (LGL * lgl) {
+  int i, j = 0, lit, tail = lglcntstk (&lgl->wrk->queue);
+  for (i = lgl->wrk->head; i < tail; i++) {
+    lit = lgl->wrk->queue.start[i];
+    if (!lit) continue;
+    assert (!lgl->wrk->posonly || 1 < lit);
+    assert (1 < abs (lit) && abs (lit) < lgl->wrk->size);
+    assert (lgl->wrk->pos[lit] == i);
+    if (!lglisfree (lgl, lit)) {
+      lgl->wrk->pos[lit] = -1;
+      assert (lgl->wrk->count > 0);
+      lgl->wrk->count--;
+    } else {
+      lgl->wrk->queue.start[j] = lit;
+      lgl->wrk->pos[lit] = j++;
+    }
+  }
+  lglrststk (&lgl->wrk->queue, j);
+  lgl->wrk->head = 0;
+}
+
+static int lglwrktouched (LGL * lgl, int lit) {
+  if (lgl->wrk->posonly) lit = abs (lit);
+  return lgl->wrk->pos[lit] >= 0;
+}
+
+static int lglwrktouch (LGL * lgl, int lit) {
+  int tail, pos;
+  if (!lglisfree (lgl, lit)) return 1;
+  if (lgl->donotsched) {
+    if (lgl->ternresing && lglavar (lgl, lit)->donoternres) return 1;
+    if (lgl->simpleprobing && lglavar (lgl, lit)->donotsimpleprobe) return 1;
+  }
+  if (lgl->wrk->posonly) lit = abs (lit);
+  tail = lglcntstk (&lgl->wrk->queue);
+  LOG (4, "work touch %d", lit);
+  if ((pos = lgl->wrk->pos[lit]) >= 0) {
+    assert (lgl->wrk->queue.start[pos] == lit);
+    lgl->wrk->queue.start[pos] = 0;
+  }
+  lgl->wrk->count++;
+  assert (lgl->wrk->count > 0);
+  lgl->wrk->pos[lit] = tail;
+  lglpushstk (lgl, &lgl->wrk->queue, lit);
+  if (tail/2 > lgl->wrk->count) lglwrkcompact (lgl);
+  return 1;
+}
+
+static int lglwrkdeq (LGL * lgl) {
+  int res, pos;
+  while ((pos = lgl->wrk->head) < lglcntstk (&lgl->wrk->queue)) {
+    lgl->wrk->head++;
+    res = lgl->wrk->queue.start[pos];
+    if (!res) continue;
+    lgl->wrk->queue.start[pos] = 0;
+    assert (lgl->wrk->count > 0);
+    lgl->wrk->count--;
+    assert (lgl->wrk->pos[res] == pos);
+    lgl->wrk->pos[res] = -1;
+    if (lglisfree (lgl, res)) return res;
+  }
+  return 0;
+}
+
+static int lglwrkpop (LGL * lgl) {
+  int res;
+  while (lglcntstk (&lgl->wrk->queue) > lgl->wrk->head) {
+    res = lglpopstk (&lgl->wrk->queue);
+    if (!res) continue;
+#ifndef NDEBUG
+    {
+      int pos = lglcntstk (&lgl->wrk->queue);
+      assert (lgl->wrk->pos[res] == pos);
+    }
+#endif
+    lgl->wrk->pos[res] = -1;
+    if (lglisfree (lgl, res)) return res;
+  }
+  return 0;
+}
+
+static int lglwrknext (LGL * lgl) {
+  return lgl->wrk->fifo ? lglwrkdeq (lgl) : lglwrkpop (lgl);
+}
+
+static int lglrandlitrav (LGL * lgl, int (*fun)(LGL*,int lit)) {
+  int delta, mod, prev, first, ulit, count;
+  if (lgl->nvars < 2) return 0;
+  first = mod = 2*lgl->nvars;
+  ulit = lglrand (lgl) % mod;
+  delta = lglrand (lgl) % mod;
+  if (!delta) delta++;
+  while (lglgcd (delta, mod) > 1)
+    if (++delta == mod) delta = 1;
+  count = mod;
+  LOG (2,
+    "random literal traversal start %d delta %d mod %d",
+     ulit, delta, mod);
+  for (;;) {
+    count--;
+    assert (count >= 0);
+    if (ulit >= 4 && !fun (lgl, lglilit (ulit))) return 0;
+    prev = ulit;
+    ulit += delta;
+    if (ulit >= mod) ulit -= mod;
+    if (ulit == first) { assert (!count); break; }
+    if (first == mod) first = prev;
+  }
+  return 1;
+}
+
+static void lglsimpleprobeinit (LGL * lgl) {
+  int idx, rem = 0, ret = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) lgl->avars[idx].equiv = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    if (lglavar (lgl, idx)->donotsimpleprobe) ret++; else rem++;
+  }
+  if (!rem) {
+    ret = 0;
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      if (!lglisfree (lgl, idx)) continue;
+      lglavar (lgl, idx)->donotsimpleprobe = 0;
+      rem++;
+    }
+  }
+  if (!ret)
+    lglprt (lgl, 1,
+      "[simpleprobe-%d] all %d free variables schedulable",
+      lgl->stats->prb.simple.count, rem);
+  else
+    lglprt (lgl, 1,
+      "[simpleprobe-%d] %d schedulable variables %.0f%%",
+      lgl->stats->prb.simple.count, rem, lglpcnt (rem, lglrem (lgl)));
+  lglwrkinit (lgl, 0, 1);
+  assert (!lgl->donotsched), lgl->donotsched = 1;
+  lglrandlitrav (lgl, lglwrktouch);
+  assert (lgl->donotsched), lgl->donotsched = 0;
+  assert (lgl->opts->prbsimple.val);
+  lglchkirrstats (lgl);
+}
+
+static void lglsimpleprobereset (LGL * lgl, int nvars) {
+  const int * p;
+  int idx;
+  lglrelstk (lgl, &lgl->sprb->units);
+  lglrelstk (lgl, &lgl->sprb->impls);
+  lglrelstk (lgl, &lgl->sprb->eqs);
+  for (idx = 2; idx < lgl->nvars; idx++) lgl->avars[idx].donotsimpleprobe = 1;
+  for (p = lgl->wrk->queue.start; p < lgl->wrk->queue.top; p++)
+    lgl->avars[abs (*p)].donotsimpleprobe = 0;
+  lglwrkreset (lgl);
+  lglrelstk (lgl, &lgl->sprb->counted);
+  lglrelstk (lgl, &lgl->sprb->marked);
+  assert (nvars == lgl->nvars);
+  lgl->sprb->spes -= nvars;
+  DEL (lgl->sprb->spes, 2*nvars);
+}
+
+static int lglflush (LGL *);
+static void lgldense (LGL *, int rmredbintrn);
+static void lglsparse (LGL *);
+
+static int lglsimpleprobeunits (LGL * lgl) {
+  const int * p;
+  int lit, res;
+  Val val;
+  res = 0;
+  lglchkirrstats (lgl);
+  for (p = lgl->sprb->units.start; !lgl->mt && p < lgl->sprb->units.top; p++) {
+    lit = *p;
+    val = lglval (lgl, lit);
+    if (val > 0) continue;
+    lgl->stats->prb.simple.failed++;
+    if (val < 0) {
+      lgldrupligaddclsarg (lgl, REDCS, lit, 0);
+      LOG (1, "inconsistent unit %d", lit);
+      lglmt (lgl);
+    } else {
+      lglunit (lgl, lit);
+      res++;
+      if (!lglflush (lgl)) {
+	LOG (1, "propagating simple HBR unit %d results in conflict", lit);
+	lglmt (lgl);
+      }
+    }
+  }
+  return res;
+}
+
+static int lglsimpleprobeimpls (LGL * lgl) {
+  int a, b, res;
+  res = 0;
+  while (!lglmtstk (&lgl->sprb->impls)) {
+    b = lglpopstk (&lgl->sprb->impls);
+    a = lglpopstk (&lgl->sprb->impls);
+    if (lglval (lgl, a) || lglval (lgl, b)) continue;
+    if (lglhasbin (lgl, a, b)) continue;
+    LOG (2, "adding previously detected hyper binary resolvent %d %d", a, b);
+    lgldrupligaddclsarg (lgl, REDCS, a, b, 0);
+    res++;
+    lgl->stats->hbr.cnt++;
+    lgl->stats->hbr.simple++;
+    (void) lglwchbin (lgl, a, b, REDCS);
+    (void) lglwchbin (lgl, b, a, REDCS);
+    lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+    lglwrktouch (lgl, -a);
+    lglwrktouch (lgl, -b);
+    if (!lglhasbin (lgl, -a, -b)) continue;
+    LOG (2, "found equivalent literals %d and %d", -a, b);
+    lglpushstk (lgl, &lgl->sprb->eqs, -a);
+    lglpushstk (lgl, &lgl->sprb->eqs, b);
+  }
+  return res;
+}
+
+static int lglhasonlybin (LGL * lgl, int lit, int other) {
+  HTS * hts = lglhts (lgl, lit);
+  const int * w;
+  int blit;
+  if (hts->count != 1) return 0;
+  w = lglhts2wchs (lgl, hts);
+  blit = *w;
+  if ((blit & MASKCS) != BINCS) return 0;
+  return (blit >> RMSHFT) == other;
+}
+
+static int lglsimpleprobemerged (LGL * lgl, int a, int b) {
+  return lglhasonlybin (lgl, -a, b) && lglhasonlybin (lgl, -b, a);
+}
+
+static int lglflushclauses (LGL * lgl, int lit);
+
+static void lglsimpleprobeclscp (LGL * lgl, int nonrepr, int repr, Stk * stk) {
+  int blit, tag, red, other, other2, lidx, count, found, start, trivial;
+  const int * p, * w, * eow, * c, * q;
+  HTS * hts = lglhts (lgl, nonrepr);
+  assert (abs (repr) < abs (nonrepr));
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  count = 0;
+  for (p = w; p < eow; p++) {
+    INCSTEPS (prb.simple.steps);
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    start = lglcntstk (stk);
+    trivial = 0;
+    red = blit & REDCS;
+    lglpushstk (lgl, stk, red);
+    lglpushstk (lgl, stk, repr);
+    if (tag == BINCS || tag == TRNCS) {
+      other = blit >> RMSHFT;
+      if (other == -repr) trivial = 1;
+      else if (other != repr) lglpushstk (lgl, stk, other);
+      if (tag == TRNCS) {
+	other2 = *p;
+	if (other2 == -repr) trivial = 1;
+	else if (other2 != repr) lglpushstk (lgl, stk, other2);
+      }
+    } else {
+      assert (tag == OCCS);
+      lidx = blit >> RMSHFT;
+      c = lglidx2lits (lgl, red, lidx);
+      found = 0;
+      for (q = c; !trivial && (other = *q); q++) {
+	if (other >= NOTALIT) trivial = 1;
+	else if (other == nonrepr) found++;
+	else if (other == -repr) trivial = 1;
+	else if (other != repr) lglpushstk (lgl, stk, other);
+      }
+      assert (trivial || found);
+    }
+    if (trivial) lglrststk (stk, start);
+    else lglpushstk (lgl, stk, 0), count++;
+  }
+  LOG (2, "copied %d clauses with %d replacing %d by %d",
+       count, nonrepr, nonrepr, repr);
+}
+
+static int lglsimpleprobebinexists (LGL * lgl, int a, int b) {
+  const int * p, * w, * eow;
+  int blit, tag, red, other;
+  HTS * hts;
+  hts = lglhts (lgl, a);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag != BINCS) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    other = blit >> RMSHFT;
+    if (other == b) return 1;
+  }
+  return 0;
+}
+
+static int lglsimpleprobetrnexists (LGL * lgl, int a, int b, int c) {
+  int blit, tag, red, other, other2;
+  const int * p, * w, * eow;
+  HTS * hts;
+  hts = lglhts (lgl, a);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    red = blit & REDCS;
+    if (red) continue;
+    other = blit >> RMSHFT;
+    if (tag == BINCS) {
+      if (other == b) return 1;
+      if (other == c) return 1;
+    } else if (tag == TRNCS) {
+      other2 = *p;
+      if (other == b && other2 == c) return 1;
+      if (other == c && other2 == b) return 1;
+    }
+  }
+  return 0;
+}
+
+static int lglsimpleprobelrgexists (LGL * lgl, int a) {
+  int blit, tag, red, other, other2, lidx, res;
+  const int * p, * w, * eow, * c, * q;
+  HTS * hts;
+  for (p = lgl->clause.start; p + 1 < lgl->clause.top; p++) {
+    other = *p;
+    assert (!lglsignedmarked (lgl, other));
+    lglsignedmark (lgl, other);
+  }
+  assert (lglsignedmarked (lgl, a));
+  hts = lglhts (lgl, a);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  res = 0;
+  for (p = w; !res && p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    red = blit & REDCS;
+    if (red || tag == LRGCS) continue;
+    other = blit >> RMSHFT;
+    if (tag == BINCS) {
+      res = lglsignedmarked (lgl, other);
+    } else if (tag == TRNCS) {
+      other2 = *p;
+      res = lglsignedmarked (lgl, other) && lglsignedmarked (lgl, other2);
+    } else {
+      assert (tag == OCCS);
+      lidx = other;
+      c = lglidx2lits (lgl, 0, lidx);
+      for (q = c; (other = *q); q++)
+	if (!lglsignedmarked (lgl, other)) break;
+      res = !other;
+    }
+  }
+  for (p = lgl->clause.start; p + 1 < lgl->clause.top; p++) 
+    lglunmark (lgl, *p);
+  return res;
+}
+
+static int lglsimpleprobeclausexists (LGL * lgl) {
+  int len = lglcntstk (&lgl->clause) - 1, a, b, c, * p, * s, res;
+  assert (len >= 0);
+  assert (!lgl->clause.top[-1]);
+  s = lgl->clause.start;
+  for (p = s + 1; p + 1 < lgl->clause.top; p++)
+    if (lglhts (lgl, *s)->count > lglhts (lgl, *p)->count)
+      SWAP (int, *s, *p);
+  a = lgl->clause.start[0];
+  if (len == 2) {
+    b = lgl->clause.start[1];
+    res = lglsimpleprobebinexists (lgl, a, b);
+  } else if (len == 3) {
+    b = lgl->clause.start[1];
+    c = lgl->clause.start[2];
+    res = lglsimpleprobetrnexists (lgl, a, b, c);
+  } else if (len > 3)
+    res = lglsimpleprobelrgexists (lgl, a);
+  else res = 0;
+  if (res) LOG (2, "will not add already existing clause");
+  return res;
+}
+
+static void lglsimpleprobeaddclausesonstack (LGL * lgl, Stk * stk) {
+  int count, red, lit, size;
+  const int * c, * p, * q;
+  count = 0;
+  for (c = stk->start; c < stk->top; c = p + 1) {
+    red = *(p = c);
+    if (p[1] == REMOVED) {
+      p++;
+      while (p + 1 < stk->top && p[1] == REMOVED) p++;
+      continue;
+    }
+    assert (!red || red == REDCS);
+    assert (lglmtstk (&lgl->clause));
+    do {
+      lit = *++p;
+      lglpushstk (lgl, &lgl->clause, lit);
+    } while (lit);
+    if (!lglisimpcls (lgl) && !lglsimpleprobeclausexists (lgl)) {
+      lgldrupligaddcls (lgl, REDCS);
+      q = lgl->clause.start;
+      size = lglcntstk (&lgl->clause);
+      assert (size > 0);
+      assert (!q[size-1]);
+      size--;
+      if (size > 2 && lgl->opts->prbsimple.val >= 3)
+	while ((lit = *q++))
+	  lglwrktouch (lgl, lit);
+      if (size == 2 && lgl->opts->prbsimple.val >= 2)
+	lglwrktouch (lgl, -q[0]),
+	lglwrktouch (lgl, -q[1]);
+      lgladdcls (lgl, red, 0, 1);
+      count++;
+    }
+    lglclnstk (&lgl->clause);
+    if (!lglflush (lgl)) break;
+  }
+  LOG (2, "added %d non-trivial clauses", count);
+}
+
+static void lglsimpleprobeaddprbincls (LGL * lgl, int a, int b) {
+  assert (lgl->probing);
+  assert (lglmtstk (&lgl->clause));
+  assert (abs (a) != abs (b));
+  assert (!lglval (lgl, a));
+  assert (!lglval (lgl, b));
+  lglpushstk (lgl, &lgl->clause, a);
+  lglpushstk (lgl, &lgl->clause, b);
+  lglpushstk (lgl, &lgl->clause, 0);
+  if (!lglsimpleprobeclausexists (lgl)) {
+    LOG (2, "added simple probing connecting binary clause", a, b);
+    lgldrupligaddcls (lgl, REDCS);
+    lgladdcls (lgl, 0, 0, 1);
+  }
+  lglclnstk (&lgl->clause);
+}
+
+static int lglcmpilit (int * a, int * b) {
+  int res, l = *a, k = *b;
+  if ((res = abs (l) - abs (k))) return res;
+  return l - k;
+}
+
+static int lglcmpcls (LGL * lgl, const int * c, const int * d) {
+  const int * p, * q;
+  if (*c >= REMOVED && *d >= REMOVED) return c - d;
+  if (*c >= REMOVED) return 1;
+  if (*d >= REMOVED) return -1;
+  for (p = c, q = d; *p && *q == *p; p++, q++)
+    ;
+  return *p - *q;
+}
+
+static int lglcmpsz (LGL * lgl, const int * start, PSz * p, PSz * q) {
+  const int * c, * d;
+  int res;
+  if ((res = p->size - q->size)) return res;
+  c = start + p->pos, d = start + q->pos;
+  if ((res = lglcmpcls (lgl, c, d))) return res;
+  if ((res = c[-1] - d[-1])) return res;
+  return p->pos - q->pos;
+}
+
+#define LGLCMPSZ(A,B) (lglcmpsz(lgl, start, (A), (B)))
+
+static void lglrmdupclsonstack (LGL * lgl, Stk * stk, Stk * sort) {
+  int * start, * c, * p, * d, pos, size, i;
+  PSz * ps;
+  lglclnstk (sort);
+  start = stk->start;
+  for (c = start; c < stk->top; c = p + 1) {
+    c++;
+    assert (c < stk->top);
+    pos = c - start;
+    size = 0;
+    for (p = c; *p; p++) size++;
+    SORT (int, c, size, lglcmpilit);
+    lglpushstk (lgl, sort, pos);
+    lglpushstk (lgl, sort, size);
+  }
+  size = lglcntstk (sort)/2;
+  if (size <= 1) return;
+  ps = (PSz *) sort->start;
+  SORT (PSz, ps, size, LGLCMPSZ);
+  for (i = 1; i < size; i++) {
+    if (ps[i-1].size != ps[i].size) continue;
+    c = stk->start + ps[i-1].pos;
+    d = stk->start + ps[i].pos;
+    if (lglcmpcls (lgl, c, d)) continue;
+    LOGCLS (4, d, "not copying duplicate %s clause", lglred2str (d[-1]));
+    while (*d) *d++ = REMOVED;
+    *d = REMOVED;
+  }
+}
+
+static void lglsimpleprobemerge (LGL * lgl, int repr, int nonrepr) {
+  const int druplig = lgl->opts->druplig.val;
+  Val valrepr, valnonrepr;
+  Stk stk, sort;
+  int unit;
+  lglchkirrstats (lgl);
+  lgl->stats->prb.simple.eqs++;
+  assert (abs (repr) < abs (nonrepr));
+  lglavar (lgl, nonrepr)->equiv = 1;
+  CLR (stk); CLR (sort);
+  if (druplig) {
+    lgldrupligaddclsarg (lgl, REDCS, repr, -nonrepr, 0),
+    lgldrupligaddclsarg (lgl, REDCS, -repr, nonrepr, 0);
+  }
+  lglsimpleprobeclscp (lgl, nonrepr, repr, &stk);
+  lglsimpleprobeclscp (lgl, -nonrepr, -repr, &stk);
+  lglrmdupclsonstack (lgl, &stk, &sort);
+  lglsimpleprobeaddclausesonstack (lgl, &stk);
+  lglrelstk (lgl, &sort);
+  lglrelstk (lgl, &stk);
+  lglflushclauses (lgl, nonrepr);
+  lglflushclauses (lgl, -nonrepr);
+  if (lgl->mt) goto FIXDRUPLIG;
+  valrepr = lglval (lgl, repr);
+  valnonrepr = lglval (lgl, nonrepr);
+  if (valrepr && valnonrepr == valrepr) goto FIXDRUPLIG;
+  if (valrepr && valrepr == -valrepr) {
+    LOG (1, "equality between %d and %d became inconsistent", repr, nonrepr);
+    lglmt (lgl);
+    goto FIXDRUPLIG;
+  }
+  if (valrepr && !valnonrepr) unit = valrepr < 0 ? -nonrepr : nonrepr;
+  else if (!valrepr && valnonrepr) unit = valnonrepr < 0 ? -repr : repr;
+  else unit = 0, assert (!valrepr), assert (!valnonrepr);
+  if (unit) {
+    LOG (1, "new unit %d from equality between %d and %d", unit, repr, nonrepr);
+    lglunit (lgl, unit);
+    (void) lglflush (lgl);
+  } else lglsimpleprobeaddprbincls (lgl, repr, -nonrepr),
+	 lglsimpleprobeaddprbincls (lgl, -repr, nonrepr);
+  lglchkirrstats (lgl);
+FIXDRUPLIG:
+  if (druplig) {
+    lgldrupligdelclsarg (lgl, repr, -nonrepr, 0),
+    lgldrupligdelclsarg (lgl, -repr, nonrepr, 0);
+  }
+}
+
+static int lglsimpleprobeqs (LGL * lgl) {
+  int a, b, res;
+  res = 0;
+  while (!lgl->mt && !lglmtstk (&lgl->sprb->eqs)) {
+    a = lglpopstk (&lgl->sprb->eqs);
+    b = lglpopstk (&lgl->sprb->eqs);
+    if (lglval (lgl, a)) continue;
+    assert (!lglval (lgl, b));
+    assert (abs (a) != abs (b));
+    if (lglsimpleprobemerged (lgl, a, b)) continue;
+    if (abs (b) < abs (a)) SWAP (int, a, b);
+    lglsimpleprobemerge (lgl, a, b);
+    res++;
+  }
+  return res;
+}
+
+static SPE * lglspe (LGL * lgl, int lit) {
+  assert (2 <= abs (lit) && abs (lit) < lgl->nvars);
+  return lgl->sprb->spes + lit;
+}
+
+static void lglsimpleprobehbr (LGL * lgl, int touched, const int * c) {
+  int blit, tag, lit, other, count, val, maxcount, rem, first, second;
+  const int * p, * q, * w, * eow;
+  unsigned sum, tmp;
+  SPE * spe;
+  HTS * hts;
+  first = second = count = sum = 0;
+  for (p = c; (lit = *p); p++) {
+    if (lglwrktouched (lgl, lit)) return;
+    if ((val = lglval (lgl, lit)) > 0) return;
+    if (val < 0) continue;
+    if (!first) first = lit;
+    else if (!second) second = lit;
+    sum += (unsigned) lit;
+    count++;
+  }
+  if (count == 2) {
+    assert (first && second);
+    if (lglhasbin (lgl, -first, -second)) {
+      LOG (2, "found equivalent literals %d and %d", -first, second);
+      lglpushstk (lgl, &lgl->sprb->eqs, -first);
+      lglpushstk (lgl, &lgl->sprb->eqs, second);
+      goto DONE;
+    }
+  }
+  rem = count;
+  maxcount = 0;
+  assert (lglmtstk (&lgl->sprb->counted));
+  for (p = c; (lit = *p); p++) {
+    if (INCSTEPS (prb.simple.steps) >= lgl->limits->prb.steps) goto DONE;
+    val = lglval (lgl, lit);
+    assert (val <= 0);
+    if (val) continue;
+    hts = lglhts (lgl, -lit);
+    w = lglhts2wchs (lgl, hts);
+    eow = w + hts->count;
+    assert (lglmtstk (&lgl->sprb->marked));
+    for (q = w; q < eow; q++) {
+      if (INCSTEPS (prb.simple.steps) >= lgl->limits->prb.steps) goto DONE;
+      blit = *q;
+      tag = blit & MASKCS;
+      if (tag == TRNCS || tag == LRGCS) q++;
+      if (tag != BINCS) continue;
+      other = blit >> RMSHFT;
+      val = lglval (lgl, other);
+      assert (val >= 0);
+      if (val) continue;
+      if ((spe = lglspe (lgl, other))->mark) continue;
+      if (lglspe (lgl, -other)->mark) {
+	LOG (2, "unit %d through very simple hyper binary resolution", -lit);
+	lglpushstk (lgl, &lgl->sprb->units, -lit);
+	goto DONE;
+      }
+      if (!spe->count) lglpushstk (lgl, &lgl->sprb->counted, other);
+      spe->sum += (unsigned) lit;
+      spe->count++;
+      spe->mark = 1;
+      lglpushstk (lgl, &lgl->sprb->marked, other);
+      if (spe->count > maxcount) maxcount = spe->count;
+    }
+    while (!lglmtstk (&lgl->sprb->marked)) {
+      other = lglpopstk (&lgl->sprb->marked);
+      spe = lglspe (lgl, other);
+      assert (spe->mark);
+      spe->mark = 0;
+    }
+    rem--;
+    assert (maxcount + rem <= count);
+    if (maxcount + rem + 1 < count) goto DONE;
+  }
+  if (count <= 2) goto DONE;
+  for (q = lgl->sprb->counted.start; q < lgl->sprb->counted.top; q++) {
+    other = *q;
+    assert (!lglval (lgl, other));
+    spe = lglspe (lgl, other);
+    assert (spe->count <= count);
+    if (spe->count == count) {
+      LOG (2, "unit %d through simple hyper binary resolution", other);
+      lglpushstk (lgl, &lgl->sprb->units, other);
+    } else if (spe->count + 1 == count) {
+      tmp = sum - spe->sum;
+      lit = (int) tmp;
+      assert (2 <= abs (lit) && abs (lit) < lgl->nvars);
+      if (abs (lit) != abs (other) && !lglhasbin (lgl, other, lit)) {
+	LOG (2, "simple hyper binary resolvent %d %d", other, lit);
+	lglpushstk (lgl, &lgl->sprb->impls, other);
+	lglpushstk (lgl, &lgl->sprb->impls, lit);
+      }
+    }
+  }
+  for (p = c; (lit = *p); p++) {
+    if (lglval (lgl, lit)) continue;
+    spe = lglspe (lgl, lit);
+    if (spe->count + 2 != count) continue;
+    tmp = sum - spe->sum;
+    tmp -= (unsigned) lit;
+    other = (int) tmp;
+    assert (2 <= abs (other) && abs (other) < lgl->nvars);
+    if (abs (lit) != abs (other) && !lglhasbin (lgl, other, lit)) {
+      LOG (2, "self-subsuming hyper binary resolvent %d %d", other, lit);
+      lglpushstk (lgl, &lgl->sprb->impls, other);
+      lglpushstk (lgl, &lgl->sprb->impls, lit);
+    }
+  }
+DONE:
+  while (!lglmtstk (&lgl->sprb->counted)) {
+    lit = lglpopstk (&lgl->sprb->counted);
+    spe = lglspe (lgl, lit);
+    CLRPTR (spe);
+  }
+  lglclnstk (&lgl->sprb->marked);
+}
+
+static void lglpushnmarkseen (LGL * lgl, int lit) {
+  lglpushstk (lgl, &lgl->seen, lit);
+  lglmarkunmarked (lgl, lit);
+}
+
+static void lglsignedmarknpushseen (LGL * lgl, int lit) {
+  lglsignedmark (lgl, lit);
+  lglpushstk (lgl, &lgl->seen, lit);
+}
+
+static void lglsimpleliftmark (LGL * lgl, int root, int level) {
+  const int * p, * w, * eow;
+  int blit, tag, other;
+  HTS * hts;
+  INCSTEPS (prb.simple.steps);
+  assert (level > 0);
+  assert (lglsignedmarked (lgl, -root));
+  LOG (3, "next simple lifting marking from %d at level %d", root, level);
+  hts = lglhts (lgl, root);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag != BINCS) continue;
+    other = blit >> RMSHFT;
+    if (lglsignedmarked (lgl, other)) continue;
+    lglsignedmarknpushseen (lgl, other);
+    LOG (4, "next simple lifting marking from %d at level %d marked %d", 
+         root, level, other);
+    if (level > 1) lglsimpleliftmark (lgl, -other, level-1);
+  }
+}
+
+static void lglsimpleliftcollect (LGL * lgl, int root, int start, int level) {
+  const int * p, * w, * eow;
+  int blit, tag, other;
+  HTS * hts;
+  INCSTEPS (prb.simple.steps);
+  assert (level > 0);
+  LOG (3, "next simple lifting collecting from %d at level %d", start, level);
+  hts = lglhts (lgl, start);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag != BINCS) continue;
+    other = blit >> RMSHFT;
+    if (other == -root) continue;
+    if (lglsignedmarked (lgl, other)) {
+      LOG (2, "simple lifted unit %d with root %d", other, root);
+      lglpushstk (lgl, &lgl->sprb->units, other);
+    } else if (other != root && lglsignedmarked (lgl, -other)) {
+      LOG (2, "found equivalent literals %d and %d", root, other);
+      lglpushstk (lgl, &lgl->sprb->eqs, root);
+      lglpushstk (lgl, &lgl->sprb->eqs, other);
+    } 
+    if (level > 1) lglsimpleliftcollect (lgl, root, -other, level-1);
+  }
+}
+
+static void lglsimplelift (LGL * lgl, int root) {
+  int count, pos, neg;
+  pos = lglhts (lgl, root)->count;
+  neg = lglhts (lgl, -root)->count;
+  if (neg < pos) root = -root;
+  LOG (2, "next simple lifting %d", root);
+  assert (lglmtstk (&lgl->seen));
+  assert (!lglsignedmarked (lgl, -root));
+  lglsignedmarknpushseen (lgl, -root);
+  lglsimpleliftmark (lgl, root, lgl->opts->prbsimpleliftdepth.val);
+  count = lglcntstk (&lgl->seen);
+  LOG (3, "simple probing lifting marked %d literals for root %d", 
+       count, root);
+  if (!count) return;
+  lglsimpleliftcollect (lgl, root, -root, lgl->opts->prbsimpleliftdepth.val);
+#ifndef NLGLOG
+  {
+    int units = lglcntstk (&lgl->sprb->units);
+    int eqs = lglcntstk (&lgl->sprb->eqs);
+    assert (!(eqs & 1));
+    eqs >>= 1;
+    LOG (3, "found %d units through simple lifting for %d", units, root);
+    LOG (3, "found %d equivalences through simple lifting for %d", eqs, root);
+  }
+#endif
+  lglpopnunmarkstk (lgl, &lgl->seen);
+}
+
+static void lglsimpleprobelit (LGL * lgl, int lit) {
+  int blit, tag, other, other2, red, lidx, cls[4];
+  const int * p, * w, * eow, * c;
+  HTS * hts;
+  lgl->stats->prb.simple.probed++;
+  assert (!lglval (lgl, lit));
+  lglclnstk (&lgl->sprb->units);
+  lglclnstk (&lgl->sprb->impls);
+  if (!lglwrktouched (lgl, -lit)) lglsimplelift (lgl, lit);
+  LOG (2, "next simple probing %d", lit);
+  hts = lglhts (lgl, lit);
+  if (!hts->count) return;
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    if (INCSTEPS (prb.simple.steps) >= lgl->limits->prb.steps) goto DONE;
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == BINCS || tag == LRGCS) continue;
+    if (tag == TRNCS) {
+      other = blit >> RMSHFT;
+      if (lglval (lgl, other)) continue;
+      other2 = *p;
+      if (lglval (lgl, other2)) continue;
+      cls[0] = lit, cls[1] = other, cls[2] = other2, cls[3] = 0;
+      lglsimpleprobehbr (lgl, lit, cls);
+    } else {
+      assert (tag == OCCS);
+      red = (blit & REDCS);
+      lidx = (blit >> RMSHFT);
+      c = lglidx2lits (lgl, red, lidx);
+      lglsimpleprobehbr (lgl, lit, c);
+    }
+  }
+DONE:
+  assert (lglmtstk (&lgl->seen));
+  lglpopnunmarkstk (lgl, &lgl->seen);
+}
+
+static void lglprtsimpleproberem (LGL * lgl) {
+  int idx, ret = 0, rem = 0, sum;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    if (lglavar (lgl, idx)->donotsimpleprobe) ret++; else rem++;
+  }
+  if (rem) {
+    sum = rem + ret;
+    lglprt (lgl, 1,
+      "[simpleprobe-%d] %d variables remain %.0f%% (%d retained %.0f%%)",
+      lgl->stats->prb.simple.count,
+      rem, lglpcnt (rem, sum),
+      ret, lglpcnt (ret, sum));
+  } else {
+    lglprt (lgl, 1,
+      "[simpleprobe-%d] fully completed simple probing",
+      lgl->stats->prb.simple.count);
+    for (idx = 2; idx < lgl->nvars; idx++)
+      lglavar (lgl, idx)->donotsimpleprobe = 0;
+  }
+}
+
+static int64_t lglirrlits (LGL * lgl) { return lgl->stats->irr.lits.cur; }
+
+static int64_t lglredlits (LGL * lgl) {
+  int64_t res = 2*lgl->stats->red.bin + 3*lgl->stats->red.trn;
+  int glue;
+  for (glue = 0; glue <= MAXGLUE; glue++) {
+    res += lglcntstk (lgl->red + glue);
+    res -= 2*lgl->stats->lir[glue].clauses;
+  }
+  return res;
+}
+
+static int lglszpenaux (LGL * lgl, int litstoo, int redtoo) {
+  int64_t size64;
+  int res;
+  size64 = lgl->stats->irr.clauses.cur;
+  if (litstoo) size64 += lglirrlits (lgl)/4;
+  if (redtoo) {
+    size64 += lgl->stats->irr.clauses.cur;
+    if (litstoo) size64 += lglredlits (lgl)/4;
+  }
+  assert (size64 >= 0);
+  size64 /= lgl->opts->sizepen.val;
+  if (size64 >= INT_MAX) res = 32;
+  else res = lglceild ((int) size64);
+  if (res < 0) res = 0;
+  if (res > lgl->opts->sizemaxpen.val) res = lgl->opts->sizemaxpen.val;
+  return res;
+}
+
+static int lglszpen (LGL * lgl) { return lglszpenaux (lgl, 0, 0); }
+
+#ifndef NLGLYALSAT
+
+static int lglitszpen (LGL * lgl) {
+  int res = lglceild (lgl->stats->irr.lits.cur/lgl->opts->sizepen.val);
+  if (res < 0) res = 0;
+  if (res > lgl->opts->sizemaxpen.val + 2)
+    res = lgl->opts->sizemaxpen.val + 2;
+  return res;
+}
+
+#endif
+
+static int64_t lglvisearch (LGL * lgl) {
+  int64_t res = lgl->stats->visits.search;
+  assert (res >= lgl->limits->inc.visits);
+  res -= lgl->limits->inc.visits;
+  return res;
+}
+
+static void lglsetprbsimplelim (LGL * lgl) {
+  int64_t limit, irrlim;
+  int pen, szpen;
+  if (lgl->opts->prbsimplertc.val || lgl->opts->prbrtc.val) {
+    lgl->limits->prb.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[simpleprobe-%d] really no limit (run to completion)", 
+      lgl->stats->prb.simple.count);
+  } else {
+    limit = (lgl->opts->prbsimplereleff.val*lglvisearch (lgl))/1000;
+    if (limit < lgl->opts->prbsimplemineff.val) 
+      limit = lgl->opts->prbsimplemineff.val;
+    if (lgl->opts->prbsimplemaxeff.val >= 0 &&
+        limit > lgl->opts->prbsimplemaxeff.val)
+      limit = lgl->opts->prbsimplemaxeff.val;
+    if (lgl->stats->prb.simple.count <= 1 &&
+        lgl->opts->boost.val &&
+        lgl->opts->prbsimpleboost.val > 1) {
+      lglprt (lgl, 1,
+	"[simpleprobe-%d] boosting simple probing limit by %d",
+	lgl->stats->prb.simple.count, lgl->opts->prbsimpleboost.val);
+      limit *= lgl->opts->prbsimpleboost.val;
+    }
+    limit >>= (pen = lgl->limits->prb.simple.pen + (szpen = lglszpen (lgl)));
+    irrlim = (2*lgl->stats->irr.clauses.cur) >> szpen;
+    if (lgl->opts->irrlim.val && limit < irrlim) {
+      limit = irrlim;
+      lglprt (lgl, 1,
+  "[simpleprobe-%d] limit %lld based on %d irredundant clauses penalty %d",
+	lgl->stats->prb.simple.count,
+	(LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+    } else
+      lglprt (lgl, 1,
+	"[simpleprobe-%d] limit %lld penalty %d = %d + %d",
+	lgl->stats->prb.simple.count, (LGLL) limit,
+	pen, lgl->limits->prb.simple.pen, szpen);
+    lgl->limits->prb.steps = lgl->stats->prb.simple.steps + limit;
+  }
+}
+
+static int lgldelaying (LGL * lgl, const char * name, int * delptr) {
+  if (!*delptr) return 0;
+  *delptr -= 1;
+  lglprt (lgl, 2,
+    "[%s-delayed] skipping this scheduled invocation and %d more",
+    name, *delptr);
+  return 1;
+}
+
+static int lglsimpleprobe (LGL * lgl) {
+  int deltarem, nunits, hbrs, neqs, oldrem = lglrem (lgl);
+  int lit, success, nvars;
+
+  if (lgldelaying (lgl, "simpleprobe",
+        &lgl->limits->prb.simple.del.rem)) return 1;
+
+  lglstart (lgl, &lgl->times->prb.simple);
+  lgl->stats->prb.simple.count++;
+
+  assert (!lgl->simp && !lgl->probing && !lgl->simpleprobing);
+  lgl->simp = lgl->probing = lgl->simpleprobing = 1;
+
+
+  NEW (lgl->sprb, 1);
+
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  lglgc (lgl);
+  assert (lgl->frozen);
+  lgldense (lgl, 0);
+  lglsimpleprobeinit (lgl);
+  lglsetprbsimplelim (lgl);
+  neqs = hbrs = nunits = 0;
+
+  nvars = lgl->nvars;
+  NEW (lgl->sprb->spes, 2*nvars);
+  lgl->sprb->spes += nvars;
+
+  while (!lgl->mt && (lit = lglwrknext (lgl))) {
+    if (INCSTEPS (prb.simple.steps) >= lgl->limits->prb.steps) break;
+    if (!lglisfree (lgl, lit)) continue;
+    if (lglavar (lgl, lit)->equiv) continue;
+    lglsimpleprobelit (lgl, lit);
+    if (lgl->mt) break;
+    lglchkirrstats (lgl);
+    nunits += lglsimpleprobeunits (lgl);
+    if (lgl->mt) break;
+    hbrs += lglsimpleprobeimpls (lgl);
+    if (lgl->mt) break;
+    neqs += lglsimpleprobeqs (lgl);
+    if (!lglflush (lgl)) break;
+    if (lglterminate (lgl)) break;
+    if (!lglsyncunits (lgl)) break;
+  }
+
+  lglsimpleprobereset (lgl, nvars);
+  lglsparse (lgl);
+  if (!lgl->mt) lgldecomp (lgl);
+
+  DEL (lgl->sprb, 1);
+
+  deltarem = oldrem - lglrem (lgl);
+  success = deltarem || hbrs || nunits;
+  LGLUPDPEN (prb.simple, deltarem);
+  lglprtsimpleproberem (lgl);
+
+  lglprt (lgl, 1 + !success,
+    "[simpleprobe-%d] removed %d variables, found %d hbrs, %d units",
+    lgl->stats->prb.simple.count, deltarem, hbrs, nunits);
+
+  assert (lgl->simp && lgl->probing && lgl->simpleprobing);
+  lgl->simp = lgl->probing = lgl->simpleprobing = 0;
+  lglrep (lgl, 2, 'p');
+  lglstop (lgl);
+  return !lgl->mt;
+}
+
+static int lglmvbcls (LGL * lgl, int a, int b) {
+  int res = 0;
+  assert (abs (a) != abs (b));
+  assert (!lglval (lgl, a));
+  assert (!lglval (lgl, b));
+  assert (lglmtstk (&lgl->clause)); 
+  lglpushstk (lgl, &lgl->clause, a);
+  lglpushstk (lgl, &lgl->clause, b);
+  lglpushstk (lgl, &lgl->clause, 0);
+  if (!lglsimpleprobeclausexists (lgl)) {
+    LOG (2, "moving redundant binary clause %d %d", a, b);
+    lgldrupligaddcls (lgl, REDCS);
+    lgladdcls (lgl, REDCS, 0, 1);
+    res = 1;
+  }
+  lglclnstk (&lgl->clause);
+  lgl->stats->moved.bin++;
+  return res;
+}
+
+static int lglrmvbcls (LGL * lgl, int a, int b) {
+  lglrmbcls (lgl, a, b, 0);
+  if (lgl->opts->move.val) return lglmvbcls (lgl, a, b);
+  return 0;
+}
+
+static int lglmvtcls (LGL * lgl, int a, int b, int c) {
+  int res = 0;
+  assert (abs (a) != abs (b));
+  assert (abs (a) != abs (c));
+  assert (abs (b) != abs (c));
+  assert (lglmtstk (&lgl->clause)); 
+  lglpushstk (lgl, &lgl->clause, a);
+  lglpushstk (lgl, &lgl->clause, b);
+  lglpushstk (lgl, &lgl->clause, c);
+  lglpushstk (lgl, &lgl->clause, 0);
+  if (!lglsimpleprobeclausexists (lgl)) {
+    LOG (2, "moving redundant ternary clause %d %d %d", a, b, c);
+    lgldrupligaddcls (lgl, REDCS);
+    lgladdcls (lgl, REDCS, 0, 1);
+    res = 1;
+  }
+  lglclnstk (&lgl->clause);
+  lgl->stats->moved.trn++;
+  return res;
+}
+
+static int lglrmvtcls (LGL * lgl, int a, int b, int c) {
+  assert (abs (a) != abs (b));
+  assert (abs (a) != abs (c));
+  assert (abs (b) != abs (c));
+  lglrmtcls (lgl, a, b, c, 0);
+  if (lgl->opts->move.val >= 2) return lglmvtcls (lgl, a, b, c);
+  return 0;
+}
+
+static int lglwaiting (LGL * lgl, const char * str, int wait) {
+  if (!wait) return 0;
+  if (!lgl->wait) return 0;
+  if (wait >= 2 && lgl->opts->elim.val && !lgl->elmrtc) {
+    if (str)
+      lglprt (lgl, 2,
+	"[%s-waiting] on variable elimination to be completed", str);
+    return 1;
+  }
+  if (wait >= 1 && lgl->opts->block.val && !lgl->blkrtc) {
+    if (str)
+      lglprt (lgl, 2, 
+	"[%s-waiting] on blocked clause elimination to be completed", str);
+    return 1;
+  }
+  return 0;
+}
+
+static void lglbasicate (LGL * lgl, int lit) {
+  const int druplig = lgl->opts->druplig.val;
+  int blit, tag, red, other, other2, lidx;
+  const int * w, * eow, * p, * c, * l;
+  int nonfalse, numtrue, val;
+  HTS * hts;
+  if (!lgl->opts->bate.val) return;
+  if (lglwaiting (lgl, 0, lgl->opts->batewait.val)) return;
+RESTART:
+  hts = lglhts (lgl, -lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = * p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    red = blit & REDCS;
+    if (red) continue;
+    if (tag == BINCS) continue;
+    if (tag == TRNCS) {
+      other = blit >> RMSHFT;
+      numtrue = 0;
+      if ((val = lglval (lgl, other)) < 0) continue;
+      if (val > 0) {
+	if (!lglevel (lgl, other)) continue;
+	if (lgltd (lgl, other)->irr) numtrue++;
+      }
+      other2 = *p;
+      if ((val = lglval (lgl, other2)) < 0) continue;
+      if (val > 0) {
+	if (!lglevel (lgl, other2)) continue;
+	if (lgltd (lgl, other2)->irr) numtrue++;
+      }
+      if (!numtrue) continue;
+      LOG (2, "basic ATE ternary clause %d %d %d", -lit, other, other2);
+      lgl->stats->prb.basic.ate.trnr++;
+      if (!lglrmvtcls (lgl, -lit, other, other2))
+	lgldrupligdelclsarg (lgl, -lit, other, other2, 0);
+      goto RESTART;
+    } else {
+      assert (tag == OCCS || tag == LRGCS);
+      if (tag == LRGCS && lgl->dense) continue;
+      lidx = (tag == LRGCS) ? *p : (blit >> RMSHFT);
+      assert (!red);
+      c = lglidx2lits (lgl, 0, lidx);
+      numtrue = nonfalse = 0;
+      for (l = c; (nonfalse < 2 || !numtrue) && (other = *l); l++) {
+	if (other == -lit) continue;
+	assert (other != lit);
+	if ((val = lglval (lgl, other)) >= 0) nonfalse++;
+	if (val > 0) {
+	   if (!lglevel (lgl, other)) { numtrue = -1; break; }
+	   if (lgltd (lgl, other)->irr) numtrue++;
+	}
+      }
+      if (numtrue > 0 && nonfalse >= 2) {
+	LOGCLS (2, c, "basic ATE large clause");
+	lgl->stats->prb.basic.ate.lrg++;
+	if (druplig) lgldrupligdelclsaux (lgl, c);
+	lglrmlcls (lgl, lidx, 0);
+	goto RESTART;
+      }
+    }
+  }
+}
+
+static void lglbasicatestats (LGL * lgl) {
+  int n = lgl->stats->prb.basic.ate.lrg + lgl->stats->prb.basic.ate.trnr;
+  int d = n - lgl->stats->prb.basic.lastate;
+  assert (d >= 0);
+  if (d <= 0) return;
+  lgl->stats->prb.basic.ate.count++;
+  lglprt (lgl, 1,
+    "[bate-%d] eliminated %d asymmetric tautologies during probing",
+    lgl->stats->prb.basic.ate.count, d);
+  lgl->stats->prb.basic.lastate = n;
+}
+
+static void lglbasicprobelit (LGL * lgl, int root) {
+  int old, ok, dom, lit, val;
+  Stk lift, saved;
+  const int * p;
+  CLR (lift); CLR (saved);
+  assert (lgl->simp);
+  assert (lgl->probing || lgl->cceing);
+  assert (!lgl->level);
+  LOG (2, "next probe %d positive phase", root);
+  assert (!lgl->level);
+  if (lgl->treelooking) lgl->stats->prb.treelook.probed++;
+  else if (lgl->cceing) lgl->stats->cce.probed++;
+  else assert (lgl->basicprobing), lgl->stats->prb.basic.probed++;
+  if (lglrand (lgl) & (1<<12)) root = -root;
+  lgliassume (lgl, root);
+  old = lgl->next;
+  ok = lglbcp (lgl);
+  dom = 0;
+  if (ok) {
+    lglclnstk (&saved);
+    lglbasicate (lgl, root);
+    for (p = lgl->trail.start + old; p < lgl->trail.top; p++) {
+      lit = *p;
+      if (lit == root) continue;
+      lglpushstk (lgl, &saved, lit);
+    }
+  } else dom = lglprbana (lgl, root);
+  lglbacktrack (lgl, 0);
+  if (!ok) {
+    LOG (1, "failed literal %d on probing", dom, root);
+    lglpushstk (lgl, &lift, -dom);
+    goto MERGE;
+  }
+  LOG (2, "next probe %d negative phase", -root);
+  assert (!lgl->level);
+  if (lgl->treelooking) lgl->stats->prb.treelook.probed++;
+  else if (lgl->cceing) lgl->stats->cce.probed++;
+  else assert (lgl->basicprobing), lgl->stats->prb.basic.probed++;
+  lgliassume (lgl, -root);
+  ok = lglbcp (lgl);
+  if (ok) {
+    lglbasicate (lgl, -root);
+    for (p = saved.start; p < saved.top; p++) {
+      lit = *p;
+      val = lglval (lgl, lit);
+      if (val <= 0) continue;
+      if (lgl->treelooking) lgl->stats->prb.treelook.lifted++;
+      else if (lgl->cceing) lgl->stats->cce.lifted++;
+      else assert (lgl->basicprobing), lgl->stats->prb.basic.lifted++;
+      lglpushstk (lgl, &lift, lit);
+      LOG (2, "lifted %d", lit);
+    }
+  } else dom = lglprbana (lgl, -root);
+  lglbacktrack (lgl, 0);
+  if (!ok) {
+    LOG (1, "failed literal %d on probing %d", dom, -root);
+    lglpushstk (lgl, &lift, -dom);
+  }
+MERGE:
+  while (!lglmtstk (&lift)) {
+    lit = lglpopstk (&lift);
+    val = lglval (lgl, lit);
+    if (val > 0) continue;
+    if (val < 0) goto EMPTY;
+    if (lgl->opts->druplig.val) {
+      lgldrupligaddclsarg (lgl, REDCS, -root, lit, 0);
+      lgldrupligaddclsarg (lgl, REDCS, root, lit, 0);
+    }
+    lglunit (lgl, lit);
+    if (lgl->opts->druplig.val) {
+      lgldrupligdelclsarg (lgl, -root, lit, 0);
+      lgldrupligdelclsarg (lgl, root, lit, 0);
+    }
+    if (lgl->treelooking) lgl->stats->prb.treelook.failed++;
+    else if (lgl->cceing) lgl->stats->cce.failed++;
+    else assert (lgl->basicprobing), lgl->stats->prb.basic.failed++;
+    if (lglbcp (lgl)) continue;
+EMPTY:
+    LOG (1, "empty clause after propagating lifted and failed literals");
+    lglmt (lgl);
+  }
+  lglrelstk (lgl, &lift);
+  lglrelstk (lgl, &saved);
+}
+
+static TVar * lgltvar (LGL * lgl, int lit) {
+  int idx = abs (lit);
+  assert (2 <= idx && idx < lgl->nvars);
+  assert (lgl->tlk);
+  return lgl->tlk->tvars + idx;
+}
+
+static void lglsignedtlmark (LGL * lgl, int lit) {
+  TVar * tv = lgltvar (lgl, lit);
+  unsigned bit = 1u << (lit < 0);
+  if (tv->mark & bit) return;
+  tv->mark |= bit;
+}
+
+static int lglsignedtlmarked (LGL * lgl, int lit) {
+  TVar * tv = lgltvar (lgl, lit);
+  unsigned bit = 1u << (lit < 0);
+  return tv->mark & bit;
+}
+
+static void lgltlenq (LGL * lgl, int start) {
+  int lit, blit, tag, other, oldcount, newcount, * stk;
+  unsigned delta, i, j, mod;
+  const int * p, * w, * eos;
+  HTS * hts;
+  assert (!lglsignedtlmarked (lgl, start));
+  lglsignedtlmark (lgl, start);
+  lglpushstk (lgl, &lgl->tlk->stk, start);
+  while (!lglmtstk (&lgl->tlk->stk)) {
+    lit = lglpopstk (&lgl->tlk->stk);
+    LOG (2, "tree-look enqueue %d%s", lit, lit == start ? " start":"");
+    if (lit) {
+      assert (!lglval (lgl, lit));
+      assert (lglsignedtlmarked (lgl, lit));
+      lglpushstk (lgl, &lgl->tlk->seen, lit);
+      lglpushstk (lgl, &lgl->tlk->stk, 0);
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eos = w + hts->count;
+      oldcount = lglcntstk (&lgl->tlk->stk);
+      for (p = w; p < eos; p++) {
+        INCSTEPS (prb.treelook.steps);
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == OCCS) continue;
+	if (tag == TRNCS || tag == LRGCS) { p++; continue; }
+	assert (tag == BINCS);
+	other = -(blit >> RMSHFT);
+	if (lglval (lgl, other)) assert (lglval (lgl, other) < 0);
+	else if (!lglsignedtlmarked (lgl, other)) {
+	  lglsignedtlmark (lgl, other);
+	  lglpushstk (lgl, &lgl->tlk->stk, other);
+	}
+      }
+      newcount = lglcntstk (&lgl->tlk->stk);
+      delta = newcount - oldcount;
+      assert (delta >= 0);
+      if ((mod = delta) <= 1) continue;
+      stk = lgl->tlk->stk.start;
+      for (i = 0; i < delta-1; i++, mod--) {
+	assert (mod > 0);
+	j = i + (lglrand (lgl) % mod);
+	assert (i <= j && j < delta);
+	if (i == j) continue;
+	SWAP (int, stk[i + oldcount], stk[j + oldcount]);
+      }
+    } else lglpushstk (lgl, &lgl->tlk->seen, 0);
+  }
+}
+
+static int lglisroot (LGL * lgl, int lit) { return !lglhasbins (lgl, lit); }
+
+static void lgltlunmarkall (LGL * lgl) {
+  int idx;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    lgl->tlk->tvars[idx].mark = 0;
+}
+
+static int lgltlschedlit (LGL * lgl, int lit) {
+  if (INCSTEPS (prb.treelook.steps) > lgl->limits->prb.steps) return 0;
+  if (!lglisfree (lgl, lit)) return 1;
+  if (lglsignedtlmarked (lgl, lit)) return 1;
+  if (!lglisroot (lgl, -lit)) return 1;
+  if (!lgl->tlk->lkhd && lglavar (lgl, lit)->donotreelook) return 1;
+  if (lgl->opts->treelook.val >= 2) {
+    lglbasicprobelit (lgl, -lit);
+    if (lgl->mt) return 0;
+    if (lglterminate (lgl)) return 0;
+    if (!lglisfree (lgl, lit)) return 1;
+    if (!lglisroot (lgl, -lit)) return 1;
+    if (!lglhasbins (lgl, lit)) return 1;
+  }
+  lgltlenq (lgl, lit);
+  return 1;
+}
+
+static int lgltlschedanylit (LGL * lgl, int lit) {
+  if (INCSTEPS (prb.treelook.steps) > lgl->limits->prb.steps) return 0;
+  if (!lglisfree (lgl, lit)) return 1;
+  if (lglsignedtlmarked (lgl, lit)) return 1;
+  if (!lgl->tlk->lkhd && lglavar (lgl, lit)->donotreelook) return 1;
+  if (lgl->opts->treelook.val >= 2) {
+    lglbasicprobelit (lgl, -lit);
+    if (lgl->mt) return 0;
+    if (lglterminate (lgl)) return 0;
+    if (!lglisfree (lgl, lit)) return 1;
+  }
+  lgltlenq (lgl, lit);
+  return 1;
+}
+
+static void lgltlsched (LGL * lgl) {
+  int idx, round, count, * p;
+  LOG (1, "scheduling tree-look literals");
+  for (round = 0; !lgl->mt && round < 2; round++) {
+    assert (lglmtstk (&lgl->tlk->seen));
+    assert (lglmtstk (&lgl->tlk->stk));
+    if (lglrandlitrav (lgl, lgltlschedlit))
+      lglrandlitrav (lgl, lgltlschedanylit);
+    lgltlunmarkall (lgl);
+    lglrelstk (lgl, &lgl->tlk->stk);
+    if (!lglmtstk (&lgl->tlk->seen)) break;
+    for (idx = 2; idx < lgl->nvars; idx++)
+      lglavar (lgl, idx)->donotreelook = 0;
+  }
+  lglfitstk (lgl, &lgl->tlk->seen);
+  count = 0;
+  for (p = lgl->tlk->seen.start; p < lgl->tlk->seen.top; p++)
+    if (*p) count++;
+  lglprt (lgl, 1,
+    "[treelook-%d] scheduled %d literals %.0f%%",
+    lgl->stats->prb.treelook.count, count, lglpcnt (count, 2*lglrem (lgl)));
+  if (!count)
+    for (idx = 2; idx < lgl->nvars; idx++)
+      lglavar (lgl, idx)->donotreelook = 0;
+}
+
+static void lgltlassign (LGL * lgl, Stk * assignment, int lit) {
+  TVar * tv;
+  LOG (2, "tree-look assign %d", lit);
+  tv = lgltvar (lgl, lit);
+  assert (!tv->val);
+  tv->val = lglsgn (lit) * (1 + lglcntstk (assignment));
+  lglpushstk (lgl, assignment, lit);
+  assert (tv->val);
+  assert (lglsgn (tv->val) == lglsgn (lit));
+}
+
+static void lgltlunassign (LGL * lgl, int lit) {
+  TVar * tv;
+  LOG (2, "tree-look unassign %d", lit);
+  tv = lgltvar (lgl, lit);
+  assert (tv->val);
+  assert (lglsgn (tv->val) == lglsgn (lit));
+  tv->val = 0;
+}
+
+static int lgltlval (LGL * lgl, int lit) {
+  TVar * tv = lgltvar (lgl, lit);
+  int res;
+  if (!tv->val) return 0;
+  res = lglsgn (tv->val);
+  if (lit < 0) res = -res;
+  return res;
+}
+
+static void lglincreducedptr (LGL * lgl, Flt * reducedptr, int size) {
+  Flt reduced = *reducedptr, inc = lglflt (-size, 1);
+  reduced = lgladdflt (reduced, inc);
+  LOG (2, "reduced score incremented to %s from %s by %s (size %d)",
+       lglflt2str (lgl, reduced), 
+       lglflt2str (lgl, *reducedptr), 
+       lglflt2str (lgl, inc),
+       size);
+  *reducedptr = reduced;
+}
+
+static int lgltlbcp (LGL * lgl,
+                     Stk * assignment, Flt * reducedptr, int dom) {
+  int next = lglcntstk (assignment), next2 = next, lit, size, implied;
+  int blit, tag, other, other2, val, lidx, red, found, trivial;
+  int numnonfalse, numfalse, firstfalse, litval, skip;
+  const int * p, * w, * eos, * c, * q;
+  HTS * hts;
+  if (lglval (lgl, dom)) return 1;
+  assert (!lgltlval (lgl, dom));
+  lgltlassign (lgl, assignment, dom);
+  lgl->stats->prb.treelook.probed++;
+  LOG (2, "starting tree-look bcp on %d", dom);
+  for (;;) {
+    if (next2 < lglcntstk (assignment)) {
+      assert (lgl->simp);
+      INCSTEPS (props.simp);
+      if (lgl->lkhd) INCSTEPS (props.lkhd);
+      lit = lglpeek (assignment, next2++);
+      assert (lgltlval (lgl, lit) > 0);
+      LOG (2, "tree-look binary clause bcp on %d", lit);
+      hts = lglhts (lgl, -lit);
+      w = lglhts2wchs (lgl, hts);
+      eos = w + hts->count;
+      for (p = w; p < eos; p++) {
+	assert (lgl->simp);
+	lgl->stats->visits.simp++;
+	if (lgl->lkhd) lgl->stats->visits.lkhd++;
+	INCSTEPS (prb.treelook.steps);
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == OCCS) continue;
+	if (tag == TRNCS || tag == LRGCS) { p++; continue; }
+	assert (tag == BINCS);
+	other = blit >> RMSHFT;
+	val = lglval (lgl, other);
+	if (val < 0) return 0;
+	if (val > 0) continue;
+	val = lgltlval (lgl, other);
+	if (val < 0) return 0;
+	if (reducedptr) lglincreducedptr (lgl, reducedptr, 2);
+	if (val > 0) continue;
+	lgltlassign (lgl, assignment, other);
+      }
+    } else if (next < lglcntstk (assignment)) {
+      lit = lglpeek (assignment, next++);
+      litval = lgltlval (lgl, lit);
+      assert (litval > 0);
+      LOG (2, "tree-look non-binary clause bcp on %d", lit);
+      hts = lglhts (lgl, -lit);
+      w = lglhts2wchs (lgl, hts);
+      eos = w + hts->count;
+      for (p = w; p < eos; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == LRGCS || tag == TRNCS) p++;
+	if (tag == BINCS || tag == LRGCS) continue;
+	INCSTEPS (prb.treelook.steps);
+	assert (lglmtstk (&lgl->clause));
+	skip = trivial = 0;
+	if (tag == TRNCS) {
+	  other = blit >> RMSHFT;
+	  other2 = *p;
+	  if (lglval (lgl, other) > 0 || 
+	      lglval (lgl, other2) > 0) skip = 1;
+	  else {
+	    if (lgltlval (lgl, other) > 0 ||
+	        lgltlval (lgl, other2) > 0) trivial = 1;
+	    lglpushstk (lgl, &lgl->clause, -lit),
+	    lglpushstk (lgl, &lgl->clause, other),
+	    lglpushstk (lgl, &lgl->clause, other2);
+	  }
+	} else {
+	  assert (tag == OCCS);
+	  red = blit & REDCS;
+	  lidx = blit >> RMSHFT;
+	  found = trivial = 0;
+	  c = lglidx2lits (lgl, red, lidx);
+	  INCSTEPS (prb.treelook.steps);
+	  for (q = c; !skip && (other = *q); q++) {
+	    if (other >= NOTALIT) skip = 1;
+	    else if (lglval (lgl, other) > 0) skip = 1;
+	    else {
+	      if (other == -lit) assert (!found), found++;
+	      if (lgltlval (lgl, other) > 0) trivial = 1;
+	      lglpushstk (lgl, &lgl->clause, other);
+	    }
+	  }
+	  assert (skip || found);
+	}
+	numnonfalse = numfalse = size = implied = 0;
+	firstfalse = 1;
+	if (!skip) {
+	  INCSTEPS (prb.treelook.steps);
+	  for (q = lgl->clause.start; q < lgl->clause.top; q++) {
+	    other = *q;
+	    if (lglval (lgl, other) < 0) continue;
+	    size++;
+	    if ((val = lgltlval (lgl, other)) < 0) {
+	      if (reducedptr && -val < litval) firstfalse = 0;
+	      numfalse++; 
+	      continue; 
+	    }
+	    numnonfalse++;
+	    if (implied == NOTALIT) continue;
+	    else if (implied) implied = NOTALIT;
+	    else implied = other;
+	  }
+	}
+	lglclnstk (&lgl->clause);
+	if (skip) continue;
+	if (reducedptr && firstfalse) 
+	  lglincreducedptr (lgl, reducedptr, size);
+	if (trivial) continue;
+	if (!numnonfalse) { assert (!implied); return 0; }
+	assert (implied);
+	if (implied == NOTALIT) continue;
+	assert (numnonfalse == 1);
+	if (!numfalse) continue; // TODO remove?
+	INCSTEPS (prb.treelook.steps);
+	if (tag == TRNCS) lgl->stats->hbr.trn++; else lgl->stats->hbr.lrg++;
+	LOG (2, "tree-look hyper binary resolvent %d %d", -dom, implied);
+        lgldrupligaddclsarg (lgl, REDCS, -dom, implied, 0);
+	(void) lglwchbin (lgl, -dom, implied, REDCS);
+	(void) lglwchbin (lgl, implied, -dom, REDCS);
+	lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+	lgl->stats->hbr.cnt++;
+	lgl->stats->prgss++;
+	lgltlassign (lgl, assignment, implied);
+	assert (next > 0),  next--; // force to redo this trn/lrg literal
+	break;	// and continue outer 'next2' prop on 'implied'
+      }
+    } else break;
+  }
+  if (reducedptr) assert (lgl->tlk->lkhd), lgl->tlk->lkhd[dom] = *reducedptr;
+  return 1;
+}
+
+static void lgltreelooklit (LGL * lgl, Stk * a, Ftk * r, int lit) {
+  Flt reduced;
+  LOG (2, "treelook dequeue %d", lit);
+  if (lit) {
+    if (lgl->opts->treelook.val >= 2 &&
+	lglmtstk (a) &&
+	lglisfree (lgl, lit)) lglbasicprobelit (lgl, -lit);
+    if (r) {
+      reduced = lglmtftk (r) ? FLTMIN : lgltopftk (r);
+      lglpushftk (lgl, r, reduced);
+    }
+    lglpushstk (lgl, a, 0);
+    if (lgl->mt || !lglisfree (lgl, lit)) return;
+    if (lgltlval (lgl, -lit) > 0 ||
+	(!lgltlval (lgl, lit) && 
+	 !lgltlbcp (lgl, a, r ? &reduced : 0, lit))) {
+      int tmp;
+      LOG (1, "tree-look failed literal %d", lit);
+      if (!(tmp = lglval (lgl, lit))) {
+	lgl->stats->prb.treelook.failed++;
+	lglunit (lgl, -lit);
+	if (!lglbcp (lgl)) {
+	  LOG (1, "inconsistent tree-look failed literal");
+	  if (!lgl->mt) lglmt (lgl);
+	}
+      } else if (tmp > 0) {
+	lgl->stats->prb.treelook.failed++;
+	LOG (1, "tree-look failed literal literal %d inconsistent", lit);
+	if (!lgl->mt) lglmt (lgl);
+      } else LOG (1, "tree-look failed literal %d already found", lit);
+    }
+    if (r) {
+      assert (r->start < r->top);
+      assert (r->top[-1] <= reduced);
+      r->top[-1] = reduced;
+    }
+  } else {
+    if (r) lglpopftk (r);
+    while ((lit = lglpopstk (a)))
+      lgltlunassign (lgl, lit);
+  }
+}
+
+static int64_t lglsetprbtreelooklim (LGL * lgl, int * lkhdresptr) {
+  int szpen, lastpen, pen, boost;
+  int64_t limit, irrlim;
+  if (lgl->opts->treelookrtc.val || lgl->opts->prbrtc.val) {
+    limit = lgl->limits->prb.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[treelook-%d] really no limit (run to completion)",
+      lgl->stats->prb.treelook.count);
+  } else if (lkhdresptr && lgl->opts->treelookfull.val) {
+    limit = lgl->limits->prb.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[treelook-%d] unlimited look-ahead requested",
+      lgl->stats->prb.treelook.count);
+  } else {
+    limit = (lgl->opts->treelookreleff.val*lglvisearch (lgl))/2000;
+    if (limit < lgl->opts->treelookmineff.val)
+      limit = lgl->opts->treelookmineff.val;
+    if (lgl->opts->treelookmaxeff.val >= 0 &&
+        limit > lgl->opts->treelookmaxeff.val)
+      limit = lgl->opts->treelookmaxeff.val;
+    assert (lgl->tlk);
+    szpen = lglszpen (lgl);
+    lastpen = lgl->tlk->lkhd ? 
+      lgl->limits->lkhdpen : lgl->limits->prb.treelook.pen;
+    limit >>= (pen = szpen + lastpen);
+    irrlim = (lgl->stats->irr.clauses.cur/4) >> szpen;
+    if (lgl->opts->boost.val && lgl->tlk->lkhd)
+      boost = lgl->opts->treelookboost.val;
+    else boost = 1;
+    limit *= boost;
+    if (lgl->opts->irrlim.val && limit < irrlim) {
+      limit = irrlim;
+      lglprt (lgl, 1, 
+  "[treelook-%d] limit %lld based on %d irredundant clauses penalty %d",
+	lgl->stats->prb.treelook.count, 
+	(LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+    } else
+      lglprt (lgl, 1, 
+	"[treelook-%d] limit %lld penalty %d = %d + %d boost %d",
+	lgl->stats->prb.treelook.count, (LGLL) limit,
+	pen, lastpen, szpen, boost);
+    if (lkhdresptr)
+      lglprt (lgl, 1, "[treelook-%d] limited look-ahead requested",
+	      lgl->stats->prb.treelook.count);
+    lgl->limits->prb.steps = lgl->stats->prb.treelook.steps + limit;
+  }
+
+  return limit;
+}
+
+static void lglclntlvals (LGL * lgl) {
+  int idx;
+  for (idx = 2; idx < lgl->nvars; idx++) lgl->tlk->tvars[idx].val = 0;
+}
+
+#ifndef NDEBUG
+static int lglieliminated (LGL * lgl, int ilit) {
+  return lglelit2ext (lgl, lglexport (lgl, ilit))->eliminated;
+}
+#endif
+
+static int lgliblocking (LGL * lgl, int ilit) {
+  return lglelit2ext (lgl, lglexport (lgl, ilit))->blocking;
+}
+
+static void lgltlsetlkhd (LGL * lgl, int * lkhdresptr, int remlits) {
+  LKHD lkhdrescore, lkhdscore, lkhdpos, lkhdneg;
+  Flt jwhrescore, jwhscore, jwhpos, jwhneg;
+  int idx, lkhdres, phase, elit;
+  Ext * ext;
+  assert (lkhdresptr);
+  lkhdres = 0; lkhdrescore = FLTMIN; jwhrescore = FLTMIN;
+  assert (!lgl->nvars || lgl->tlk->lkhd);
+  lgljwh (lgl);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    assert (!lglieliminated (lgl, idx));
+    if (lkhdresptr && lgliblocking (lgl, idx)) continue;
+    if (!remlits) {
+      lkhdpos = lgl->tlk->lkhd[idx];
+      lkhdneg = lgl->tlk->lkhd[-idx];
+      lkhdscore = lglmulflt (lkhdneg, lkhdpos);
+      if (lkhdscore > FLTMIN)
+	lkhdscore = lgladdflt (lkhdscore, lgladdflt (lkhdneg, lkhdpos));
+    } else lkhdscore = lkhdpos = lkhdneg = FLTMIN;
+    jwhpos = lgl->jwh[lglulit (idx)];
+    jwhneg = lgl->jwh[lglulit (-idx)];
+    jwhscore = lglmulflt (jwhpos, jwhneg);
+    jwhscore = lgladdflt (jwhscore, lgladdflt (jwhpos, jwhneg));
+    LOG (1,
+      "final tree based look-ahead score [%s,%s] "
+      "(pos [%s,%s], neg [%s,%s]) of %d",
+       lglflt2str (lgl, lkhdscore), lglflt2str (lgl,jwhscore),
+       lglflt2str (lgl, lkhdpos), lglflt2str (lgl,jwhpos),
+       lglflt2str (lgl, lkhdneg), lglflt2str (lgl,jwhneg),
+       idx);
+
+    // phase with less weighted reductions
+         if (lkhdpos > lkhdneg) phase = -1;
+    else if (lkhdpos < lkhdneg) phase = 1;
+    // then with more weighted occs
+    else if (jwhpos > jwhneg) phase = 1;
+    else if (jwhpos < jwhneg) phase = -1;
+    // otherwise negative phase
+    else phase = -1;
+
+    if (lkhdres) {
+      if (lkhdscore < lkhdrescore) continue;
+      if (lkhdscore == lkhdrescore && jwhscore <= jwhrescore) continue;
+    }
+    lkhdrescore = lkhdscore;
+    jwhrescore = jwhscore;
+    lkhdres = phase * idx;
+  }
+  if (lkhdres) {
+    elit = lglexport (lgl, lkhdres);
+    ext = lglelit2ext (lgl, elit);
+    assert (!ext->eliminated);
+    assert (!ext->blocking);
+    lglprt (lgl, 1, "[treelook-%d] best look-ahead %d score [%s,%s]",
+      lgl->stats->prb.treelook.count, lkhdres,
+      lglflt2str (lgl, lkhdrescore), lglflt2str (lgl, jwhrescore));
+    if (ext->melted) {
+      ext->melted = 0;
+      LOG (2, "tree-look-ahead winner external %d not melted anymore", elit);
+    } else
+      LOG (2,
+	"tree-look-ahead winner external %d was not melted anyhow", elit);
+  } else LOG (1, "no proper best tree-look-ahead literal found");
+  if (lkhdresptr) *lkhdresptr = lkhdres;
+}
+
+static void lglgenericreport (LGL * lgl, const char * name, int count,
+                              int probed, int nprobes, double start) {
+  int div, mod;
+  assert (nprobes >= 0);
+  if (!nprobes || lgl->opts->verbose.val < 2) return;
+  if (lgl->opts->verbose.val == 2) div = 10;
+  else if (lgl->opts->verbose.val == 3) div = 100;
+  else div = 0;
+  mod = div ? (nprobes + div - 1) / div : 1;
+  assert (mod > 0);
+  if (probed % mod) return;
+  lglprt (lgl, 1,
+    "[%s-%d] probed %d/%d (%.0f%%) %.1f sec %d vars %.0f MB",
+    name, count, probed, nprobes, lglpcnt (probed, nprobes),
+    lglgetime (lgl) - start, lglrem (lgl), lglmb (lgl));
+}
+
+static void lgltreelookreport (LGL * lgl,
+                              int probed, int nprobes, double start) {
+  lglgenericreport (lgl,
+     "treelook", lgl->stats->prb.treelook.count, probed, nprobes, start);
+}
+
+static int lgltreelookaux (LGL * lgl, int * lkhdresptr) {
+  int oldhbrs, oldrem, remvarsall, remvarslkhd, remlits, notfullyscheduled;
+  int deltavars, newhbrs, success, idx, next, lit, nseen;
+  int64_t oldsteps, steps, limit;
+  Stk assignment;
+  double start;
+  Ftk reduced;
+  TVar * tv;
+  AVar * av;
+
+  if (lgl->mt) return 0;
+  if (lkhdresptr) *lkhdresptr = 0;
+  if (!lgl->nvars) return 1;
+
+  lglstart (lgl, &lgl->times->prb.treelook);
+  lgl->stats->prb.treelook.count++;
+
+  NEW (lgl->tlk, 1);
+  NEW (lgl->tlk->tvars, lgl->nvars);
+
+  assert (!lgl->simp && !lgl->probing && !lgl->treelooking);
+  lgl->simp = lgl->probing = lgl->treelooking = 1;
+
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  oldhbrs = lgl->stats->hbr.cnt;
+  oldrem = lglrem (lgl);
+
+  assert (!lgl->tlk->lkhd);
+  if (lkhdresptr) {
+    NEW (lgl->tlk->lkhd, 2*lgl->nvars);
+    lgl->tlk->lkhd += lgl->nvars;
+    assert (lgl->tlk->lkhd);
+  }
+
+  limit = lglsetprbtreelooklim (lgl, lkhdresptr);
+  oldsteps = lgl->stats->prb.treelook.steps;
+
+  lgltlsched (lgl);
+
+  steps = lgl->stats->prb.treelook.steps - oldsteps;
+  lglprt (lgl, 1, "[treelook-%d] scheduling used %lld steps",
+    lgl->stats->prb.treelook.count, (LGLL) steps);
+
+  if (limit != LLMAX) {
+    notfullyscheduled =
+      (lgl->stats->prb.treelook.steps >= lgl->limits->prb.steps);
+    lgl->limits->prb.steps = lgl->stats->prb.treelook.steps + limit;
+    if (notfullyscheduled)
+      lglprt (lgl, 1, "[treelook-%d] not fully scheduled",
+ 	lgl->stats->prb.treelook.count);
+    else
+      lglprt (lgl, 1, "[treelook-%d] scheduled completely",
+ 	lgl->stats->prb.treelook.count);
+  } else notfullyscheduled = 0;
+
+  CLR (assignment); CLR (reduced);
+  remlits = remvarsall = remvarslkhd = 0;
+
+  nseen = lglcntstk (&lgl->tlk->seen);
+  if (!lgl->mt && nseen) {
+
+    (void) lglsetprbtreelooklim (lgl, lkhdresptr);
+    oldsteps = lgl->stats->prb.treelook.steps;
+
+    lgldense (lgl, 0);
+    next = 0;
+    start = lglgetime (lgl);
+    lgltreelookreport (lgl, next, nseen, start);
+    while (!lgl->mt &&
+	   !lglterminate (lgl) &&
+	   lglsyncunits (lgl) &&
+	   next < nseen &&
+	   lgl->stats->prb.treelook.steps < lgl->limits->prb.steps) {
+      lit = lglpeek (&lgl->tlk->seen, next++);
+      lgltreelooklit (lgl, &assignment, lkhdresptr ? &reduced : 0, lit);
+      lgltreelookreport (lgl, next, nseen, start);
+    }
+    lgltreelookreport (lgl, next, nseen, start);
+    lglclntlvals (lgl);
+    assert (lgl->stats->prb.treelook.steps >= oldsteps);
+    steps = lgl->stats->prb.treelook.steps - oldsteps;
+    lglprt (lgl, 1, "[treelook-%d] used %lld steps",
+      lgl->stats->prb.treelook.count, (LGLL) steps);
+    while (next < lglcntstk (&lgl->tlk->seen)) {
+      lit = lglpeek (&lgl->tlk->seen, next++);
+      if (!lit) continue;
+      if (!lglisfree (lgl, lit)) continue;
+      remlits++;
+      tv = lgltvar (lgl, lit);
+      tv->val = 1;
+    }
+    for (idx = 2; idx < lgl->nvars; idx++)
+      if (lglisfree (lgl, idx)) {
+	tv = lgltvar (lgl, idx);
+	av = lglavar (lgl, idx);
+	if (tv->val) {
+	   tv->val = 0;
+	   if (!av->donotreelook) remvarsall++;
+	   remvarslkhd++;
+	} else if (!av->donotreelook) av->donotreelook = 1;
+      }
+    assert (remvarslkhd >= remvarsall);
+
+    if (remvarsall || notfullyscheduled) {
+      lglprt (lgl, 1, "[treelook-%d] %d literals remain %.0f%%%s",
+	lgl->stats->prb.treelook.count,
+	remlits, lglpcnt (remlits, 2*lglrem (lgl)),
+        lkhdresptr ? " in look-ahead" : "");
+      if (lkhdresptr)
+	lglprt (lgl, 1, "[treelook-%d] %d look-ahead variables remain %.0f%%",
+	  lgl->stats->prb.treelook.count,
+	  remvarslkhd, lglpcnt (remvarslkhd, lglrem (lgl)));
+      lglprt (lgl, 1,
+	"[treelook-%d] %d variables remain to probed next time %.0f%%",
+	lgl->stats->prb.treelook.count,
+	remvarsall, lglpcnt (remvarsall, lglrem (lgl)));
+    } else {
+      lglprt (lgl, 1, 
+        "[treelook-%d] fully completed tree based probing%s",
+	lgl->stats->prb.treelook.count, lkhdresptr ? " in look-ahead" : "");
+      for (idx = 2; idx < lgl->nvars; idx++)
+	lglavar (lgl, idx)->donotreelook = 0;
+    }
+    lglsparse (lgl);
+  }
+
+  DEL (lgl->tlk->tvars, lgl->nvars);
+  lglgc (lgl);
+  lglrelftk (lgl, &reduced);
+  lglrelstk (lgl, &assignment);
+  lglrelstk (lgl, &lgl->tlk->seen);
+  if (!lgl->mt && lkhdresptr) 
+    lgltlsetlkhd (lgl, lkhdresptr, remlits || notfullyscheduled);
+  if (lgl->tlk->lkhd) {
+    lgl->tlk->lkhd -= lgl->nvars;
+    DEL (lgl->tlk->lkhd, 2*lgl->nvars);
+  }
+  DEL (lgl->tlk, 1);
+  newhbrs = lgl->stats->hbr.cnt - oldhbrs;
+  if (newhbrs && !lgl->mt && !lkhdresptr) lgldecomp (lgl);
+
+  assert (lgl->simp && lgl->probing && lgl->treelooking);
+  lgl->simp = lgl->probing = lgl->treelooking = 0;
+
+  deltavars = oldrem - lglrem (lgl);
+  success = deltavars || newhbrs;
+  if (!lkhdresptr) LGLUPDPEN (prb.treelook, deltavars);
+  else if (remlits && lgl->limits->lkhdpen < lgl->opts->penmax.val)
+    lgl->limits->lkhdpen++;
+  else if (!remlits && lgl->limits->lkhdpen)
+    lgl->limits->lkhdpen--;
+  lglprt (lgl, 1 + !success,
+	  "[treelook-%d] removed %d variables, found %d hbrs",
+	  lgl->stats->prb.treelook.count, deltavars, newhbrs);
+  lglrep (lgl, 2, 'p');
+  lglstop (lgl);
+  lglbasicatestats (lgl);
+  return !lgl->mt;
+}
+
+static int lgltreelook (LGL * lgl) {
+  if (lgldelaying (lgl, "treelook",
+        &lgl->limits->prb.treelook.del.rem)) return 1;
+  return lgltreelookaux (lgl, 0);
+}
+
+static int lgljwhlook (LGL * lgl) {
+  Flt best, pos, neg, score;
+  int res, idx, elit;
+  Ext * ext;
+  lgljwh (lgl);
+  best = FLTMIN;
+  res = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    assert (!lglieliminated (lgl, idx));
+    if (lgliblocking (lgl, idx)) continue;
+    pos = lgl->jwh[lglulit (idx)];
+    neg = lgl->jwh[lglulit (-idx)];
+    score = lglmulflt (pos, neg);
+    score = lgladdflt (score, lgladdflt (pos, neg));
+    if (res && score <= best) continue;
+    LOG (1, "jwh look-ahead score %s (pos %s, neg %s) of %d",
+      lglflt2str (lgl, score), lglflt2str (lgl, pos), lglflt2str (lgl, neg),
+      idx);
+    res = (pos > neg) ? idx : -idx;
+    best = score;
+  }
+  if (res) {
+    elit = lglexport (lgl, res);
+    ext = lglelit2ext (lgl, elit);
+    lglprt (lgl, 1, "[jwhlook] best look-ahead %d score %s",
+            res, lglflt2str (lgl, best));
+    if (ext->melted) {
+      ext->melted = 0;
+      LOG (2, "jwh-look-ahead winner external %d not melted anymore", elit);
+    } else
+      LOG (2, "jwh-look-ahead winner external %d was not melted anyhow", elit);
+  } else LOG (1, "no proper best jwh-look-ahead literal found");
+  return res;
+}
+
+static int lglislook (LGL * lgl) {
+  int64_t best, pos, neg, score;
+  int res, idx, elit, * scores;
+  Ext * ext;
+  scores = lglis (lgl);
+  best = res = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    assert (!lglieliminated (lgl, idx));
+    if (lgliblocking (lgl, idx)) continue;
+    pos = scores[idx], neg = scores[-idx];
+    score = pos * neg + pos + neg;
+    assert (0 <= score && pos <= score && neg <= score);
+    if (res && score <= best) continue;
+    LOG (1,
+      "LIS look-ahead score %lld (pos %lld, neg %lld) of %d",
+      (LGLL) score, (LGLL) pos, (LGLL) neg, idx);
+    res = (pos > neg) ? idx : -idx;
+    best = score;
+  }
+  scores -= lgl->nvars;
+  DEL (scores, 2*lgl->nvars);
+  if (res) {
+    elit = lglexport (lgl, res);
+    ext = lglelit2ext (lgl, elit);
+    assert (!ext->eliminated && !ext->blocking);
+    lglprt (lgl, 1,
+      "[lislook] best LIS look-ahead %d score %lld", 
+      res, (LGLL) best);
+    if (ext->melted) {
+      ext->melted = 0;
+      LOG (2, "look-ahead winner external %d not melted anymore", elit);
+    } else
+      LOG (2, "look-ahead winner external %d was not melted anyhow", elit);
+  } else LOG (1, "no proper best LIS look-ahead literal found");
+  return res;
+}
+
+static int64_t lglsatmul64 (int64_t a, int64_t b) {
+  assert (a >= 0), assert (b >= 0);
+  return (b && (LLMAX / b < a)) ? LLMAX : a * b;
+}
+
+static int64_t lglsatadd64 (int64_t a, int64_t b) {
+  assert (a >= 0), assert (b >= 0);
+  return (LLMAX - b < a) ? LLMAX : a + b;
+}
+
+static int64_t * lglsumlenscores (LGL * lgl) {
+  int idx, sign, lit, tag, blit, other, other2, red;
+  const int *p, * w, * eow, * c;
+  int64_t * res, len;
+  Val val, tmp, tmp2;
+  HTS * hts;
+  Stk * s;
+  NEW (res, 2*lgl->nvars);
+  res += lgl->nvars;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      val = lglval (lgl, lit);
+      if (val > 0) continue;
+      hts = lglhts (lgl, lit);
+      if (!hts->offset) continue;
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	if (red) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < abs (lit)) continue;
+	tmp = lglval (lgl, other);
+	if (tmp > 0) continue;
+	if (tag == BINCS) {
+	  assert (!tmp);
+	  res[lit] += 2;
+	  res[other] += 2;
+	} else {
+	  assert (tag == TRNCS);
+	  other2 = *p;
+	  if (abs (other2) < abs (lit)) continue;
+	  tmp2 = lglval (lgl, other2);
+	  if (tmp2 > 0) continue;
+	  assert ((val > 0) + (tmp > 0) + (tmp2 > 0) == 0);
+	  assert ((val < 0) + (tmp < 0) + (tmp2 < 0) <= 1);
+	  len = !val + !tmp + !tmp2;
+	  if (!val) res[lit] += len;
+	  if (!tmp) res[other] += len;
+	  if (!tmp2) res[other2] += len;
+	}
+      }
+    }
+  s = &lgl->irr;
+  for (c = s->start; c < s->top; c = p + 1) {
+    p = c;
+    if (*p >= NOTALIT) continue;
+    val = -1;
+    len = 0;
+    while ((other = *p)) {
+      tmp = lglval (lgl, other);
+      if (tmp > val) val = tmp;
+      if (!tmp) len++;
+      p++;
+    }
+    if (val > 0) continue;
+    for (p = c; (other = *p); p++)
+      if (!lglval (lgl, other))
+	res[other] += len;
+  }
+  return res;
+}
+
+static int lglsumlenlook (LGL * lgl) {
+  int64_t best, pos, neg, score, * scores;
+  int res, idx, elit;
+  Ext * ext;
+  scores = lglsumlenscores (lgl);
+  best = res = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    assert (!lglieliminated (lgl, idx));
+    if (lgliblocking (lgl, idx)) continue;
+    pos = scores[idx], neg = scores[-idx];
+    score = lglsatadd64 (lglsatmul64 (pos, neg), lglsatadd64 (pos, neg));
+    assert (0 <= score), assert (pos <= score), assert (neg <= score);
+    if (res && score <= best) continue;
+    LOG (1,
+      "look-ahead score %lld (pos %lld, neg %lld) of %d",
+      (LGLL) score, (LGLL) pos, (LGLL) neg, idx);
+    res = (pos > neg) ? idx : -idx;
+    best = score;
+  }
+  scores -= lgl->nvars;
+  DEL (scores, 2*lgl->nvars);
+  if (res) {
+    elit = lglexport (lgl, res);
+    ext = lglelit2ext (lgl, elit);
+    assert (!ext->eliminated && !ext->blocking);
+    lglprt (lgl, 1,
+      "[sumlook] best look-ahead %d score %lld", 
+      res, (LGLL) best);
+    if (ext->melted) {
+      ext->melted = 0;
+      LOG (2, "look-ahead winner external %d not melted anymore", elit);
+    } else
+      LOG (2, "look-ahead winner external %d was not melted anyhow", elit);
+  } else LOG (1, "no proper best look-ahead literal found");
+  return res;
+}
+
+static int lglschedbasicprobe (LGL * lgl, Stk * probes, int round) {
+  int idx, res, i, j, donotbasicprobes, keepscheduled;
+  assert (lglmtstk (probes));
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    if (lgl->opts->prbasic.val <= 1 &&
+        (lglhasbins (lgl, idx) == lglhasbins (lgl, -idx))) continue;
+    LOG (1, "new probe %d", idx);
+    lglpushstk (lgl, probes, idx);
+  }
+  res = lglcntstk (probes);
+  donotbasicprobes = keepscheduled = 0;
+  for (i = 0; i < res; i++) {
+    idx = lglpeek (probes, i);
+    if (!idx) continue;
+    assert (lglisfree (lgl, idx));
+    if (lglavar (lgl, idx)->donotbasicprobe) donotbasicprobes++;
+    else keepscheduled++;
+  }
+  if (!keepscheduled) {
+    for (i = 0; i < res; i++) {
+      idx = lglpeek (probes, i);
+      if (!idx) continue;
+      assert (lglisfree (lgl, idx));
+      lglavar (lgl, idx)->donotbasicprobe = 0;
+      keepscheduled++;
+    }
+    donotbasicprobes = 0;
+  }
+  for (i = 0; i < res; i++) {
+    idx = lglpeek (probes, i);
+    if (!idx) continue;
+    assert (lglisfree (lgl, idx));
+    if (lglavar (lgl, idx)->donotbasicprobe) donotbasicprobes++;
+    else keepscheduled++;
+  }
+  j = 0;
+  for (i = 0; i < res; i++) {
+    idx = lglpeek (probes, i);
+    if (!idx) continue;
+    if (!lglavar (lgl, idx)->donotbasicprobe)
+      lglpoke (probes, j++, idx);
+  }
+  lglrststk (probes, (res = j));
+  if (!res)
+    lglprt (lgl, 2, "[basicprobe-%d-%d] no potential probes found",
+	    lgl->stats->prb.basic.count, round);
+  else if (!donotbasicprobes)
+    lglprt (lgl, 2, "[basicprobe-%d-%d] scheduled all %d potential probes",
+	    lgl->stats->prb.basic.count, round, res);
+  else
+    lglprt (lgl, 2, "[basicprobe-%d-%d] scheduled %d probes %.0f%%",
+	    lgl->stats->prb.basic.count, round,
+	    res, lglpcnt (res, lglrem (lgl)));
+  return res;
+}
+
+static void lglsetprbasiclim (LGL * lgl) {
+  int64_t limit, irrlim;
+  int pen, szpen;
+  if (lgl->opts->prbasicrtc.val || lgl->opts->prbrtc.val) {
+    lgl->limits->prb.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[basicprobe-%d] really no limit (run to completion)", 
+      lgl->stats->prb.basic.count);
+  } else {
+    limit = (lgl->opts->prbasicreleff.val*lglvisearch (lgl))/1000;
+    if (limit < lgl->opts->prbasicmineff.val)
+      limit = lgl->opts->prbasicmineff.val;
+    if (lgl->opts->prbasicmaxeff.val >= 0 &&
+	limit > lgl->opts->prbasicmaxeff.val)
+      limit = lgl->opts->prbasicmaxeff.val;
+    limit >>= (pen = lgl->limits->prb.basic.pen + (szpen = lglszpen (lgl)));
+    irrlim = (8*lgl->stats->irr.clauses.cur) >> szpen;
+    if (lgl->opts->irrlim.val && limit < irrlim) {
+      limit = irrlim;
+      lglprt (lgl, 1,
+    "[basicprobe-%d] limit %lld based on %d irredundant clauses penalty %d",
+	lgl->stats->prb.basic.count,
+	(LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+    } else
+      lglprt (lgl, 1, "[basicprobe-%d] limit %lld penalty %d = %d + %d",
+	lgl->stats->prb.basic.count, (LGLL) limit,
+	pen, lgl->limits->prb.basic.pen, szpen);
+    lgl->limits->prb.steps = lgl->stats->prb.basic.steps + limit;
+  }
+}
+
+static void lglbasicprobereport (LGL * lgl,
+                                 int probed, int nprobes, double start) {
+  lglgenericreport (lgl,
+    "basicprobe", lgl->stats->prb.basic.count, probed, nprobes, start);
+}
+
+static int lglbasicprobe (LGL * lgl) {
+#ifndef NLGLOG
+  int origprobed = lgl->stats->prb.basic.probed;
+#endif
+  int origfailed = lgl->stats->prb.basic.failed;
+  int origlifted = lgl->stats->prb.basic.lifted;
+  int orighbr = lgl->stats->hbr.cnt;
+  int root, failed, lifted, units, first, idx;
+  int oldrem, deltarem, deltahbr, remprobes;
+  int nprobes, success, round, probed;
+  int oldhbr, oldfailed, oldlifted;
+  Stk probes, lift, saved;
+  unsigned pos, delta;
+  double start;
+  if (!lgl->nvars) return 1;
+  if (!lgl->opts->probe.val) return 1;
+  if (lgldelaying (lgl, "basicprobe",
+        &lgl->limits->prb.basic.del.rem)) return 1;
+  lglstart (lgl, &lgl->times->prb.basic);
+  lgl->stats->prb.basic.count++;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  assert (!lgl->simp && !lgl->probing && !lgl->basicprobing);
+  lgl->simp = lgl->probing = lgl->basicprobing = 1;
+  CLR (lift); CLR (probes); CLR (saved);
+  lglsetprbasiclim (lgl);
+  oldfailed = origfailed;
+  oldlifted = origlifted;
+  oldhbr = lgl->stats->hbr.cnt;
+  oldrem = lglrem (lgl);
+  round = 0;
+RESTART:
+  nprobes = lglschedbasicprobe (lgl, &probes, round);
+  remprobes = 0;
+  if (!nprobes) goto DONE;
+  pos = lglrand (lgl) % nprobes;
+  delta = lglrand (lgl) % nprobes;
+  if (!delta) delta++;
+  probed = 0;
+  start = lglgetime (lgl);
+  lglbasicprobereport (lgl, probed, nprobes, start);
+  while (lglgcd (delta, nprobes) > 1)
+    if (++delta == nprobes) delta = 1;
+  LOG (1, "probing start %u delta %u mod %u", pos, delta, nprobes);
+  first = 0;
+  while (!lgl->mt) {
+    if (lgl->stats->prb.basic.steps >= lgl->limits->prb.steps) break;
+    if (lglterminate (lgl)) break;
+    if (!lglsyncunits (lgl)) break;
+    assert (pos < (unsigned) nprobes);
+    root = probes.start[pos];
+    probes.start[pos] = 0;
+    if (!root || root == first) {
+      lglprt (lgl, 1,
+        "[basicprobe-%d-%d] %d sched %.0f%%, %d failed, %d lifted, %d hbrs",
+	lgl->stats->prb.basic.count, round,
+	nprobes, lglpcnt (nprobes, lglrem (lgl)),
+        lgl->stats->prb.basic.failed - oldfailed,
+        lgl->stats->prb.basic.lifted - oldlifted,
+        lgl->stats->hbr.cnt - oldhbr);
+      for (idx = 2; idx < lgl->nvars; idx++)
+	lglavar (lgl, idx)->donotbasicprobe = 0;
+      break;
+    }
+    lglavar (lgl, root)->donotbasicprobe = 1;
+    if (!first) first = root;
+    pos += delta;
+    if (pos >= nprobes) pos -= nprobes;
+    if (!lglisfree (lgl, root)) continue;
+    lglbasicprobereport (lgl, ++probed, nprobes, start);
+    lglbasicprobelit (lgl, root);
+  }
+  lglbasicprobereport (lgl, probed, nprobes, start);
+  if (!lgl->mt) {
+    if (lgl->stats->prb.basic.steps >= lgl->limits->prb.steps) {
+      while (!lglmtstk (&probes))
+	if((idx = lglpopstk (&probes)) && lglisfree (lgl, idx)) remprobes++;
+      lglprt (lgl, 1, 
+        "[basicprobe-%d-%d] %d probes remain %.0f%% after last round",
+	lgl->stats->prb.basic.count, round,
+	remprobes, lglpcnt (remprobes, lglrem (lgl)));
+    } else if (round >= lgl->opts->prbasicroundlim.val) {
+      lglprt (lgl, 1,
+	      "[basicprobe-%d-%d] round limit %d hit",
+	      lgl->stats->prb.basic.count, round, 
+	      lgl->opts->prbasicroundlim.val);
+    } else if (lgl->stats->prb.basic.failed > oldfailed ||
+               lgl->stats->prb.basic.lifted > oldlifted ||
+	       lgl->stats->hbr.cnt > oldhbr) {
+      oldfailed = lgl->stats->prb.basic.failed;
+      oldlifted = lgl->stats->prb.basic.lifted;
+      lglclnstk (&probes);
+      if (oldhbr < lgl->stats->hbr.cnt && lgl->opts->decompose.val)
+	if (!lgldecomp (lgl)) goto DONE;
+      oldhbr = lgl->stats->hbr.cnt;
+      round++;
+      goto RESTART;
+    } else {
+      assert (!remprobes);
+      lglprt (lgl, 1,
+	      "[basicprobe-%d-%d] fully completed probing",
+	      lgl->stats->prb.basic.count, round);
+      for (idx = 2; idx < lgl->nvars; idx++)
+	lglavar (lgl, idx)->donotbasicprobe = 0;
+    }
+  }
+DONE:
+  lglrelstk (lgl, &lift);
+  lglrelstk (lgl, &probes);
+  lglrelstk (lgl, &saved);
+
+  assert (lgl->stats->hbr.cnt >= orighbr);
+  assert (lglrem (lgl) <= oldrem);
+  deltarem = oldrem - lglrem (lgl);
+  deltahbr = lgl->stats->hbr.cnt - orighbr;
+  success = deltarem || deltahbr;
+  LGLUPDPEN (prb.basic, deltarem);
+  assert (lgl->stats->prb.basic.failed >= origfailed);
+  assert (lgl->stats->prb.basic.lifted >= origlifted);
+  failed = lgl->stats->prb.basic.failed - origfailed;
+  lifted = lgl->stats->prb.basic.lifted - origlifted;
+#ifndef NLGLOG
+  assert (lgl->stats->prb.basic.probed >= origprobed);
+  probed = lgl->stats->prb.basic.probed - origprobed;
+  LOG (1, "%ssuccessfully probed %d out of %d probes %.1f%%",
+       success ? "" : "un", probed, nprobes, lglpcnt (probed, nprobes));
+  LOG (1, "found %d failed %.1f%% lifted %d through probing",
+       failed, lglpcnt (failed, probed), lifted);
+#endif
+  assert (lgl->probing && lgl->simp && lgl->basicprobing);
+  lgl->simp = lgl->probing = lgl->basicprobing = 0;
+  units = failed + lifted;
+  lglprt (lgl, 1 + !units,
+    "[basicprobe-%d-%d] %d units = %d failed (%.0f%%) + %d lifted (%.0f%%)",
+    lgl->stats->prb.basic.count, round,
+    units, failed, lglpcnt (failed, units), lifted, lglpcnt (lifted, units));
+  lglprt (lgl, 1 + !success,
+    "[basicprobe-%d-%d] removed %d variables, found %d hbrs",
+    lgl->stats->prb.basic.count, round, deltarem, deltahbr);
+  lglrep (lgl, 2, 'p');
+  lglstop (lgl);
+  lglbasicatestats (lgl);
+  return !lgl->mt;
+}
+
+static int lglsmallirr (LGL * lgl) {
+  int maxirrlidx = lglcntstk (&lgl->irr), limit;
+  int64_t tmp = MAXREDLIDX;
+  tmp *= lgl->opts->smallirr.val;
+  tmp /= 100;
+  limit = (tmp < INT_MAX) ? tmp : INT_MAX;
+  if (maxirrlidx >= limit) return 0;
+  return  1;
+}
+
+static int lglprobe (LGL * lgl) {
+  int res = 1, mod = 0, all, small = lglsmallirr (lgl);
+  int (*prb[3])(LGL *);
+  lglstart (lgl, &lgl->times->probe);
+  if (small && lgl->opts->prbsimple.val) prb[mod++] = lglsimpleprobe;
+  if (small && lgl->opts->treelook.val) prb[mod++] = lgltreelook;
+  if (lgl->opts->prbasic.val) prb[mod++] = lglbasicprobe;
+  all = lgl->stats->prb.simple.count;
+  all += lgl->stats->prb.basic.count;
+  all += lgl->stats->prb.treelook.count;
+  if (lgl->stats->simp.count == 2) {
+    int i;
+    res = 1;
+    for (i = 0; res && i < mod; i++) res = prb[i] (lgl);
+  } else res = mod ? prb[all % mod] (lgl) : 1;
+  lglstop (lgl);
+  return res;
+}
+
+static void lglinitevars (LGL * lgl) {
+  EVar * ev;
+  int idx;
+  assert (lgl->occs);
+  NEW (lgl->evars, lgl->nvars);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    ev = lgl->evars + idx;
+    ev->pos = -1;
+  }
+}
+
+static void lgldense (LGL * lgl, int rmredbintrn) {
+  int lit, lidx, count, idx, other, other2, blit, sign, tag, red;
+  const int * start, * top, * c, * p, * eow;
+  int * q, * w;
+  EVar * ev;
+  HTS * hts;
+  LOG (1, "transition to dense mode");
+  assert (!lgl->dense);
+  assert (!lgl->rmredbintrn);
+  assert (!lgl->evars);
+  assert (lglsmallirr (lgl));
+  assert (lglmtstk (&lgl->esched));
+  assert (lglmtstk (&lgl->saved.bin));
+  assert (lglmtstk (&lgl->saved.trn));
+  assert (!lgl->eliminating || !lgl->elm->pivot);
+  lgl->stats->dense++;
+  if (rmredbintrn) {
+    lgl->rmredbintrn = 1;
+    LOG (1, "temporarily removing redundant binary and ternary clauses");
+  }
+  count = 0;
+  if (lgl->occs) lglinitevars (lgl);
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      if (!hts->count) continue;
+      q = w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	red = blit & REDCS;
+	if (red) {
+	   if (tag == LRGCS) continue;
+	   if (rmredbintrn) {
+	     assert (tag == BINCS || tag == TRNCS);
+	     other = blit >> RMSHFT;
+	     if (abs (other) < idx) continue;
+	     if (tag == TRNCS) {
+	       other2 = *p;
+	       if (abs (other2) < idx) continue;
+	       lglpushstk (lgl, &lgl->saved.trn, lit);
+	       lglpushstk (lgl, &lgl->saved.trn, other);
+	       lglpushstk (lgl, &lgl->saved.trn, other2);
+	       assert (lgl->stats->red.trn);
+	       lgl->stats->red.trn--;
+	     } else {
+	       lglpushstk (lgl, &lgl->saved.bin, lit);
+	       lglpushstk (lgl, &lgl->saved.bin, other);
+	       assert (lgl->stats->red.bin);
+	       lgl->stats->red.bin--;
+	     }
+	   } else {
+	     *q++ = blit;
+	     if (tag == TRNCS) *q++ = *p;
+	   }
+	} else {
+	  *q++ = blit;
+	  if (tag == LRGCS || tag == TRNCS) *q++ = *p;
+	  if (tag == LRGCS) continue;
+	  assert (tag == BINCS || tag == TRNCS);
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  if (tag == TRNCS) {
+	    other2 = *p;
+	    if (abs (other2) < idx) continue;
+	    lglincocc (lgl, other2), count++;
+	  }
+	  lglincocc (lgl, lit), count++;
+	  lglincocc (lgl, other), count++;
+	}
+      }
+      lglshrinkhts (lgl, hts, q - w);
+    }
+  lglfitstk (lgl, &lgl->saved.bin);
+  lglfitstk (lgl, &lgl->saved.trn);
+  if (count)
+    LOG (1, "counted %d occurrences in small irredundant clauses", count);
+  {
+    count = 0;
+    start = lgl->irr.start;
+    top = lgl->irr.top;
+    for (c = start; c < top; c = p + 1) {
+      p = c;
+      if (*c >= NOTALIT) continue;
+      lidx = c - start;
+      assert (0 <= lidx), assert (lidx < MAXIRRLIDX);
+      blit = (lidx << RMSHFT) | OCCS;
+      for (; (lit = *p); p++) {
+	hts = lglhts (lgl, lit);
+	lglpushwch (lgl, hts, blit);
+	lglincocc (lgl, lit), count++;
+      }
+    }
+  }
+  if (count)
+    LOG (1, "counted %d occurrences in large irredundant clauses", count);
+  count = 0;
+  if (lgl->occs) {
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      ev = lglevar (lgl, idx);
+      if (ev->pos >= 0) continue;
+      if (lglifrozen (lgl, idx)) continue;
+      if (lgl->donotsched) {
+	AVar * av = lglavar (lgl, idx);
+	if (lgl->eliminating && av->donotelm) continue;
+	if (lgl->blocking && av->donotblk) continue;
+      }
+      assert (!ev->occ[0] && !ev->occ[1]);
+      lglesched (lgl, idx);
+      count++;
+    }
+    if (count) LOG (1, "scheduled %d zombies", count);
+  }
+  LOG (1, "continuing in dense mode");
+  lgl->dense = 1;
+  lglfullyconnected (lgl);
+  if (lgl->occs && lgl->opts->verbose.val >= 1) {
+    const char * str;
+    int inst, vl;
+    count = 0;
+    if (lgl->eliminating) str = "elim", inst = lgl->stats->elm.count, vl = 1;
+    else if (lgl->blocking) str = "block", inst = lgl->stats->blk.count, vl=1;
+    else str = "dense", inst = lgl->stats->dense, vl = 2;
+    for (idx = 2; idx < lgl->nvars; idx++)
+      if (lglevar (lgl, idx)->pos >= 0) count++;
+    lglprt (lgl, vl,
+      "[%s-%d] scheduled %d variables %.0f%%",
+      str, inst, count, lglpcnt (count, lgl->nvars-2));
+  }
+}
+
+static void lglsparse (LGL * lgl) {
+  int idx, sign, lit, count, blit, tag;
+  int * w, *p, * eow, * q;
+  HTS * hts;
+  assert (!lgl->notfullyconnected);
+  assert (lgl->dense);
+  lgl->stats->sparse++;
+  count = 0;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      if (!hts->count) continue;
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = q = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == OCCS) { count++; continue; }
+	*q++ = blit;
+	if (tag == BINCS) continue;
+	assert (tag == LRGCS || tag == TRNCS);
+	assert (p + 1 < eow);
+	*q++ = *++p;
+      }
+      assert (hts->count - (p - q) == q - w);
+      lglshrinkhts (lgl, hts, q - w);
+    }
+  if (lgl->occs) {
+    DEL (lgl->evars, lgl->nvars);
+    lglrelstk (lgl, &lgl->esched);
+  }
+  LOG (1, "removed %d full irredundant occurrences", count);
+  lgl->dense = 0;
+  lgl->notfullyconnected = 1;
+  LOG (1, "large clauses not fully connected yet");
+}
+
+static int lglm2i (LGL * lgl, int mlit) {
+  int res, midx = abs (mlit);
+  assert (0 < midx);
+  res = lglpeek (&lgl->elm->m2i, midx);
+  if (mlit < 0) res = -res;
+  return res;
+}
+
+static int lgli2m (LGL * lgl, int ilit) {
+  AVar * av = lglavar (lgl, ilit);
+  int res = av->mark;
+  if (!res) {
+    res = lglcntstk (&lgl->seen) + 1;
+    av->mark = res;
+    assert (2*lglcntstk (&lgl->seen) == lglcntstk (&lgl->elm->noccs) - 2);
+    assert (2*lglcntstk (&lgl->seen) == lglcntstk (&lgl->elm->mark) - 2);
+    assert (2*lglcntstk (&lgl->seen) == lglcntstk (&lgl->elm->occs) - 2);
+    assert (lglcntstk (&lgl->seen) == lglcntstk (&lgl->elm->m2i) - 1);
+    lglpushstk (lgl, &lgl->seen, abs (ilit));
+    lglpushstk (lgl, &lgl->elm->noccs, 0);
+    lglpushstk (lgl, &lgl->elm->noccs, 0);
+    lglpushstk (lgl, &lgl->elm->mark, 0);
+    lglpushstk (lgl, &lgl->elm->mark, 0);
+    lglpushstk (lgl, &lgl->elm->occs, 0);
+    lglpushstk (lgl, &lgl->elm->occs, 0);
+    lglpushstk (lgl, &lgl->elm->m2i, abs (ilit));
+    LOG (4, "mapped internal variable %d to marked variable %d",
+	 abs (ilit), res);
+  }
+  if (ilit < 0) res = -res;
+  return res;
+}
+
+static unsigned lglsig (int lit) {
+  unsigned ulit = lglulit (lit), res;
+  assert (ulit >= 2);
+  ulit -= 2;
+  res = (1u << (ulit & 31));
+  return res;
+}
+
+static void lgladdecl (LGL * lgl, const int * c) {
+  int ilit, mlit, umlit, size = 0, next, prev;
+  unsigned csig = 0;
+  const int * p;
+  Val val;
+#if !defined (NDEBUG) || !defined (NLGLOG)
+  int lidx;
+#endif
+  LOGCLS (3, c, "copying irredundant clause");
+  INCSTEPS (elm.copies);
+  size = 0;
+  for (p = c; (ilit = *p); p++) {
+    val = lglval (lgl, ilit);
+    assert (val <= 0);
+    if (val < 0) continue;
+    size++;
+    if (abs (ilit) == lgl->elm->pivot) continue;
+    mlit = lgli2m (lgl, ilit);
+    assert (abs (mlit) != 1);
+    csig |= lglsig (mlit);
+  }
+  assert (size >= 1);
+  next = lglcntstk (&lgl->elm->lits);
+#if !defined (NDEBUG) || !defined (NLGLOG)
+  lidx = next;
+#endif
+  assert (next > 0);
+  for (p = c; (ilit = *p); p++) {
+    val = lglval (lgl, ilit);
+    if (val < 0) continue;
+    mlit = lgli2m (lgl, ilit);
+    lglpushstk (lgl, &lgl->elm->lits, mlit);
+    umlit = lglulit (mlit);
+    prev = lglpeek (&lgl->elm->occs, umlit);
+    lglpushstk (lgl, &lgl->elm->next, prev);
+    lglpoke (&lgl->elm->occs, umlit, next++);
+    lglpushstk (lgl, &lgl->elm->csigs, csig);
+    lglpushstk (lgl, &lgl->elm->sizes, size);
+    lgl->elm->noccs.start[umlit]++;
+  }
+  lglpushstk (lgl, &lgl->elm->lits, 0);
+  lglpushstk (lgl, &lgl->elm->next, 0);
+  lglpushstk (lgl, &lgl->elm->csigs, 0);
+  lglpushstk (lgl, &lgl->elm->sizes, 0);
+  lgl->elm->necls++;
+  LOGCLS (4, lgl->elm->lits.start + lidx, "copied and mapped clause");
+#ifndef NDEBUG
+  LOGMCLS (4, lgl->elm->lits.start + lidx, "copied and remapped clause");
+  {
+    int i, j = 0;
+    for (i = 0; c[i]; i++) {
+      Val val = lglval (lgl, c[i]);
+      assert (val <= 0);
+      if (val < 0) continue;
+      assert (c[i] == lglm2i (lgl, lglpeek (&lgl->elm->lits, lidx + j++)));
+    }
+  }
+#endif
+}
+
+static int lglecls (LGL * lgl, int lit) {
+  int blit, tag, red, other, lidx, count;
+  const int * p, * w, * eow, * c;
+  int d[4];
+  HTS * hts;
+  LOG (3, "copying irredundant clauses with %d", lit);
+  count = 0;
+  hts = lglhts (lgl, lit);
+  if (!hts->count) return 0;
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    if (tag == BINCS || tag == TRNCS) {
+      d[0] = lit;
+      other = blit >> RMSHFT;
+      d[1] = other;
+      if (tag == TRNCS) d[2] = *p, d[3] = 0;
+      else d[2] = 0;
+      c = d;
+    } else {
+      assert (tag == OCCS);
+      lidx = (tag == OCCS) ? (blit >> RMSHFT) : *p;
+      c = lglidx2lits (lgl, 0, lidx);
+    }
+    lgladdecl (lgl, c);
+    count++;
+  }
+  return count;
+}
+
+static void lglrstecls (LGL * lgl)  {
+  assert (lgl->elm->pivot);
+  lglclnstk (&lgl->elm->lits);
+  lglclnstk (&lgl->elm->next);
+  lglclnstk (&lgl->elm->csigs);
+  lglclnstk (&lgl->elm->sizes);
+  lglclnstk (&lgl->elm->occs);
+  lglclnstk (&lgl->elm->noccs);
+  lglclnstk (&lgl->elm->mark);
+  lglclnstk (&lgl->elm->m2i);
+  lglpopnunmarkstk (lgl, &lgl->seen);
+  lgl->elm->pivot = 0;
+}
+
+static void lglrelecls (LGL * lgl)  {
+  lglrelstk (lgl, &lgl->elm->lits);
+  lglrelstk (lgl, &lgl->elm->next);
+  lglrelstk (lgl, &lgl->elm->csigs);
+  lglrelstk (lgl, &lgl->elm->sizes);
+  lglrelstk (lgl, &lgl->elm->occs);
+  lglrelstk (lgl, &lgl->elm->noccs);
+  lglrelstk (lgl, &lgl->elm->mark);
+  lglrelstk (lgl, &lgl->elm->m2i);
+  lglrelstk (lgl, &lgl->elm->clv);
+}
+
+static void lglinitecls (LGL * lgl, int idx) {
+#ifndef NLGLOG
+  int clauses;
+#endif
+  assert (!lgl->elm->pivot);
+  assert (idx >= 2);
+  assert (lglmtstk (&lgl->elm->lits));
+  assert (lglmtstk (&lgl->elm->next));
+  assert (lglmtstk (&lgl->elm->csigs));
+  assert (lglmtstk (&lgl->elm->sizes));
+  assert (lglmtstk (&lgl->elm->occs));
+  assert (lglmtstk (&lgl->elm->noccs));
+  assert (lglmtstk (&lgl->elm->m2i));
+  assert (lglmtstk (&lgl->seen));
+  lgl->elm->pivot = idx;
+  lglpushstk (lgl, &lgl->elm->mark, 0);
+  lglpushstk (lgl, &lgl->elm->mark, 0);
+  lglpushstk (lgl, &lgl->elm->occs, 0);
+  lglpushstk (lgl, &lgl->elm->occs, 0);
+  lglpushstk (lgl, &lgl->elm->noccs, 0);
+  lglpushstk (lgl, &lgl->elm->noccs, 0);
+  lglpushstk (lgl, &lgl->elm->m2i, 0);
+  (void) lgli2m (lgl, idx);
+  lglpushstk (lgl, &lgl->elm->lits, 0);
+  lglpushstk (lgl, &lgl->elm->next, 0);
+  lglpushstk (lgl, &lgl->elm->csigs, 0);
+  lglpushstk (lgl, &lgl->elm->sizes, 0);
+  lgl->elm->necls = 0;
+#ifndef NLGLOG
+  clauses =
+#endif
+  lglecls (lgl, idx);
+  lgl->elm->negcls = lgl->elm->necls;
+  lgl->elm->neglidx = lglcntstk (&lgl->elm->lits);
+#ifndef NLGLOG
+  clauses +=
+#endif
+  lglecls (lgl, -idx);
+  LOG (2, "found %d variables in %d clauses with %d or %d",
+       lglcntstk (&lgl->seen), clauses, idx, -idx);
+  assert (lgl->elm->pivot);
+}
+
+static void lglelrmcls (LGL * lgl, int lit, int * c, int clidx) {
+  int lidx, i, other, ulit, * lits, * csigs, blit, tag, red, other2;
+  int * p, * eow, * w, count;
+  HTS * hts;
+#ifndef NDEBUG
+  int size;
+#endif
+  lits = lgl->elm->lits.start;
+  csigs = lgl->elm->csigs.start;
+  assert (lits < c && c < lgl->elm->lits.top - 1);
+  lidx = c - lits;
+  LOGCLS (2, c, "removing clause");
+  for (i = lidx; (other = lits[i]); i++) {
+    assert (other < NOTALIT);
+    lits[i] = REMOVED;
+    csigs[i] = 0;
+    ulit = lglulit (other);
+    assert (ulit < lglcntstk (&lgl->elm->noccs));
+    assert (lgl->elm->noccs.start[ulit] > 0);
+    lgl->elm->noccs.start[ulit] -= 1;
+  }
+#ifndef NDEBUG
+  size = lglpeek (&lgl->elm->sizes, lidx);
+#endif
+  hts = lglhts (lgl, lit);
+  assert (hts->count > 0 && hts->count >= clidx);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  blit = tag = count = 0;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    if (count == clidx) break;
+    count++;
+  }
+  assert (count == clidx);
+  assert (blit && tag);
+  assert (p < eow);
+  if (tag == BINCS) {
+    assert (size >= 2);
+    other = blit >> RMSHFT;
+    lglrmbcls (lgl, lit, other, 0);
+    lgldrupligdelclsarg (lgl, lit, other, 0);
+  } else if (tag == TRNCS) {
+    other = blit >> RMSHFT;
+    other2 = *p;
+    lgldrupligdelclsarg (lgl, lit, other, other2, 0);
+    lglrmtcls (lgl, lit, other, other2, 0);
+  } else {
+    assert (tag == OCCS);
+    lidx = (tag == OCCS) ? (blit >> RMSHFT) : *p;
+#ifndef NDEBUG
+    {
+      int * q, * d = lglidx2lits (lgl, 0, lidx);
+      for (q = d; *q; q++)
+	;
+      assert (q - d >= size);
+    }
+#endif
+    lgldrupligdelclsaux (lgl, lglidx2lits (lgl, 0, lidx));
+    lglrmlcls (lgl, lidx, 0);
+  }
+}
+
+#define BWL 2
+
+static int lglbacksub (LGL * lgl, int * c, int str,
+                       int ** dptr, int * dlidxptr) {
+  int * start = lgl->elm->lits.start, * p, * q, marked = 0, res, * d;
+  int lit, ulit, occ, next, osize, other, uolit, size, plit, phase, clidx;
+  unsigned ocsig, csig = 0, masksig;
+#ifndef NLGLOG
+  const char * mode = str ? "strengthening" : "subsumption";
+#endif
+  LOGMCLS (BWL + 1, c, "backward %s check for clause", mode);
+  LOGCLS (BWL + 1, c, "backward %s check for mapped clause", mode);
+  phase = (c - start) >= lgl->elm->neglidx;
+  for (p = c; (lit = *p); p++)
+    if (abs (lit) != 1)
+      csig |= lglsig (lit);
+  size = p - c;
+  assert (csig == lglpeek (&lgl->elm->csigs, c - start));
+  assert (size == lglpeek (&lgl->elm->sizes, c - start));
+  res = 0;
+  if (dptr) *dptr = 0;
+  if (dlidxptr) *dlidxptr = 0;
+
+  if (str) phase = !phase;
+  lit = phase ? -1 : 1;
+  masksig = ~(lglsig (-lit) | lglsig (lit));
+
+  ulit = lglulit (lit);
+  occ = lglpeek (&lgl->elm->noccs, ulit);
+  if (!str && occ <= 1) return 0;
+  if (str && !occ) return 0;
+  if (occ > lgl->elm->bkwdocclim) return 0;
+  for (next = lglpeek (&lgl->elm->occs, ulit);
+       !res && next &&
+	 lgl->limits->elm.steps > lgl->stats->elm.steps;
+       next = lglpeek (&lgl->elm->next, next)) {
+      INCSTEPS (elm.steps);
+      if (next == p - start) continue;
+      if (phase != (next >= lgl->elm->neglidx)) continue;
+      plit = lglpeek (&lgl->elm->lits, next);
+      if (plit >= NOTALIT) continue;
+      assert (plit == lit);
+      osize = lglpeek (&lgl->elm->sizes, next);
+      INCSTEPS (elm.steps);
+      if (osize > size) continue;
+      ocsig = lglpeek (&lgl->elm->csigs, next);
+      INCSTEPS (elm.steps);
+      assert (ocsig);
+      ocsig &= masksig;
+      if ((ocsig & ~csig)) continue;
+      if (!marked) {
+	for (q = c; (other = *q); q++) {
+	  if (str && abs (other) == 1) other = -other;
+	  uolit = lglulit (other);
+	  assert (!lglpeek (&lgl->elm->mark, uolit));
+	  lglpoke (&lgl->elm->mark, uolit, 1);
+	}
+	marked = 1;
+        ADDSTEPS (elm.steps, q-c);
+      }
+      d = lgl->elm->lits.start + next;
+      if (c <= d && d < c + size) continue;
+      if (str) lgl->stats->elm.strchks++; else lgl->stats->elm.subchks++;
+      while (d[-1]) d--;
+      assert (c != d);
+      LOGMCLS (BWL + 1, d, "backward %s check with clause", mode);
+      res = 1;
+      for (q = d; res && (other = *q); q++) {
+	uolit = lglulit (other);
+	res = lglpeek (&lgl->elm->mark, uolit);
+      }
+      ADDSTEPS (elm.steps, q-d);
+      if (!res || !str || osize < size) continue;
+      ADDSTEPS (elm.steps, q-d);
+      LOGMCLS (BWL, d,
+        "static double strengthened by double self-subsuming resolution");
+      q = lgl->elm->lits.start;
+      if (phase) {
+        assert ((c - start) < lgl->elm->neglidx);
+        assert ((d - start) >= lgl->elm->neglidx);
+	q += lgl->elm->neglidx;
+      } else {
+        assert (!phase);
+        assert ((d - start) < lgl->elm->neglidx);
+        assert ((c - start) >= lgl->elm->neglidx);
+	assert (!lglpeek (&lgl->elm->lits, 0));
+	q++;
+      }
+      clidx = 0;
+      while (q < d) {
+	other = *q++;
+	if (other >= NOTALIT) {
+	  while (*q++)
+	    ;
+	  continue;
+	}
+	if (!other) clidx++;
+      }
+      LOGMCLS (BWL, d,
+	"strengthened and subsumed original irredundant clause");
+      LOGCLS (BWL, d,
+        "strengthened and subsumed mapped irredundant clause");
+      *dptr = d, *dlidxptr = clidx;
+      assert (res);
+  }
+  if (marked) {
+    for (p = c; (lit = *p); p++) {
+      if (str && abs (lit) == 1) lit = -lit;
+      ulit = lglulit (lit);
+      assert (lglpeek (&lgl->elm->mark, ulit));
+      lglpoke (&lgl->elm->mark, ulit, 0);
+    }
+    ADDSTEPS (elm.steps, p-c);
+  }
+  return res;
+}
+
+static void lglelmsub (LGL * lgl) {
+  int clidx, count, subsumed, pivot, * c;
+  if (!lgl->opts->elmotfsub.val) return;
+  count = clidx = subsumed = 0;
+  pivot = lgl->elm->pivot;
+  for (c = lgl->elm->lits.start + 1;
+       c < lgl->elm->lits.top &&
+	 lgl->limits->elm.steps > lgl->stats->elm.steps;
+       c++) {
+    INCSTEPS (elm.steps);
+    if (count++ == lgl->elm->negcls) clidx = 0, pivot = -pivot;
+    if (lglbacksub (lgl, c, 0, 0, 0)) {
+      subsumed++;
+      lgl->stats->elm.sub++;
+      LOGMCLS (BWL, c, "subsumed original irredundant clause");
+      LOGCLS (3, c, "subsumed mapped irredundant clause");
+      lglelrmcls (lgl, pivot, c, clidx);
+    } else clidx++;
+    while (*c) c++;
+  }
+  LOG (BWL + !subsumed,
+    "subsumed %d clauses containing %d or %d",
+    subsumed, lgl->elm->pivot, -lgl->elm->pivot);
+}
+
+static int lglelmstr (LGL * lgl) {
+  int clidx, count, strengthened, pivot, * c, * p, mlit, ilit, res, found;
+  int * d, dlidx;
+  int size;
+  if (!lgl->opts->elmotfstr.val) return 0;
+  count = clidx = strengthened = 0;
+  pivot = lgl->elm->pivot;
+  res = 0;
+  LOG (3, "strengthening with pivot %d", pivot);
+  for (c = lgl->elm->lits.start + 1;
+       c < lgl->elm->lits.top &&
+	 lgl->limits->elm.steps > lgl->stats->elm.steps;
+       c++) {
+    INCSTEPS (elm.steps);
+    if (count++ == lgl->elm->negcls) {
+      clidx = 0, pivot = -pivot;
+      LOG (3, "strengthening with pivot %d", pivot);
+    }
+    if (*c == REMOVED) {
+      while (*c) { assert (*c == REMOVED); c++; }
+      continue;
+    }
+    if (lglbacksub (lgl, c, 1, &d, &dlidx)) {
+      strengthened++;
+      lgl->stats->elm.str++;
+      LOGMCLS (2, c, "strengthening original irredundant clause");
+      LOGCLS (3, c, "strengthening mapped irredundant clause");
+      assert (lglmtstk (&lgl->clause));
+      found = 0;
+      size = 0;
+      for (p = c; (mlit = *p); p++) {
+	ilit = lglm2i (lgl, *p);
+	if (ilit == pivot) { found++; continue; }
+	assert (!lglval (lgl, ilit));
+	lglpushstk (lgl, &lgl->clause, ilit);
+	size++;
+      }
+      assert (found);
+      lglpushstk (lgl, &lgl->clause, 0);
+      LOGCLS (2, lgl->clause.start, "static strengthened irredundant clause");
+      lgldrupligaddcls (lgl, REDCS);
+      if (d) lglelrmcls (lgl, -pivot, d, dlidx);
+      lglelrmcls (lgl, pivot, c, clidx);
+      lgladdcls (lgl, 0, 0, 1);
+      lglclnstk (&lgl->clause);
+      if (size == 1) { res = 1; break; }
+    } else clidx++;
+    while (*c) c++;
+  }
+  LOG (2, "strengthened %d clauses containing %d or %d",
+       strengthened, lgl->elm->pivot, -lgl->elm->pivot);
+  return res;
+}
+
+static int lglflushclauses (LGL * lgl, int lit) {
+  int blit, tag, red, other, other2, count, glue, res;
+  const int druplig = lgl->opts->druplig.val;
+  const int * p, * w, * eow;
+  int lidx, glidx, slidx;
+  int * c, * q;
+  HTS * hts;
+  Stk * s;
+#ifndef NDEBUG
+  int occs;
+#endif
+  lglchkirrstats (lgl);
+  assert (lgl->probing || lgl->lkhd || lgl->dense);
+  hts = lglhts (lgl, lit);
+  if (!hts->count) return 0;
+#ifndef NDEBUG
+  occs = lgl->occs ? lglocc (lgl, lit) : 0;
+#endif
+  res = 0;
+  LOG (2, "flushing clauses with literal %d", lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  count = 0;
+  for (p = w; p < eow; p++) {
+    if (lgl->blocking) INCSTEPS (blk.steps);
+    if (lgl->eliminating) INCSTEPS (elm.steps);
+    if (lgl->simpleprobing) INCSTEPS (prb.simple.steps);
+    blit = *p;
+    tag = blit & MASKCS;
+    red = blit & REDCS;
+    other = blit >> RMSHFT;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == BINCS) {
+      lglrmbwch (lgl, other, lit, red);
+      LOG (2, "flushed %s binary clause %d %d", lglred2str (red), lit, other);
+      if (druplig) lgldrupligdelclsarg (lgl, lit, other, 0);
+      lgldeclscnt (lgl, 2, red, 0);
+      if (!red) lgldecocc (lgl, lit), lgldecocc (lgl, other), res++;
+      count++;
+    } else if (tag == TRNCS) {
+      other2 = *p;
+      lglrmtwch (lgl, other2, lit, other, red);
+      lglrmtwch (lgl, other, lit, other2, red);
+      LOG (2, "flushed %s ternary clause %d %d %d",
+	   lglred2str (red), lit, other, other2);
+      if (druplig) lgldrupligdelclsarg (lgl, lit, other, other2, 0);
+      lgldeclscnt (lgl, 3, red, 0);
+      if (!red)  {
+	lgldecocc (lgl, lit);
+	lgldecocc (lgl, other);
+	lgldecocc (lgl, other2);
+	res++;
+      }
+      count++;
+    } else {
+      assert (tag == OCCS || tag == LRGCS);
+      if (tag == LRGCS) {
+	lidx = *p;
+	s = lglidx2stk (lgl, red, lidx);
+	if (red) {
+	  glue = lidx & GLUEMASK;
+	  c = s->start + (lidx >> GLUESHFT);
+	} else {
+	  glue = 0;
+	  c = s->start + lidx;
+	}
+      } else {
+	lidx = (blit >> RMSHFT);
+	s = &lgl->irr;
+	c = s->start + lidx;
+	glue = 0;
+      }
+      if (c >= s->top || (other = c[0]) >= NOTALIT) continue;
+      LOGCLS (2, c, "flushed %s large clause", lglred2str (red));
+      if (druplig) lgldrupligdelclsaux (lgl, c);
+      if (tag == LRGCS) {
+	if (other == lit) other = c[1];
+	assert (abs (other) != abs (lit));
+	lglrmlwch (lgl, other, red, lidx);
+      } else {
+	glidx = lidx;
+	if (red) glidx <<= GLUESHFT;
+	if (c[1] != lit) lglrmlwch (lgl, c[1], red, glidx);
+	if (other != lit) lglrmlwch (lgl, other, red, glidx);
+      }
+      if (red) {
+	assert (!glue);
+	LGLCHKACT (c[-1]);
+	c[-1] = REMOVED;
+      } else lgldecocc (lgl, lit);
+      for (q = c; (other = *q); q++) {
+	assert (other < NOTALIT);
+	*q = REMOVED;
+	if (other == lit) continue;
+	if (red && glue) continue;
+	slidx = lidx;
+	if (red && tag == LRGCS) slidx >>= GLUESHFT;
+	lglrmlocc (lgl, other, red, slidx);
+	if (!red) lgldecocc (lgl, other);
+      }
+      *q = REMOVED;
+      lgldeclscnt (lgl, q - c, red, glue);
+      lgltrimlitstk (lgl, red, lidx);
+      if (!red) res++;
+      count++;
+    }
+  }
+#ifndef NDEBUG
+  if (lgl->occs) assert (occs == res);
+#endif
+  lglshrinkhts (lgl, hts, 0);
+  LOG (2, "flushed %d clauses with %d including %d irredundant",
+       count, lit, res);
+  lglchkirrstats (lgl);
+  return res;
+}
+
+static int lglflushlits (LGL * lgl, int lit) {
+  int blit, tag, red, other, other2, size, satisfied, d[3], glue;
+  const int druplig = lgl->opts->druplig.val;
+  int * p, * w, * eow, * c, * l, * k;
+  int lidx, slidx, glidx;
+  int count, res;
+  Val val, val2;
+  ptrdiff_t delta;
+  Stk saved;
+  Stk * s;
+
+#define FIXPTRS() do { p += delta, w += delta, eow += delta; } while (0)
+
+  HTS * hts;
+  LOG (2, "flushing literal %d from clauses", lit);
+  assert (!lgl->level);
+  assert (lglifixed (lgl, lit) < 0);
+  assert (lgl->dense);
+  lglchkirrstats (lgl);
+  hts = lglhts (lgl, lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  res = count = 0;
+  CLR (saved);
+  for (p = w; p < eow; p++) {
+    if (lgl->blocking) INCSTEPS (blk.steps);
+    if (lgl->eliminating) INCSTEPS (elm.steps);
+    if (lgl->simpleprobing) INCSTEPS (prb.simple.steps);
+    count++;
+    blit = *p;
+    tag = blit & MASKCS;
+    red = blit & REDCS;
+    if (tag == BINCS) {
+      other = blit >> RMSHFT;
+      assert ((red && lgliselim (lgl, other)) || lglval (lgl, other) > 0);
+      lglrmbwch (lgl, other, lit, red);
+      LOG (2, "flushed %s binary clause %d %d", lglred2str (red), lit, other);
+      if (druplig) lgldrupligdelclsarg (lgl, lit, other, 0);
+      lgldeclscnt (lgl, 2, red, 0);
+      if (!red) {
+	if (lgl->dense) lgldecocc (lgl, lit), lgldecocc (lgl, other);
+	res++;
+      }
+    } else if (tag == TRNCS) {
+      other = blit >> RMSHFT;
+      other2 = *++p;
+      lglrmtwch (lgl, other2, lit, other, red);
+      lglrmtwch (lgl, other, lit, other2, red);
+      LOG (2, "flushed %s ternary clause %d %d %d",
+	   lglred2str (red), lit, other, other2);
+      lgldeclscnt (lgl, 3, red, 0);
+      if (!red)  {
+	if (lgl->dense) {
+	  lgldecocc (lgl, lit);
+	  lgldecocc (lgl, other);
+	  lgldecocc (lgl, other2);
+	}
+	res++;
+      }
+      val = lglval (lgl, other);
+      val2 = lglval (lgl, other2);
+      if (!val && !val2) {
+	LOG (2,
+  "reducing flushed %s ternary clause %d %d %d to binary %s clause %d %d",
+	     lglred2str (red),
+	     lit, other, other2,
+	     lglred2str (red),
+	     other, other2);
+	delta = lglwchbin (lgl, other, other2, red);
+	delta += lglwchbin (lgl, other2, other, red);
+	if (lgl->simpleprobing && lgl->opts->prbsimple.val >= 2)
+	  lglwrktouch (lgl, -other), lglwrktouch (lgl, -other2);
+	if (delta) FIXPTRS ();
+	if (red) {
+	  lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+	} else {
+	  lglincirr (lgl, 2);
+	  if (lgl->dense) lglincocc (lgl, other), lglincocc (lgl, other2);
+	}
+	if (druplig) lgldrupligaddclsarg (lgl, REDCS, other, other2, 0);
+      } else {
+#ifndef NDEBUG
+	if (!red || (!lgliselim (lgl, other) && !lgliselim (lgl, other2)))
+	  assert (val > 0 || val2 > 0);
+#endif
+      }
+      if (druplig) lgldrupligdelclsarg (lgl, lit, other, other2, 0);
+    } else {
+      assert (tag == OCCS || tag == LRGCS);
+      lidx = (tag == LRGCS) ? *++p : (blit >> RMSHFT);
+      s = lglidx2stk (lgl, red, lidx);
+      c = s->start + (red ? (lidx >> GLUESHFT) : lidx);
+      if (c >= s->top || c[0] >= NOTALIT) continue;
+      size = satisfied = 0;
+      assert (lglmtstk (&saved));
+      for (l = c; (other = *l); l++) {
+	if (druplig) lglpushstk (lgl, &saved, other);
+	if (satisfied) continue;
+	if (other == lit) continue;
+	if ((val = lglval (lgl, other)) < 0) continue;
+	if (val > 0) { satisfied = 1; continue; }
+	if (size < 3) d[size] = other;
+	size++;
+      }
+      if (!satisfied && size == 2) {
+	LOGCLS (2, c,
+	  "reducing to binary %s clause %d %d flushed large %s clause",
+	     lglred2str (red), d[0], d[1], lglred2str (red));
+	delta = lglwchbin (lgl, d[0], d[1], red);
+	delta += lglwchbin (lgl, d[1], d[0], red);
+	if (delta) FIXPTRS ();
+	if (red) {
+	  lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+	} else {
+	  lglincirr (lgl, 2);
+	  if (lgl->dense) lglincocc (lgl, d[0]), lglincocc (lgl, d[1]);
+	}
+	if (lgl->simpleprobing && lgl->opts->prbsimple.val >= 2)
+	  lglwrktouch (lgl, -d[0]), lglwrktouch (lgl, -d[1]);
+	if (druplig) lgldrupligaddclsarg (lgl, REDCS, d[0], d[1], 0);
+      }
+      if (!satisfied && size == 3) {
+	LOGCLS (2, c,
+	  "reducing to ternary %s clause %d %d %d flushed large %s clause",
+	     lglred2str (red), d[0], d[1], d[2], lglred2str (red));
+	delta = lglwchtrn (lgl, d[0], d[1], d[2], red);
+	delta += lglwchtrn (lgl, d[1], d[0], d[2], red);
+	delta += lglwchtrn (lgl, d[2], d[0], d[1], red);
+	if (delta) FIXPTRS ();
+	if (red) {
+	  lgl->stats->red.trn++, assert (lgl->stats->red.trn > 0);
+	} else {
+	  lglincirr (lgl, 3);
+	  if (lgl->dense) {
+	    lglincocc (lgl, d[0]);
+	    lglincocc (lgl, d[1]);
+	    lglincocc (lgl, d[2]);
+	  }
+	}
+	if (lgl->simpleprobing && lgl->opts->prbsimple.val >= 3)
+	  lglwrktouch (lgl, d[0]),
+	  lglwrktouch (lgl, d[1]),
+	  lglwrktouch (lgl, d[2]); 
+	if (druplig) lgldrupligaddclsarg (lgl, REDCS, d[0], d[1], d[2], 0);
+      }
+      if (lgl->dense && !red) {
+	for (l = c; (other = *l); l++) {
+	  if (satisfied || size <= 3 || lglval (lgl, other) < 0) {
+	    if (!red) lgldecocc (lgl, other);
+	    if (other != lit) {
+	      slidx = lidx;
+	      if (red && tag == LRGCS) slidx >>= GLUESHFT;
+	      lglrmlocc (lgl, other, red, slidx);
+	    }
+	  }
+	}
+      }
+      glidx = lidx;
+      if (red && tag == OCCS) glidx <<= GLUESHFT;
+      if (c[0] != lit) lglrmlwch (lgl, c[0], red, glidx);
+      if (c[1] != lit) lglrmlwch (lgl, c[1], red, glidx);
+      if (satisfied || size <= 3) {
+	if (red) { LGLCHKACT (c[-1]); c[-1] = REMOVED; }
+	for (k = c; (other = *k); k++) *k = REMOVED;
+	*k = REMOVED;
+	if (red) {
+	  glue = (tag == LRGCS) ? (lidx & GLUEMASK) : 0;
+	  assert (lgl->stats->lir[glue].clauses > 0);
+	  lgl->stats->lir[glue].clauses--;
+	  assert (lgl->stats->red.lrg > 0);
+	  lgl->stats->red.lrg--;
+	} else lgldecirr (lgl, k - c);
+      } else {
+	for (l = k = c; (other = *l); l++) {
+	  if ((val = lglval (lgl, other)) < 0) continue;
+	  if (lgl->simpleprobing && lgl->opts->prbsimple.val >= 3)
+	    lglwrktouch (lgl, other);
+	  assert (abs (other) != abs (lit));
+	  assert (!val);
+	  *k++ = other;
+	}
+	assert (size == k - c);
+	if (!red && k < l) {
+	  assert (lgl->stats->irr.lits.cur >= l - k);
+	  lgl->stats->irr.lits.cur -= l - k;
+	}
+	*k++ = 0;
+	while (k <= l) *k++ = REMOVED;
+	delta = lglwchlrg (lgl, c[0], c[1], red, glidx);
+	delta += lglwchlrg (lgl, c[1], c[0], red, glidx);
+	if (delta) FIXPTRS ();
+	if (druplig) lgldrupligaddclsaux (lgl, REDCS, c);
+      }
+      lgltrimlitstk (lgl, red, lidx);
+      if (druplig) {
+	assert (lglcntstk (&saved) >= 4);
+	lglpushstk (lgl, &saved, 0);
+	lgldrupligdelclsaux (lgl, saved.start);
+	lglclnstk (&saved);
+      }
+    }
+  }
+  lglrelstk (lgl, &saved);
+  hts = lglhts (lgl, lit);
+  lglshrinkhts (lgl, hts, 0);
+  LOG (2, "flushed %d occurrences of literal %d including %d irredundant",
+       count, lit, res);
+  lglchkirrstats (lgl);
+  return res;
+
+#undef FIXPTRS
+
+}
+
+static int lglflushed (LGL * lgl) {
+  assert (lgl->flushed <= lglcntstk (&lgl->trail));
+  return lgl->flushed == lglcntstk (&lgl->trail);
+}
+
+static int lglflush (LGL * lgl) {
+  int lit, count;
+  if (lgl->mt) return 0;
+  lglchkirrstats (lgl);
+  assert (!lgl->level);
+  assert (lgl->probing || lgl->lkhd || lgl->dense);
+  if (lglflushed (lgl)) return 1;
+  if (!lglbcp (lgl)) { lglmt (lgl); return 0; }
+  if (!lglsyncunits (lgl)) { assert (lgl->mt); return 0; }
+  count = 0;
+  while  (lgl->flushed < lglcntstk (&lgl->trail)) {
+    lit = lglpeek (&lgl->trail, lgl->flushed++);
+    lglflushclauses (lgl, lit);
+    lglflushlits (lgl, -lit);
+    count++;
+  }
+  LOG (2, "flushed %d literals", count);
+  assert (!lgl->mt);
+  return 1;
+}
+
+static void lglblockinglit (LGL * lgl, int ilit) {
+  int elit = lglexport (lgl, ilit), sgnbit = (1 << (elit < 0));
+  Ext * ext = lglelit2ext (lgl, elit);
+  assert (!ext->equiv);
+  assert (!ext->eliminated);
+  assert (abs (ext->repr) == abs (ilit));
+  if (ext->blocking & sgnbit) return;
+  ext->blocking |= sgnbit;
+  LOG (3, "marking external %d internal %d as blocking", elit, ilit);
+  lgl->stats->blk.lits++;
+}
+
+static void lglelmfrelit (LGL * lgl, int mpivot,
+			  int * sop, int * eop, int * son, int * eon) {
+  int ipivot = mpivot * lgl->elm->pivot, clidx, ilit, tmp, cover, maxcover;
+  int * c, * d, * p, * q, lit, nontrivial, idx, sgn, clen, reslen;
+  assert (mpivot == 1 || mpivot == -1);
+  assert (ipivot);
+  LOG (3,
+       "blocked clause elimination and forced resolution of clauses with %d",
+	ipivot);
+  clidx = 0;
+  cover = lglpeek (&lgl->elm->noccs, lglulit (-mpivot));
+  for (c = sop; c < eop; c = p + 1) {
+    if (lgl->eliminating) INCSTEPS (elm.steps);
+    if (*c == REMOVED) {
+      for (p = c + 1; *p; p++)
+	;
+      continue;
+    }
+    maxcover = 0;
+    for (p = c; (lit = *p); p++) {
+      if (lit == mpivot) continue;
+      assert (lit != -mpivot);
+      maxcover += lglpeek (&lgl->elm->noccs, lglulit (-lit));
+    }
+    if (maxcover < cover - 1) { clidx++; continue; }
+    for (p = c; (lit = *p); p++) {
+      if (lit == mpivot) continue;
+      assert (lit != -mpivot);
+      idx = abs (lit);
+      assert (!lglpeek (&lgl->elm->mark, idx));
+      sgn = lglsgn (lit);
+      lglpoke (&lgl->elm->mark, idx, sgn);
+    }
+    nontrivial = 0;
+    clen = p - c;
+    for (d = son; !nontrivial && d < eon; d = q + 1) {
+      INCSTEPS (elm.steps);
+      if (*d == REMOVED) {
+	for (q = d + 1; *q; q++)
+	  ;
+	continue;
+      }
+      INCSTEPS (elm.resolutions);
+      LOGMCLS (3, c, "trying forced resolution 1st antecedent");
+      LOGMCLS (3, d, "trying forced resolution 2nd antecedent");
+      assert (clen > 0);
+      reslen = clen - 1;
+      for (q = d; (lit = *q); q++) {
+	if (lit == -mpivot) continue;
+	assert (lit != mpivot);
+	idx = abs (lit), sgn = lglsgn (lit);
+	tmp = lglpeek (&lgl->elm->mark, idx);
+	if (tmp == -sgn) break;
+	if (tmp != sgn) reslen++;
+      }
+      if (lit) {
+	while (*++q) ;
+	LOG (3, "trying forced resolution ends with trivial resolvent");
+      } else {
+	LOG (3, "non trivial resolvent in blocked clause elimination");
+	nontrivial = INT_MAX;
+      }
+    }
+    for (p = c; (lit = *p); p++) {
+      if (lit == mpivot) continue;
+      assert (lit != -mpivot);
+      idx = abs (lit);
+      assert (lglpeek (&lgl->elm->mark, idx) == lglsgn (lit));
+      lglpoke (&lgl->elm->mark, idx, 0);
+    }
+    assert (lgl->opts->elim.val);
+    if (!nontrivial &&
+        lgl->opts->block.val &&
+	lgl->opts->elmblk.val &&
+	(!lgl->opts->elmblkwait.val || !lgl->opts->elim.val || lgl->elmrtc)) {
+      assert (maxcover >= cover);
+      lgl->stats->elm.blkd++;
+      LOGMCLS (2, c, "blocked on %d clause", ipivot);
+      lglepush (lgl, ipivot);
+      for (p = c; (lit = *p); p++) {
+	if (lit == mpivot) continue;
+	assert (lit != -mpivot);
+	ilit = lglm2i (lgl, lit);
+	lglepush (lgl, ilit);
+      }
+      lglepush (lgl, 0);
+      lglelrmcls (lgl, ipivot, c, clidx);
+      lglblockinglit (lgl, ipivot);
+      continue;
+    }
+    clidx++;
+    if (lgl->limits->elm.steps <= lgl->stats->elm.steps) {
+      LOG (2, "maximum number of steps in elimination exhausted");
+      return;
+    }
+  }
+}
+
+static void lglelmfre (LGL * lgl) {
+  int * sop, * eop, * son, * eon;
+  assert (lgl->elm->pivot);
+  sop = lgl->elm->lits.start + 1;
+  eop = son = lgl->elm->lits.start + lgl->elm->neglidx;
+  eon = lgl->elm->lits.top;
+  lglelmfrelit (lgl, 1, sop, eop, son, eon);
+  lglelmfrelit (lgl, -1, son, eon, sop, eop);
+}
+
+static void lgleliminated (LGL * lgl, int pivot) {
+  AVar * av;
+  int elit;
+  Ext * e;
+  assert (!lglifrozen (lgl, pivot));
+  av = lglavar (lgl, pivot);
+  assert (av->type == FREEVAR);
+  av->type = ELIMVAR;
+  lgl->stats->elm.elmd++;
+  assert (lgl->stats->elm.elmd > 0);
+  lglflushclauses (lgl, pivot);
+  lglflushclauses (lgl, -pivot);
+  LOG (2, "eliminated %d", pivot);
+  elit = lglexport (lgl, pivot);
+  e = lglelit2ext (lgl, elit);
+  assert (!e->eliminated);
+  assert (!e->equiv);
+  e->eliminated = 1;
+}
+
+static void lglepusheliminated (LGL * lgl, int idx) {
+  const int * p, * w, * eow, * c, * l;
+  int lit, blit, tag, red, other;
+  HTS * hts;
+  lit = (lglocc (lgl, idx) < lglocc (lgl, -idx)) ? idx : -idx;
+  LOG (3, "keeping clauses with %d for extending assignment", lit);
+  hts = lglhts (lgl, lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    lglepush (lgl, lit);
+    if (tag == BINCS || tag == TRNCS) {
+      lglepush (lgl, blit >> RMSHFT);
+      if (tag == TRNCS)
+	lglepush (lgl, *p);
+    } else {
+      assert (tag == OCCS);
+      c = lglidx2lits (lgl, 0, blit >> RMSHFT);
+      for (l = c; (other = *l); l++)
+	if (other != lit)
+	  lglepush (lgl, other);
+    }
+    lglepush (lgl, 0);
+  }
+  lglepush (lgl, -lit);
+  lglepush (lgl, 0);
+  lgleliminated (lgl, idx);
+}
+
+static int lglunhimpl (const DFPR * dfpr, int a, int b) {
+  int u = lglulit (a), v = lglulit (b), c, d, f, g;
+  c = dfpr[u].discovered; if (!c) return 0;
+  d = dfpr[v].discovered; if (!d) return 0;
+  f = dfpr[u].finished, g = dfpr[v].finished;
+  assert (0 < c && c < f);
+  assert (0 < d && d < g);
+  return c < d && g < f;
+}
+
+static int lglunhimplies2 (const DFPR * dfpr, int a, int b) {
+  return lglunhimpl (dfpr, a, b) || lglunhimpl (dfpr, -b, -a);
+}
+
+static int lglunhimplincl (const DFPR * dfpr, int a, int b) {
+  int u = lglulit (a), v = lglulit (b), c, d, f, g;
+  c = dfpr[u].discovered; if (!c) return 0;
+  d = dfpr[v].discovered; if (!d) return 0;
+  f = dfpr[u].finished, g = dfpr[v].finished;
+  assert (0 < c && c < f);
+  assert (0 < d && d < g);
+  return c <= d && g <= f;
+}
+
+static int lglunhimplies2incl (const DFPR * dfpr, int a, int b) {
+  return lglunhimplincl (dfpr, a, b) || lglunhimplincl (dfpr, -b, -a);
+}
+
+static int lglhastrn (LGL * lgl, int a, int b, int c) {
+  int blit, tag, other, other2;
+  const int * w, * eow, * p;
+  HTS * ha, * hb, * hc;
+  ha = lglhts (lgl, a);
+  hb = lglhts (lgl, b);
+  if (hb->count < ha->count) { SWAP (int, a, b); SWAP (HTS *, ha, hb); }
+  hc = lglhts (lgl, c);
+  if (hc->count < ha->count) { SWAP (int, a, c); SWAP (HTS *, ha, hc); }
+  w = lglhts2wchs (lgl, ha);
+  eow = w + ha->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == OCCS) continue;
+    if (tag == BINCS) {
+      other = blit >> RMSHFT;
+      if (other == b || other == c) return 1;
+      continue;
+    }
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    assert (tag == TRNCS);
+    other = blit >> RMSHFT;
+    if (other != b && other != c) continue;
+    other2 = *p;
+    if (other2 == b || other2 == c) return 1;
+  }
+  if (hc->count < hb->count) { SWAP (int, b, c); SWAP (HTS *, hb, hc); }
+  w = lglhts2wchs (lgl, hb);
+  eow = w + hb->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == OCCS) continue;
+    if (tag == TRNCS || tag == LRGCS) { p++; continue; }
+    assert (tag == BINCS);
+    other = blit >> RMSHFT;
+    if (other == c) return 1;
+  }
+  return 0;
+}
+
+static int64_t lglfactor (LGL * lgl, int lim, int count) {
+  int64_t factor, res;
+  if (!count) return lim;
+  switch (lgl->opts->factor.val) {
+    default: factor = 1; break;
+    case 1: factor = lglceild (count); break;
+    case 2: factor = count; break;
+    case 3: factor = count*(int64_t)count; break;
+  }
+  if (!factor) factor = 1;
+  if (factor > lgl->opts->factmax.val) factor = lgl->opts->factmax.val;
+  res = lim * factor;
+  return res;
+}
+
+static int lglforcedve (LGL * lgl, int idx) {
+  int pocc = lglocc (lgl, idx);
+  int nocc = lglocc (lgl, -idx);
+  int count = lgl->stats->elm.count;
+  if (!pocc) return 1;
+  if (!nocc) return 1;
+  if (pocc + nocc <= lgl->opts->elmoccsumforced.val) return 1;
+  if (lgl->opts->elmfull.val) return 0;
+  if (pocc >= lglfactor (lgl, lgl->opts->elmocclim1.val, count)) return -1;
+  if (nocc >= lglfactor (lgl, lgl->opts->elmocclim1.val, count)) return -1;
+  if (pocc < lglfactor (lgl, lgl->opts->elmocclim2.val, count)) return 0;
+  if (nocc < lglfactor (lgl, lgl->opts->elmocclim2.val, count)) return 0;
+  return -1;
+}
+
+static int lgltrylargeve (LGL * lgl) {
+  const int * c, * d, * sop, * eop, * son, * eon, * p, * q, * start, * end;
+  int lit, idx, sgn, tmp, ip, ilit, npocc, nnocc, limit, count, i, res;
+  int clen, dlen, reslen, maxreslen;
+  ip = lgl->elm->pivot;
+  assert (ip);
+  if ((res = lglforcedve (lgl, ip))) return res > 0;
+  sop = lgl->elm->lits.start + 1;
+  eop = son = lgl->elm->lits.start + lgl->elm->neglidx;
+  eon = lgl->elm->lits.top;
+  npocc = lglpeek (&lgl->elm->noccs, lglulit (1));
+  nnocc = lglpeek (&lgl->elm->noccs, lglulit (-1));
+  limit = npocc + nnocc;
+  count = 0;
+  for (i = 0; i <= 1; i++) {
+    start = i ? son : sop;
+    end = i ? eon : eop;
+    for (c = start; c < end; c++) {
+      INCSTEPS (elm.steps);
+      if (*c == REMOVED) { while (*c) c++; continue; }
+      while ((lit = *c)) {
+	(void) lglm2i (lgl, lit);
+	c++;
+      }
+      count++;
+    }
+  }
+  assert (count == limit);
+  LOG (3, "trying clause distribution for %d with limit %d", ip, limit);
+  maxreslen = 0;
+  for (c = sop; c < eop && limit >= 0; c = p + 1) {
+    INCSTEPS (elm.steps);
+    if (*c == REMOVED) {
+      for (p = c + 1; *p; p++)
+        ;
+      continue;
+    }
+    assert (lglmtstk (&lgl->resolvent));
+    clen = 0;
+    for (p = c; (lit = *p); p++) {
+      if (lit == 1) continue;
+      assert (lit != -1);
+      idx = abs (lit);
+      assert (!lglpeek (&lgl->elm->mark, idx));
+      sgn = lglsgn (lit);
+      lglpoke (&lgl->elm->mark, idx, sgn);
+      ilit = lglm2i (lgl, lit);
+      lglpushstk (lgl, &lgl->resolvent, ilit);
+      clen++;
+    }
+    for (d = son; limit >= 0 && d < eon; d = q + 1) {
+      INCSTEPS (elm.steps);
+      if (*d == REMOVED) {
+	for (q = d + 1; *q; q++)
+	  ;
+	continue;
+      }
+      INCSTEPS (elm.resolutions);
+      LOGMCLS (3, c, "trying resolution 1st antecedent");
+      LOGMCLS (3, d, "trying resolution 2nd antecedent");
+      dlen = 0;
+      reslen = clen;
+      for (q = d; (lit = *q); q++) {
+	if (lit == -1) continue;
+	dlen++;
+	assert (lit != 1);
+	idx = abs (lit), sgn = lglsgn (lit);
+	tmp = lglpeek (&lgl->elm->mark, idx);
+	if (tmp == -sgn) break;
+	if (tmp == sgn) continue;
+	ilit = lglm2i (lgl, lit);
+	lglpushstk (lgl, &lgl->resolvent, ilit);
+	reslen++;
+      }
+      assert (reslen == lglcntstk (&lgl->resolvent));
+      if (!lit && reslen == 1) {
+	LOG (3, "trying resolution ends with unit clause");
+	lit = lglpeek (&lgl->resolvent, 0);
+	limit += lglevar (lgl, lit)->occ[lit < 0];
+      } else if (lit) {
+	while (*++q) ;
+	LOG (3, "trying resolution ends with trivial resolvent");
+      } else {
+	limit--;
+	LOG (3,
+	     "trying resolution with non trivial resolvent remaining %d",
+	     limit);
+	if (reslen > maxreslen) maxreslen = reslen;
+      }
+      assert (!*q);
+      lglrststk (&lgl->resolvent, clen);
+    }
+    lglclnstk (&lgl->resolvent);
+    for (p = c; (lit = *p); p++) {
+      if (lit == 1) continue;
+      assert (lit != -1);
+      idx = abs (lit);
+      assert (lglpeek (&lgl->elm->mark, idx) == lglsgn (lit));
+      lglpoke (&lgl->elm->mark, idx, 0);
+    }
+    if (lgl->limits->elm.steps <= lgl->stats->elm.steps) {
+      LOG (2, "maximum number of steps in elimination exhausted");
+      return 0;
+    }
+  }
+  assert (lglm2i (lgl, 1) == ip);
+  if (limit < 0) {
+    LOG (3, "resolving away %d would increase number of clauses", ip);
+    return 0;
+  }
+  if (limit) LOG (2, "resolving away %d removes %d clauses", ip, limit);
+  else LOG (2, "resolving away %d does not change number of clauses", ip);
+  return 1;
+}
+
+static void lgldolargeve (LGL * lgl) {
+  const int * c, * d, * sop, * eop, * son, * eon, * p, * q, * start, * end;
+  int lit, idx, sgn, tmp, ip, ilit, mp, npocc, nnocc;
+  int clen, dlen, reslen;
+  Val val;
+  ip = lgl->elm->pivot;
+  assert (ip);
+  sop = lgl->elm->lits.start + 1;
+  eop = son = lgl->elm->lits.start + lgl->elm->neglidx;
+  eon = lgl->elm->lits.top;
+  npocc = lglpeek (&lgl->elm->noccs, lglulit (1));
+  nnocc = lglpeek (&lgl->elm->noccs, lglulit (-1));
+  LOG (2, "(large) variable elimination of %d", lgl->elm->pivot);
+  if (npocc < nnocc) start = sop, end = eop, mp = 1;
+  else start = son, end = eon, ip = -ip, mp = -1;
+  LOG (3, "will save clauses with %d for extending assignment", ip);
+  for (c = start; c < end; c = p + 1) {
+    INCSTEPS (elm.steps);
+    if (*c == REMOVED) {
+      for (p = c + 1; *p; p++)
+	;
+      continue;
+    }
+    lglepush (lgl, ip);
+    for (p = c; (lit = *p); p++)  {
+      if (lit == mp) continue;
+      assert (lit != -mp);
+      ilit = lglm2i (lgl, lit);
+      lglepush (lgl, ilit);
+    }
+    lglepush (lgl, 0);
+  }
+  lglepush (lgl, -ip);
+  lglepush (lgl, 0);
+  for (c = sop; c < eop; c = p + 1) {
+    INCSTEPS (elm.steps);
+    if (*c == REMOVED) {
+      for (p = c + 1; *p; p++)
+	;
+      continue;
+    }
+    assert (lglmtstk (&lgl->resolvent));
+    clen = 0;
+    for (p = c; (lit = *p); p++) {
+      if (lit == 1) continue;
+      assert (lit != -1);
+      idx = abs (lit);
+      assert (!lglpeek (&lgl->elm->mark, idx));
+      sgn = lglsgn (lit);
+      lglpoke (&lgl->elm->mark, idx, sgn);
+      ilit = lglm2i (lgl, lit);
+      lglpushstk (lgl, &lgl->resolvent, ilit);
+      clen++;
+    }
+    for (d = son; d < eon; d = q + 1) {
+      INCSTEPS (elm.steps);
+      if (*d == REMOVED) {
+	for (q = d + 1; *q; q++)
+	  ;
+	continue;
+      }
+      INCSTEPS (elm.resolutions);
+      assert (lglmtstk (&lgl->clause));
+      dlen = 0;
+      reslen = clen;
+      for (q = d; (lit = *q); q++) {
+	if (lit == -1) continue;
+	dlen++;
+	assert (lit != 1);
+	idx = abs (lit), sgn = lglsgn (lit);
+	tmp = lglpeek (&lgl->elm->mark, idx);
+	if (tmp == sgn) continue;
+	if (tmp == -sgn) break;
+	ilit = lglm2i (lgl, lit);
+	val = lglval (lgl, ilit);
+	if (val < 0) continue;
+	if (val > 0) break;
+	lglpushstk (lgl, &lgl->clause, ilit);
+	ilit = lglm2i (lgl, lit);
+	lglpushstk (lgl, &lgl->resolvent, ilit);
+	reslen++;
+      }
+      assert (reslen == lglcntstk (&lgl->resolvent));
+      if (!lit && reslen == 1) {
+	goto RESOLVE;
+      } if (lit) {
+	while (*++q) ;
+      } else {
+RESOLVE:
+	LOGMCLS (3, c, "resolving variable elimination 1st antecedent");
+	LOGMCLS (3, d, "resolving variable elimination 2nd antecedent");
+	for (p = c; (lit = *p); p++) {
+	  if (lit == 1) continue;
+	  assert (lit != -1);
+	  ilit = lglm2i (lgl, lit);
+	  val = lglval (lgl, ilit);
+	  if (val < 0) continue;
+	  if (val > 0) break;
+	  lglpushstk (lgl, &lgl->clause, ilit);
+	}
+	if (!lit) {
+	  lglpushstk (lgl, &lgl->clause, 0);
+	  LOGCLS (3, lgl->clause.start, "variable elimination resolvent");
+	  lgldrupligaddcls (lgl, REDCS);
+	  lgladdcls (lgl, 0, 0, 1);
+	}
+      }
+      lglclnstk (&lgl->clause);
+      assert (!*q);
+      lglrststk (&lgl->resolvent, clen);
+    }
+    lglclnstk (&lgl->resolvent);
+    for (p = c; (lit = *p); p++) {
+      if (lit == 1) continue;
+      assert (lit != -1);
+      idx = abs (lit);
+      assert (lglpeek (&lgl->elm->mark, idx) == lglsgn (lit));
+      lglpoke (&lgl->elm->mark, idx, 0);
+    }
+  }
+  lgleliminated (lgl, lgl->elm->pivot);
+  lgl->stats->elm.large++;
+}
+
+static void lglelimlitaux (LGL * lgl, int idx) {
+  lglelmsub (lgl);
+  if (lglelmstr (lgl)) return;
+  lglelmfre (lgl);
+  if (lgltrylargeve (lgl)) lgldolargeve (lgl);
+}
+
+static int lgls2m (LGL * lgl, int ilit) {
+  AVar * av = lglavar (lgl, ilit);
+  int res = av->mark;
+  if (!res) {
+    res = lglcntstk (&lgl->seen) + 1;
+    if (res > lgl->opts->smallvevars.val + 1) return 0;
+    av->mark = res;
+    assert (lglcntstk (&lgl->seen) == lglcntstk (&lgl->elm->m2i) - 1);
+    lglpushstk (lgl, &lgl->seen, abs (ilit));
+    lglpushstk (lgl, &lgl->elm->m2i, abs (ilit));
+    LOG (4, "mapped internal variable %d to marked variable %d",
+	 abs (ilit), res);
+  }
+  if (ilit < 0) res = -res;
+  return res;
+}
+
+static void lglvar2funaux (int v, Fun res, int negate) {
+  uint64_t tmp;
+  int i, j, p;
+  assert (0 <= v && v < FUNVAR);
+  if (v < 6) {
+    tmp = lglbasevar2funtab[v];
+    if (negate) tmp = ~tmp;
+    for (i = 0; i < FUNQUADS; i++)
+      res[i] = tmp;
+  } else {
+    tmp = negate ? ~0ull : 0ull;
+    p = 1 << (v - 6);
+    j = 0;
+    for (i = 0; i < FUNQUADS; i++) {
+      res[i] = tmp;
+      if (++j < p) continue;
+      tmp = ~tmp;
+      j = 0;
+    }
+  }
+}
+
+static void lglvar2fun (int v, Fun res) {
+  lglvar2funaux (v, res, 0);
+}
+
+static void lglnegvar2fun (int v, Fun res) {
+  lglvar2funaux (v, res, 1);
+}
+
+static void lglfuncpy (Fun dst, const Fun src) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    dst[i] = src[i];
+}
+
+static void lglfalsefun (Fun res) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    res[i] = 0ll;
+}
+
+static void lgltruefun (Fun res) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    res[i] = ~0ll;
+}
+
+static int lglisfalsefun (const Fun f) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (f[i] != 0ll) return 0;
+  return 1;
+}
+
+static int lglistruefun (const Fun f) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (f[i] != ~0ll) return 0;
+  return 1;
+}
+
+static void lglorfun (Fun a, const Fun b) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    a[i] |= b[i];
+}
+
+static void lglornegfun (Fun a, const Fun b) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    a[i] |= ~b[i];
+}
+
+static void lglor3fun (Fun a, const Fun b, const Fun c) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    a[i] = b[i] | c[i];
+}
+
+static void lglor3negfun (Fun a, const Fun b, const Fun c) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    a[i] = b[i] | ~c[i];
+}
+
+static void lglandornegfun (Fun a, const Fun b, const Fun c) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    a[i] &= b[i] | ~c[i];
+}
+
+static void lglandfun (Fun a, const Fun b) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    a[i] &= b[i];
+}
+
+static void lgland3fun (Fun a, const Fun b, const Fun c) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    a[i] = b[i] & c[i];
+}
+
+static void lgland3negfun (Fun a, const Fun b, const Fun c) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    a[i] = b[i] & ~c[i];
+}
+
+static void lglsrfun (Fun a, int shift) {
+  uint64_t rest, tmp;
+  int i, j, q, b, l;
+  assert (0 <= shift);
+  b = shift & 63;
+  q = shift >> 6;
+  j = 0;
+  i = q;
+  assert (i >= 0);
+  l = 64 - b;
+  while (j < FUNQUADS) {
+    if (i < FUNQUADS) {
+      tmp = a[i] >> b;
+      rest = (b && i+1 < FUNQUADS) ? (a[i+1] << l) : 0ull;
+      a[j] = rest | tmp;
+    } else a[j] = 0ull;
+    i++, j++;
+  }
+}
+
+static void lglslfun (Fun a, int shift) {
+  uint64_t rest, tmp;
+  int i, j, q, b, l;
+  assert (0 <= shift);
+  b = shift & 63;
+  q = shift >> 6;
+  j = FUNQUADS - 1;
+  i = j - q;
+  l = 64 - b;
+  while (j >= 0) {
+    if (i >= 0) {
+      tmp = a[i] << b;
+      rest = (b && i > 0) ? (a[i-1] >> l) : 0ll;
+      a[j] = rest | tmp;
+    } else a[j] = 0ll;
+    i--, j--;
+  }
+}
+
+static void lgls2fun (int mlit, Fun res) {
+  int midx = abs (mlit), sidx = midx - 2;
+  assert (0 <= sidx && sidx < FUNVAR);
+  if (mlit < 0) lglnegvar2fun (sidx, res);
+  else lglvar2fun (sidx, res);
+}
+
+static int lglinitsmallve (LGL * lgl, int lit, Fun res) {
+  int blit, tag, red, other, other2, lidx, mlit;
+  const int * p, * w, * eow, * c, * q;
+  Fun cls, tmp;
+  HTS * hts;
+  Val val;
+  assert (!lglval (lgl, lit));
+  LOG (3, "initializing small variable eliminiation for %d", lit);
+#ifndef NDEBUG
+  mlit =
+#endif
+  lgls2m (lgl, lit);
+  assert (abs (mlit) == 1);
+  hts = lglhts (lgl, lit);
+  lgltruefun (res);
+  if (!hts->count) goto DONE;
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    INCSTEPS (elm.steps);
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    lglfalsefun (cls);
+    if (tag == BINCS || tag == TRNCS) {
+      other = blit >> RMSHFT;
+      val = lglval (lgl, other);
+      assert (val <= 0);
+      if (!val) {
+	mlit = lgls2m (lgl, other);
+	if (!mlit) return 0;
+	lgls2fun (mlit, tmp);
+	lglorfun (cls, tmp);
+      }
+      if (tag == TRNCS) {
+	other2 = *p;
+	val = lglval (lgl, other2);
+	assert (val <= 0);
+	if (!val) {
+	  mlit = lgls2m (lgl, other2);
+	  if (!mlit) return 0;
+	  lgls2fun (mlit, tmp);
+	  lglorfun (cls, tmp);
+	}
+      }
+    } else {
+      assert (tag == OCCS);
+      lidx = blit >> RMSHFT;
+      c = lglidx2lits (lgl, 0, lidx);
+      for (q = c; (other = *q); q++) {
+	if (other == lit) continue;
+	assert (other != -lit);
+	val = lglval (lgl, other);
+	assert (val <= 0);
+	if (!val) {
+	  mlit = lgls2m (lgl, other);
+	  if (!mlit) return 0;
+	  lgls2fun (mlit, tmp);
+	  lglorfun (cls, tmp);
+	}
+      }
+    }
+    assert (!lglisfalsefun (cls));
+    assert (!lglistruefun (cls));
+    lglandfun (res, cls);
+    INCSTEPS (elm.copies);
+  }
+DONE:
+  return 1;
+}
+
+static void lglresetsmallve (LGL * lgl) {
+  lglclnstk (&lgl->elm->m2i);
+  lglclnstk (&lgl->elm->clv);
+  lglpopnunmarkstk (lgl, &lgl->seen);
+}
+
+static void lglsmallevalcls (unsigned cls, Fun res) {
+  Fun tmp;
+  int v;
+  lglfalsefun (res);
+  for (v = 0; v < FUNVAR; v++) {
+    if (cls & (1 << (2*v + 1))) {
+      lglvar2fun (v, tmp);
+      lglornegfun (res, tmp);
+    } else if (cls & (1 << (2*v))) {
+      lglvar2fun (v, tmp);
+      lglorfun (res, tmp);
+    }
+  }
+}
+
+static Cnf lglpos2cnf (int pos) { assert (pos >=0 ); return pos; }
+static Cnf lglsize2cnf (int s) { assert (s >=0 ); return ((Cnf)s) << 32; }
+static int lglcnf2pos (Cnf cnf) { return cnf & 0xfffffll; }
+static int lglcnf2size (Cnf cnf) { return cnf >> 32; }
+
+static Cnf lglcnf (int pos, int size) {
+  return lglpos2cnf (pos) | lglsize2cnf (size);
+}
+
+static void lglsmallevalcnf (LGL * lgl, Cnf cnf, Fun res) {
+  Fun tmp;
+  int i, n, p, cls;
+  p = lglcnf2pos (cnf);
+  n = lglcnf2size (cnf);
+  lgltruefun (res);
+  for (i = 0; i < n; i++) {
+    cls = lglpeek (&lgl->elm->clv, p + i);
+    lglsmallevalcls (cls, tmp);
+    lglandfun (res, tmp);
+  }
+}
+
+static void lglnegcofactorfun (const Fun f, int v, Fun res) {
+  Fun mask, masked;
+  lglvar2fun (v, mask);
+  lgland3negfun (masked, f, mask);
+  lglfuncpy (res, masked);
+  lglslfun (masked, (1 << v));
+  lglorfun (res, masked);
+}
+
+static void lglposcofactorfun (const Fun f, int v, Fun res) {
+  Fun mask, masked;
+  lglvar2fun (v, mask);
+  lgland3fun (masked, f, mask);
+  lglfuncpy (res, masked);
+  lglsrfun (masked, (1 << v));
+  lglorfun (res, masked);
+}
+
+static int lglsmallfundeps0 (const Fun f) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (((f[i] & 0xaaaaaaaaaaaaaaaaull)>>1) !=
+         (f[i] & 0x5555555555555555ull)) return 1;
+  return 0;
+}
+
+static int lglsmallfundeps1 (const Fun f) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (((f[i] & 0xccccccccccccccccull)>>2) !=
+         (f[i] & 0x3333333333333333ull)) return 1;
+  return 0;
+}
+
+static int lglsmallfundeps2 (const Fun f) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (((f[i] & 0xf0f0f0f0f0f0f0f0ull)>>4) !=
+         (f[i] & 0x0f0f0f0f0f0f0f0full)) return 1;
+  return 0;
+}
+
+static int lglsmallfundeps3 (const Fun f) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (((f[i] & 0xff00ff00ff00ff00ull)>>8) !=
+         (f[i] & 0x00ff00ff00ff00ffull)) return 1;
+  return 0;
+}
+
+static int lglsmallfundeps4 (const Fun f) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (((f[i] & 0xffff0000ffff0000ull)>>16) !=
+         (f[i] & 0x0000ffff0000ffffull)) return 1;
+  return 0;
+}
+
+static int lglsmallfundeps5 (const Fun f) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (((f[i] & 0xffffffff00000000ull)>>32) !=
+         (f[i] & 0x00000000ffffffffull)) return 1;
+  return 0;
+}
+
+static int lglsmallfundepsgen (const Fun f, int min) {
+  const int c = (1 << (min - 6));
+  int i, j;
+  assert (min >= 6);
+  for (i = 0; i < FUNQUADS; i += (1 << (min - 5)))
+    for (j = 0; j < c; j++)
+      if (f[i + j] != f[i + c + j]) return 1;
+  return 0;
+}
+
+static int lglsmalltopvar (const Fun f, int min) {
+  int i;
+  switch (min) {
+    case 0: if (lglsmallfundeps0 (f)) return 0;
+    case 1: if (lglsmallfundeps1 (f)) return 1;
+    case 2: if (lglsmallfundeps2 (f)) return 2;
+    case 3: if (lglsmallfundeps3 (f)) return 3;
+    case 4: if (lglsmallfundeps4 (f)) return 4;
+    case 5: if (lglsmallfundeps5 (f)) return 5;
+  }
+  for (i = lglmax (6, min); i <= FUNVAR - 2; i++)
+    if (lglsmallfundepsgen (f, i)) return i;
+  return i;
+}
+
+static Cnf lglsmalladdlit2cnf (LGL * lgl, Cnf cnf, int lit) {
+  int p, m, q, n, i, cls;
+  Cnf res;
+  p = lglcnf2pos (cnf);
+  m = lglcnf2size (cnf);
+  q = lglcntstk (&lgl->elm->clv);
+  for (i = 0; i < m; i++) {
+    cls = lglpeek (&lgl->elm->clv, p + i);
+    assert (!(cls & lit));
+    cls |= lit;
+    lglpushstk (lgl, &lgl->elm->clv, cls);
+  }
+  n = lglcntstk (&lgl->elm->clv) - q;
+  res = lglcnf (q, n);
+  return res;
+}
+
+#ifndef NDEBUG
+static int lglefun (const Fun a, const Fun b) {
+  int i;
+  for (i = 0; i < FUNQUADS; i++)
+    if (a[i] & ~b[i]) return 0;
+  return 1;
+}
+#endif
+
+// The dual version of Minato's algorithm for computing an irredundant
+// product of sums.   The original algorithm computes an irredundant sum of
+// products. It uses BDDs for representing boolean functions and ZDDs for
+// manipulating sum of product.  We work with function tables stored as bit
+// maps and plain CNFs stored as lists of clauses instead.
+
+static Cnf lglsmallipos (LGL * lgl, const Fun U, const Fun L, int min) {
+  Fun U0, U1, L0, L1, Unew, ftmp;
+  Cnf c0, c1, cstar, ctmp, res;
+  int x, y, z;
+  assert (lglefun (L, U));
+  if (lglistruefun (U)) return TRUECNF;
+  if (lglisfalsefun (L)) return FALSECNF;
+  lgl->stats->elm.ipos++;
+  assert (min < lglcntstk (&lgl->elm->m2i));
+  y = lglsmalltopvar (U, min);
+  z = lglsmalltopvar (L, min);
+  INCSTEPS (elm.steps);
+  x = (y < z) ? y : z;
+  assert (x < FUNVAR);
+  lglnegcofactorfun (U, x, U0); lglposcofactorfun (U, x, U1);
+  lglnegcofactorfun (L, x, L0); lglposcofactorfun (L, x, L1);
+  lglor3negfun (ftmp, U0, L1);
+  c0 = lglsmallipos (lgl, ftmp, L0, min+1);
+  lglor3negfun (ftmp, U1, L0);
+  c1 = lglsmallipos (lgl, ftmp, L1, min+1);
+  lglsmallevalcnf (lgl, c0, ftmp);
+  lglor3negfun (Unew, U0, ftmp);
+  lglsmallevalcnf (lgl, c1, ftmp);
+  lglandornegfun (Unew, U1, ftmp);
+  lglor3fun (ftmp, L0, L1);
+  cstar = lglsmallipos (lgl, Unew, ftmp, min+1);
+  assert (cstar != FALSECNF);
+  ctmp = lglsmalladdlit2cnf (lgl, c1, (1 << (2*x + 1)));
+  res = lglcnf2pos (ctmp);
+  ctmp = lglsmalladdlit2cnf (lgl, c0, (1 << (2*x)));
+  if (res == TRUECNF) res = lglcnf2pos (ctmp);
+  ctmp = lglsmalladdlit2cnf (lgl, cstar, 0);
+  if (res == TRUECNF) res = lglcnf2pos (ctmp);
+  res |= lglsize2cnf (lglcntstk (&lgl->elm->clv) - res);
+  return res;
+}
+
+static void lglsmallve (LGL * lgl, Cnf cnf) {
+  int * soc = lgl->elm->clv.start + lglcnf2pos (cnf);
+  int * eoc = soc + lglcnf2size (cnf);
+  int * p, cls, v, lit, trivial;
+  Val val;
+  for (p = soc; !lgl->mt && p < eoc; p++) {
+    cls = *p;
+    assert (lglmtstk (&lgl->clause));
+    trivial = 0;
+    for (v = 0; v < FUNVAR; v++) {
+      if (cls & (1 << (2*v + 1))) lit = -lglm2i (lgl, v+2);
+      else if (cls & (1 << (2*v))) lit = lglm2i (lgl, v+2);
+      else continue;
+      val = lglval (lgl, lit);
+      if (val < 0) continue;
+      if (val > 0) trivial = 1;
+      lglpushstk (lgl, &lgl->clause, lit);
+    }
+    if (!trivial) {
+      INCSTEPS (elm.resolutions);
+      lglpushstk (lgl, &lgl->clause, 0);
+      LOGCLS (3, lgl->clause.start, "small elimination resolvent");
+      lgldrupligaddcls (lgl, REDCS);
+      lgladdcls (lgl, 0, 0, 1);
+    }
+    lglclnstk (&lgl->clause);
+  }
+}
+
+static int lglsmallisunitcls (LGL * lgl, int cls) {
+  int fidx, fsign, flit, mlit, ilit;
+  ilit = 0;
+  for (fidx = 0; fidx < FUNVAR; fidx++)
+    for (fsign = 0; fsign <= 1; fsign++) {
+      flit = 1<<(2*fidx + fsign);
+      if (!(cls & flit)) continue;
+      if (ilit) return 0;
+      mlit = (fidx + 2) * (fsign ? -1 : 1);
+      ilit = lglm2i (lgl, mlit);
+    }
+  return ilit;
+}
+
+static int lglsmallcnfunits (LGL * lgl, Cnf cnf) {
+  int p, m, i, res, cls, ilit;
+  p = lglcnf2pos (cnf);
+  m = lglcnf2size (cnf);
+  res = 0;
+  for (i = 0; i < m; i++) {
+    cls = lglpeek (&lgl->elm->clv, p + i);
+    ilit = lglsmallisunitcls (lgl, cls);
+    if (!ilit) continue;
+    assert (lglval (lgl, ilit) >= 0);
+    lglunit (lgl, ilit);
+    res++;
+  }
+  return res;
+}
+
+static int lgltrysmallve (LGL * lgl, int idx) {
+  int res, new, old, units;
+  Fun pos, neg, fun;
+  EVar * ev;
+  Cnf cnf;
+  assert (lglmtstk (&lgl->elm->m2i));
+  assert (lglmtstk (&lgl->seen));
+  assert (lglmtstk (&lgl->elm->clv));
+  if (!lgl->opts->smallve.val) return 0;
+  if (lgl->opts->smallvewait.val && !lgl->elmrtc) return 0;
+  lglpushstk (lgl, &lgl->elm->m2i, 0);
+  lglpushstk (lgl, &lgl->elm->clv, 0);
+  res = 0;
+  if (lglinitsmallve (lgl, idx, pos) && lglinitsmallve (lgl, -idx, neg)) {
+    lglor3fun (fun, pos, neg);
+    cnf = lglsmallipos (lgl, fun, fun, 0);
+    new = lglcnf2size (cnf);
+    units = lglsmallcnfunits (lgl, cnf);
+    assert (units <= new);
+    new -= units;
+    ev = lglevar (lgl, idx);
+    old = ev->occ[0] + ev->occ[1];
+    LOG (2,
+"small elimination of %d replaces %d old with %d new clauses and %d units",
+      idx, old, new, units);
+    lgl->stats->elm.small.tried++;
+    if (new > old) {
+      if (units > 0) {
+	LOG (2,
+"unforced small elimination of %d would add %d clauses but produces %d units",
+	  idx, new - old, units);
+        res = 1;
+      } else {
+	LOG (2,
+"unforced small elimination of %d would add %d clauses considered failed",
+	  idx, new - old);
+        lgl->stats->elm.small.failed++;
+      }
+    } else {
+      LOG (2,
+"small elimination of %d removes %d clauses thus considered promising",
+	idx, old - new);
+      lglepusheliminated (lgl, idx);
+      lglflushclauses (lgl, idx);
+      lglflushclauses (lgl, -idx);
+      lglsmallve (lgl, cnf);
+      lgl->stats->elm.small.elm++;
+      res = 1;
+    }
+  } else LOG (2, "too many variables for small elimination");
+  lglresetsmallve (lgl);
+  return res;
+}
+
+static int lgl2manyoccs4elm (LGL * lgl, int lit) {
+  return lglocc (lgl, lit) > 
+           lglfactor (lgl, lgl->opts->elmocclim.val, lgl->stats->elm.count);
+}
+
+static int lglchkoccs4elmlit (LGL * lgl, int lit) {
+  int blit, tag, red, other, other2, lidx, size, lits, count;
+  const int * p, * w, * eow, * c, * l;
+  int64_t litslim;
+  HTS * hts;
+  if (lgl->opts->elmfull.val) return 1;
+  count = lgl->stats->elm.count;
+  litslim = lglfactor (lgl, lgl->opts->elmlitslim.val, count);
+  hts = lglhts (lgl, lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  lits = 0;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    red = blit & REDCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (red || tag == LRGCS) continue;
+    if (tag == BINCS) {
+      other = blit >> RMSHFT;
+      if (lgl2manyoccs4elm (lgl, other)) return 0;
+      lits += 2;
+    } else if (tag == TRNCS) {
+      other = blit >> RMSHFT;
+      if (lgl2manyoccs4elm (lgl, other)) return 0;
+      other2 = *p;
+      if (lgl2manyoccs4elm (lgl, other2)) return 0;
+      lits += 3;
+    } else {
+      assert (tag == OCCS);
+      lidx = blit >> RMSHFT;
+      c = lglidx2lits (lgl, 0, lidx);
+      size = 0;
+      for (l = c; (other = *l); l++) {
+        if (lgl2manyoccs4elm (lgl, other)) return 0;
+        if (++size > lglfactor (lgl, lgl->opts->elmclslim.val, count))
+	  return 0;
+      }
+      lits += size;
+    }
+    if (lits > litslim) return 0;
+  }
+  return 1;
+}
+
+static int lglchkoccs4elm (LGL * lgl, int idx) {
+  int res;
+  if ((res = lglforcedve (lgl, idx)) > 0) return 1;
+  if (res < 0) return 0;
+  if (lgl2manyoccs4elm (lgl, idx)) return 0;
+  if (lgl2manyoccs4elm (lgl, -idx)) return 0;
+  if (!lglchkoccs4elmlit (lgl, idx)) return 0;
+  if (!lglchkoccs4elmlit (lgl, -idx)) return 0;
+  return 1;
+}
+
+static int lglispure (LGL * lgl, int lit) {
+  if (!lgl->opts->pure.val) return 0;
+  if (lglifrozen (lgl, lit)) return 0;
+  return !lglocc (lgl, -lit);
+}
+
+static int lglpurelit (LGL * lgl, int lit) {
+  int res;
+  LOG(1, "pure literal %d", lit);
+  assert (!lglocc (lgl, -lit));
+  res = lglflushclauses (lgl, lit);
+  assert (lgl->blocking || lgl->eliminating);
+  if (lgl->blocking) {
+    lgl->stats->blk.pure++;
+    lgl->stats->blk.clauses += res;
+    ADDSTEPS (blk.steps, res);
+  }
+  if (lgl->eliminating) {
+    lgl->stats->elm.pure++;
+    ADDSTEPS (elm.steps, res);
+  }
+  lglepusheliminated (lgl, lit);
+  return res;
+}
+
+static void lglelimlit (LGL * lgl, int idx) {
+  int forced;
+  if (!lglisfree (lgl, idx)) return;
+  if (lglispure (lgl, idx)) { (void) lglpurelit (lgl, idx); return; }
+  if (lglispure (lgl, -idx)) { (void) lglpurelit (lgl, -idx); return; }
+  if (!lglchkoccs4elm (lgl, idx)) return;
+  LOG (2, "trying to eliminate %d", idx);
+  if ((forced = lglforcedve (lgl, idx)) < 0) return;
+  if (!forced && lgltrysmallve (lgl, idx)) return;
+  lglinitecls (lgl, idx);
+  lglelimlitaux (lgl, idx);
+  if (lgl->elm->pivot) lglrstecls (lgl);
+}
+
+static int lglblockcls (LGL * lgl, int lit) {
+  int blit, tag, red, other, other2, lidx, val, count, size;
+  const int * p, * w, * eow, * c, *l;
+  int bc = lgl->stats->blk.count;
+  HTS * hts;
+  INCSTEPS (blk.steps);
+  hts = lglhts (lgl, lit);
+  if (!hts->count) return 1;
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  count = 0;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    count++;
+    lgl->stats->blk.res++;
+    INCSTEPS (blk.steps);
+    if (tag == BINCS || tag == TRNCS) {
+      other = blit >> RMSHFT;
+      val = lglmarked (lgl, other);
+      if (val < 0) continue;
+      if (tag == TRNCS) {
+	other2 = *p;
+	val = lglmarked (lgl, other2);
+	if (val < 0) continue;
+      }
+    } else {
+      assert (tag == OCCS);
+      lidx = blit >> RMSHFT;
+      c = lglidx2lits (lgl, 0, lidx);
+      size = 0;
+      for (l = c; (other = *l); l++) {
+	val = lglmarked (lgl, other);
+	if (++size > lglfactor (lgl, lgl->opts->blkclslim.val, bc)) return 0;
+	if (val < 0) break;
+      }
+      if (other) continue;
+    }
+    return 0;
+  }
+  LOG (3, "resolved %d trivial resolvents on %d", count, lit);
+  return 1;
+}
+
+static int lgl2manyoccs4blk (LGL * lgl, int lit) {
+  return lglhts (lgl, lit)->count >
+           lglfactor (lgl, lgl->opts->blkocclim.val, lgl->stats->blk.count);
+}
+
+static int lgldonotblocklit (LGL * lgl, int lit) {
+  int pocc = lglocc (lgl, lit);
+  int nocc = lglocc (lgl, -lit);
+  int count = lgl->stats->blk.count;
+  if (pocc >= lglfactor (lgl, lgl->opts->blkocclim1.val, count)) return 1;
+  if (nocc >= lglfactor (lgl, lgl->opts->blkocclim1.val, count)) return 1;
+  if (pocc < lglfactor (lgl, lgl->opts->blkocclim2.val, count)) return 0;
+  if (nocc < lglfactor (lgl, lgl->opts->blkocclim2.val, count)) return 0;
+  return 1;
+}
+
+static int lglblocklit (LGL * lgl, int lit, Stk * stk) {
+  int blit, tag, red, blocked, other, other2, lidx, count, size;
+  int bc = lgl->stats->blk.count;
+  int * p, * w, * eow, * c, * l;
+  HTS * hts;
+  if (lglval (lgl, lit)) return 0;
+  if (lgldonotblocklit (lgl, lit)) return 0;
+  if (lgl2manyoccs4blk (lgl, lit)) return 0;
+  hts = lglhts (lgl, lit);
+  assert (!lgl->opts->pure.val || hts->count > 0);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  count = 0;
+  assert (lglmtstk (stk+2) && lglmtstk (stk+3) && lglmtstk (stk+4));
+  for (p = w; p < eow; p++) {
+    if (INCSTEPS (blk.steps) >= lgl->limits->blk.steps) break;
+    if (lglterminate (lgl)) break;
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    assert (lglmtstk (&lgl->seen));
+    blocked = 0;
+    if (tag == BINCS || tag == TRNCS) {
+      if (!lgl->opts->blksmall.val) continue;
+      other = blit >> RMSHFT;
+      if (lgl2manyoccs4blk (lgl, other)) continue;
+      lglpushnmarkseen (lgl, other);
+      if (tag == TRNCS) {
+	other2 = *p;
+        if (lgl2manyoccs4blk (lgl, other2)) goto CONTINUE;
+	lglpushnmarkseen (lgl, other2);
+      }
+    } else {
+      assert (tag == OCCS);
+      if (!lgl->opts->blklarge.val) continue;
+      lidx = blit >> RMSHFT;
+      c = lglidx2lits (lgl, 0, lidx);
+      size = 0;
+      for (l = c; (other = *l); l++) {
+	if (other == lit) continue;
+        if (lgl2manyoccs4blk (lgl, other)) goto CONTINUE;
+	if (++size > lglfactor (lgl, lgl->opts->blkclslim.val, bc))
+	  goto CONTINUE;
+	lglpushnmarkseen (lgl, other);
+      }
+    }
+    blocked = lglblockcls (lgl, -lit);
+CONTINUE:
+    lglpopnunmarkstk (lgl, &lgl->seen);
+    if (!blocked) continue;
+    if (tag == BINCS) {
+      other = blit >> RMSHFT;
+      lglpushstk (lgl, stk+2, other);
+    } else if (tag == TRNCS) {
+      other = blit >> RMSHFT;
+      lglpushstk (lgl, stk+3, other);
+      other2 = *p;
+      lglpushstk (lgl, stk+3, other2);
+    } else {
+      assert (tag == OCCS);
+      lidx = blit >> RMSHFT;
+      lglpushstk (lgl, stk+4, lidx);
+    }
+  }
+  while (!lglmtstk (stk+2)) {
+    if (INCSTEPS (blk.steps) >= lgl->limits->blk.steps) break;
+    count++;
+    other = lglpopstk (stk+2);
+    LOG (2, "blocked binary clause %d %d on %d", lit, other, lit);
+    lglrmbcls (lgl, lit, other, 0);
+    lglepush (lgl, lit);
+    lglepush (lgl, other);
+    lglepush (lgl, 0);
+    if (!lglmvbcls (lgl, lit, other))
+      lgldrupligdelclsarg (lgl, lit, other, 0);
+  }
+  while (!lglmtstk (stk+3)) {
+    if (INCSTEPS (blk.steps) >= lgl->limits->blk.steps) break;
+    count++;
+    other2 = lglpopstk (stk+3);
+    other = lglpopstk (stk+3);
+    LOG (2, "blocked ternary clause %d %d %d on %d", lit, other, other2, lit);
+    lglrmtcls (lgl, lit, other, other2, 0);
+    lglepush (lgl, lit);
+    lglepush (lgl, other);
+    lglepush (lgl, other2);
+    lglepush (lgl, 0);
+    if (!lglmvtcls (lgl, lit, other, other2))
+      lgldrupligdelclsarg (lgl, lit, other, other2, 0);
+  }
+  while (!lglmtstk (stk+4)) {
+    if (INCSTEPS (blk.steps) >= lgl->limits->blk.steps) break;
+    lidx = lglpopstk (stk+4);
+    count++;
+    c = lglidx2lits (lgl, 0, lidx);
+    LOGCLS (2, c, "blocked on %d large clause", lit);
+    lgldrupligdelclsaux (lgl, c);
+    lglepush (lgl, lit);
+    for (l = c; (other = *l); l++)
+      if (other != lit) lglepush (lgl, other);
+    lglepush (lgl, 0);
+    lglrmlcls (lgl, lidx, 0);
+  }
+  LOG (2, "found %d blocked clauses with %d", count, lit);
+  lgl->stats->blk.clauses += count;
+  if (count > 0) lglblockinglit (lgl, lit);
+  lglclnstk (stk+2), lglclnstk (stk+3), lglclnstk (stk+4);
+  return count;
+}
+
+static void lglsetblklim (LGL * lgl) {
+  int64_t limit, irrlim;
+  int pen, szpen;
+  if (lgl->opts->blkrtc.val) {
+    lgl->limits->blk.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[block-%d] really no limit (run to completion)",
+      lgl->stats->blk.count);
+  } else {
+    limit = (lgl->opts->blkreleff.val*lglvisearch (lgl))/1000;
+    if (limit < lgl->opts->blkmineff.val) limit = lgl->opts->blkmineff.val;
+    if (lgl->opts->blkmaxeff.val >= 0 && limit > lgl->opts->blkmaxeff.val)
+      limit = lgl->opts->blkmaxeff.val;
+    if (lgl->stats->blk.count <= 1 &&
+        lgl->opts->boost.val &&
+	lglrem (lgl) < lgl->opts->blkboostvlim.val) {
+      lglprt (lgl, 1,
+        "[block-%d] boosting limit by %d",
+	lgl->stats->blk.count, lgl->opts->blkboost.val);
+      limit *= lgl->opts->blkboost.val;
+    }
+    limit >>= (pen = lgl->limits->blk.pen + (szpen = lglszpen (lgl)));
+    irrlim = (lgl->stats->irr.clauses.cur/2) >> szpen;
+    if (lgl->opts->irrlim.val && limit < irrlim) {
+      limit = irrlim;
+      lglprt (lgl, 1, 
+  "[block-%d] limit of %lld steps based on %d irredundant clauses penalty %d",
+	lgl->stats->blk.count,
+	(LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+    } else
+      lglprt (lgl, 1, 
+	"[block-%d] limit of %lld steps penalty %d = %d + %d",
+	lgl->stats->blk.count, (LGLL) limit,
+	pen, lgl->limits->blk.pen, szpen);
+    lgl->limits->blk.steps = lgl->stats->blk.steps + limit;
+  }
+}
+
+static int lgleschedrem (LGL * lgl, int this_time) {
+  int idx, res = 0, count;
+  const char * str;
+  AVar * av;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (lglifrozen (lgl, idx)) continue;
+    if (!lglisfree (lgl, idx)) continue;
+    av = lglavar (lgl, idx);
+    if (lgl->eliminating && av->donotelm) continue;
+    if (lgl->blocking && av->donotblk) continue;
+    res++;
+  }
+  assert (lgl->eliminating || lgl->blocking);
+  if (lgl->eliminating) count = lgl->stats->elm.count, str = "elim";
+  else assert (lgl->blocking), count = lgl->stats->blk.count, str = "block";
+  if (res)
+    lglprt (lgl, 1,
+      "[%s-%d] %d variables %.0f%% %s time",
+      str, count,
+      res, lglpcnt (res, lglrem (lgl)),
+      this_time ? "will be scheduled this" : "remain to be tried next");
+  else {
+    lglprt (lgl, 1,
+      "[%s-%d] no untried remaining variables left",
+      str, count);
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      av = lglavar (lgl, idx);
+      if (lgl->eliminating) av->donotelm = 0;
+      if (lgl->blocking) av->donotblk = 0;
+    }
+  }
+  return res;
+}
+
+static void lglsetdonotesched (LGL * lgl, int completed) {
+  AVar * av;
+  EVar * ev;
+  int idx;
+  assert (lgl->eliminating + lgl->blocking == 1);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    av = lglavar (lgl, idx);
+    ev = lglevar (lgl, idx);
+    if (lgl->eliminating) {
+      if (completed) av->donotelm = 0;
+      else if (ev->pos < 0) av->donotelm = 1;
+    }
+    if (lgl->blocking) {
+      if (completed) av->donotblk = 0;
+      else if (ev->pos < 0) av->donotblk = 1;
+    }
+  }
+}
+
+static int lglblkdone (LGL * lgl) {
+  if (!lglsmallirr (lgl)) return 1;
+  if (lglterminate (lgl)) return 1;
+  if (lglmtstk (&lgl->esched)) return 1;
+  if (lgl->stats->blk.steps >= lgl->limits->blk.steps) return 1;
+  return 0;
+}
+
+static void lglblock (LGL * lgl) {
+  int oldrem = lgl->blkrem, oldall = lgl->blkall;
+  int oldirr = lgl->stats->irr.clauses.cur;
+  int idx, count, all, rem, success;
+  Stk blocked[5];
+  assert (lglsmallirr (lgl));
+  assert (!lgl->simp);
+  assert (!lgl->dense);
+  assert (!lgl->eliminating);
+  assert (!lgl->blocking);
+  assert (!lgl->occs);
+  lglstart (lgl, &lgl->times->block);
+  if (lgl->level) lglbacktrack (lgl, 0);
+  lgl->simp = lgl->blocking = lgl->occs = 1;
+  lgl->stats->blk.count++;
+  lglgc (lgl);
+  assert (lgl->frozen);
+  assert (!(oldall && !oldrem));
+  all = !oldrem || !oldall;
+  if (all)
+    lglprt (lgl, 1,
+      "[block-%d] scheduling all variables this time",
+      lgl->stats->blk.count);
+  else if (!lgleschedrem (lgl, 1)) all = 1, oldrem = 0;
+  if (!all) assert (!lgl->donotsched), lgl->donotsched = 1;
+  lgldense (lgl, 1);
+  if (!all) assert (lgl->donotsched), lgl->donotsched = 0;
+  lglsetblklim (lgl);
+  CLR (blocked);
+  count = 0;
+  if (!lgl->opts->blkresched.val)
+    assert (!lgl->donotsched), lgl->donotsched = 1;
+  while (!lglblkdone (lgl)) {
+    idx = lglpopesched (lgl);
+    lglavar (lgl, idx)->donotblk = 1;
+    if (!lglisfree (lgl, idx)) continue;
+    if (lglispure (lgl, -idx)) count += lglpurelit (lgl, -idx);
+    else if (lglispure (lgl, idx)) count += lglpurelit (lgl, idx);
+    else {
+      if (lglocc (lgl, -idx) > lglocc (lgl, idx)) idx = -idx;
+      count += lglblocklit (lgl, idx, blocked);
+      count += lglblocklit (lgl, -idx, blocked);
+    }
+  }
+  if (!lgl->opts->blkresched.val)
+    assert (lgl->donotsched), lgl->donotsched = 0;
+  rem = lglcntstk (&lgl->esched);
+  if (!rem) {
+    lglprt (lgl, 1,
+      "[block-%d] fully completed",
+      lgl->stats->blk.count);
+    lgl->blkrtc = 1;
+  } else {
+    lglprt (lgl, 1,
+      "[block-%d] incomplete %d not tried %.0f%%",
+      lgl->stats->blk.count, rem, lglpcnt (rem, lgl->nvars - 2));
+  }
+  lglsetdonotesched (lgl, !rem);
+  lglrelstk (lgl, &lgl->esched);
+  lglsparse (lgl);
+  lglgc (lgl);
+  lglrelstk (lgl, blocked+2);
+  lglrelstk (lgl, blocked+3);
+  lglrelstk (lgl, blocked+4);
+  lgl->blkrem = rem > 0;
+  lgl->blkall = all && lgl->blkrem;
+  lglprt (lgl, 1,
+    "[block-%d] transition to [ all %d rem %d ] state",
+    lgl->stats->blk.count, lgl->blkall, lgl->blkrem);
+  assert (lgl->simp && lgl->blocking && lgl->occs);
+  lgl->blocking = lgl->simp = lgl->occs = 0;
+  lgl->stats->irrprgss += count;
+  lglprt (lgl, 1,
+    "[block-%d] eliminated %d blocked clauses",
+    lgl->stats->blk.count, count);
+  if (!lgl->blkrtc &&
+      lgl->stats->blk.count <= lgl->opts->blksuccessmaxwortc.val) {
+    success = 1;
+    lglprt (lgl, 1,
+      "[block-%d] considered successful since not run to completion yet",
+      lgl->stats->blk.count);
+  } else if (count) {
+    success = (oldirr/lgl->opts->blksuccessrat.val <= count);
+    if (!success)
+      lglprt (lgl, 1,
+	"[block-%d] %d < 1/%d * %d = %d considered unsuccessful",
+	lgl->stats->blk.count, count, lgl->opts->blksuccessrat.val,
+	oldirr, oldirr/lgl->opts->blksuccessrat.val);
+  } else success = 0;
+  LGLUPDPEN (blk, success);
+  lglrep (lgl, 2, 'k');
+  lglstop (lgl);
+  assert (!lgl->mt);
+}
+
+static void lglsetccelim (LGL * lgl) {
+  int count = lgl->stats->cce.count - lgl->opts->cceboostdel.val;
+  int64_t limit, irrlim;
+  int pen, szpen;
+  if (lgl->opts->ccertc.val > 1) {
+    lgl->limits->cce.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[cce-%d] really no limit (run to completion)",
+      lgl->stats->cce.count);
+  } else if (lgl->opts->ccertc.val ||
+      (count > 0 &&
+       lglrem (lgl) < lgl->opts->ccertcintvlim.val &&
+       !(count % lgl->opts->ccertcint.val))) {
+    limit = 4000000000ll;
+    lgl->limits->cce.steps = lgl->stats->cce.steps + limit;
+    lglprt (lgl, 1,
+       "[cce-%d] almost no limit of %lld steps",
+       lgl->stats->cce.count, (LGLL) limit);
+  } else {
+    limit = (lgl->opts->ccereleff.val*lglvisearch (lgl))/1000;
+    if (limit < lgl->opts->ccemineff.val) limit = lgl->opts->ccemineff.val;
+    if (lgl->opts->ccemaxeff.val >= 0 && limit > lgl->opts->ccemaxeff.val)
+      limit = lgl->opts->ccemaxeff.val;
+    if (count > 0 &&
+        (count <= 1 || !(count % lgl->opts->cceboostint.val)) &&
+        lgl->opts->boost.val &&
+	lgl->nvars < lgl->opts->cceboostvlim.val) {
+      lglprt (lgl, 1,
+        "[cce-%d] boosting limit by %d",
+	lgl->stats->cce.count, lgl->opts->cceboost.val);
+      limit *= lgl->opts->cceboost.val;
+    }
+    limit >>= (pen = lgl->limits->cce.pen + (szpen = lglszpen (lgl)));
+    irrlim = (lgl->stats->irr.clauses.cur) >> szpen;
+    if (lgl->opts->irrlim.val && limit < irrlim) {
+      limit = irrlim;
+      lglprt (lgl, 1,
+  "[cce-%d] limit of %lld steps based on %d irredundant clauses penalty %d",
+	lgl->stats->cce.count,
+	(LGLL) limit, lgl->stats->irr.clauses.cur, szpen );
+    } else
+      lglprt (lgl, 1,
+	"[cce-%d] limit of %lld steps penalty %d = %d + %d",
+	lgl->stats->cce.count, (LGLL) limit,
+	pen, lgl->limits->cce.pen, szpen);
+    lgl->limits->cce.steps = lgl->stats->cce.steps + limit;
+  }
+}
+
+#define CCELOGLEVEL 2
+
+static void lglsignedmark2 (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  int bit = 1 << (2 + (lit < 0));
+  if (av->mark & bit) return;
+  av->mark |= bit;
+}
+
+static void lglsignedunmark2 (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  int bit = 1 << (2 + (lit < 0));
+  if (!(av->mark & bit)) return;
+  av->mark &= ~bit;
+}
+
+static int lglsignedmarked2 (LGL * lgl, int lit) {
+  AVar * av = lglavar (lgl, lit);
+  int bit = 1 << (2 + (lit < 0));
+  return av->mark & bit;
+}
+
+static int lglabcecls (LGL * lgl, int lit, const int * c) {
+  int other, found = 0;
+  const int * p;
+  for (p = c; (other = *p); p++)
+    if (other == -lit) found++;
+    else if (lglsignedmarked (lgl, -other)) return 1;
+  assert (found == 1);
+  return 0;
+}
+
+static int lglabce (LGL * lgl, int lit) {
+  const int * p, * w, * eow, * c;
+  int blit, tag, other, cls[4];
+  HTS * hts;
+  assert (!lglifrozen (lgl, lit));
+  hts = lglhts (lgl, -lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  cls[0] = -lit, cls[3] = 0;
+  for (p = w; p < eow; p++) {
+    if (lgl->limits->cce.steps <= INCSTEPS (cce.steps)) return 0;
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (blit & REDCS) continue;
+    if (tag == LRGCS) continue;
+    other = blit >> RMSHFT;
+    cls[1] = other;
+    if (tag == BINCS) cls[2] = 0, c = cls;
+    else if (tag == TRNCS) cls[2] = *p, c = cls;
+    else assert (tag == OCCS), c = lglidx2lits (lgl, 0, other);
+    if (!lglabcecls (lgl, lit, c)) return 0;
+  }
+  return 1;
+}
+
+static int lglcceclause (LGL * lgl,
+                         const int * c, 
+			 int igntag,
+			 int cce) {
+  int other, res, nextala, nextcla, lit, blit, tag, other2, i, j, n;
+  int ala, first, old, prev, steps, lidx;
+  int * newtop, * d, * q, * r;
+  const int * p, * eow, * w;
+  ptrdiff_t delta;
+  HTS * hts;
+  LOGCLS (CCELOGLEVEL, c, "trying CCE on clause");
+  assert (lglmtstk (&lgl->cce->extend));
+  assert (lglmtstk (&lgl->cce->cla));
+  assert (lglmtstk (&lgl->seen));
+  for (p = c; (other = *p); p++) {
+    assert (!lglmarked (lgl, other));
+    lglpushstk (lgl, &lgl->seen, other);
+    lglpushstk (lgl, &lgl->cce->cla, other);
+    lglsignedmark (lgl, other);
+  }
+  n = lglcntstk (&lgl->seen);
+  for (i = n-1; i > 0; i--) {
+    j = lglrand (lgl) % (i + 1);
+    if (j == i) continue;
+    SWAP (int, lgl->seen.start[i], lgl->seen.start[j]);
+    SWAP (int, lgl->cce->cla.start[i], lgl->cce->cla.start[j]);
+  }
+  nextcla = nextala = res = 0;
+ALA:
+  while (!res && nextala < lglcntstk (&lgl->seen)) {
+    lit = lglpeek (&lgl->seen, nextala++);
+    assert (lglsignedmarked (lgl, lit));
+    assert (!lglsignedmarked (lgl, -lit));
+    hts = lglhts (lgl, lit);
+    w = newtop = lglhts2wchs (lgl, hts);
+    eow = w + hts->count;
+    steps = 0;
+    for (p = w; !res && p < eow; p++) {
+      steps++;
+      blit = *p;
+      *newtop++ = blit;
+      tag = blit & MASKCS;
+      if (tag == TRNCS || tag == LRGCS) *newtop++ = *++p;
+      if (tag == OCCS) continue;
+      if (blit & REDCS) continue;
+      other = blit >> RMSHFT;
+      if (lglsignedmarked (lgl, -other)) continue;
+      if (tag == BINCS) {
+	if (lglsignedmarked (lgl, other)) {
+	  if (igntag == BINCS) {
+	    if (c[0] == lit && c[1] == other) continue;
+	    if (c[1] == lit && c[0] == other) continue;
+	  }
+	  LOG (CCELOGLEVEL, 
+	       "ALA on binary clause %d %d results in ATE", lit, other);
+	  res = 1;
+	} else {
+	  assert (!lglmarked (lgl, other));
+	  LOG (CCELOGLEVEL, "ALA %d through binary clause %d %d", 
+	       -other, lit, other);
+	  lglsignedmark (lgl, -other);
+	  lglpushstk (lgl, &lgl->seen, -other);
+	}
+      } else if (tag == TRNCS) {
+	other2 = *p;
+	if (lglsignedmarked (lgl, -other2)) continue;
+	if (lglsignedmarked (lgl, other)) {
+	  if (lglsignedmarked (lgl, other2)) {
+	    if (igntag == TRNCS) {
+	      if (c[0] == lit && c[1] == other && c[2] == other2) continue;
+	      if (c[0] == lit && c[2] == other && c[1] == other2) continue;
+	      if (c[1] == lit && c[0] == other && c[2] == other2) continue;
+	      if (c[1] == lit && c[2] == other && c[0] == other2) continue;
+	      if (c[2] == lit && c[0] == other && c[1] == other2) continue;
+	      if (c[2] == lit && c[1] == other && c[0] == other2) continue;
+	    }
+	    LOG (CCELOGLEVEL,
+	      "ALA on ternary clause %d %d %d results in ATE",
+	      lit, other, other2);
+	    res = 1;
+	  } else {
+	    assert (!lglmarked (lgl, other2));
+	    LOG (CCELOGLEVEL, 
+	         "ALA %d through ternary clause %d %d %d (1st case)",
+		 -other2, lit, other, other2);
+	    lglsignedmark (lgl, -other2);
+	    lglpushstk (lgl, &lgl->seen, -other2);
+	  }
+	} else if (lglsignedmarked (lgl, other2)) {
+	  assert (!lglmarked (lgl, other));
+	  LOG (CCELOGLEVEL, 
+	      "ALA %d through ternary clause %d %d %d (2nd case)",
+	      -other, lit, other, other2);
+	  lglsignedmark (lgl, -other);
+	  lglpushstk (lgl, &lgl->seen, -other);
+	}
+      } else {
+	assert (tag == LRGCS);
+	d = lglidx2lits (lgl, 0, (lidx = *p));
+	if (d == c) continue;
+	if (d[0] == lit) SWAP (int, d[0], d[1]);
+	assert (d[1] == lit);
+	if (lglsignedmarked (lgl, -d[0])) continue;
+	for (q = d + 2; (other = *q); q++) {
+	  if (lglsignedmarked (lgl, -other)) break;
+	  if (!lglsignedmarked (lgl, other)) break;
+	}
+	if (other) {
+	  newtop -= 2, assert (w <= newtop);
+	  SWAP (int, d[1], *q);
+	  assert (d[1] == other);
+          delta = lglwchlrg (lgl, d[1], d[0], 0, lidx);
+	  if (delta) w += delta, p += delta, newtop += delta, eow += delta;
+	} else if (lglsignedmarked (lgl, d[0])) {
+	  LOGCLS (CCELOGLEVEL, d, "ATE after ALA on large clause");
+	  res = 1;
+	} else {
+	  ala = -d[0];
+	  assert (!lglmarked (lgl, ala));
+	  LOGCLS (CCELOGLEVEL, d, "ALA %d through large clause", ala);
+	  lglsignedmark (lgl, ala);
+	  lglpushstk (lgl, &lgl->seen, ala);
+	}
+      }
+    }
+    assert (newtop <= eow);
+    while (p < eow) *newtop++ = *p++;
+    lglshrinkhts (lgl, hts, newtop - w);
+    if (lgl->limits->cce.steps <= ADDSTEPS (cce.steps, steps)) goto DONE;
+  }
+  if (res || !lgl->opts->block.val || cce < 3) goto SKIPCLA;
+  while (!res && nextcla < lglcntstk (&lgl->cce->cla)) {
+    lit = lglpeek (&lgl->cce->cla, nextcla++);
+    if (lglifrozen (lgl, lit)) continue;
+    assert (lglsignedmarked (lgl, lit));
+    assert (!lglsignedmarked (lgl, -lit));
+    hts = lglhts (lgl, -lit);
+    w = lglhts2wchs (lgl, hts);
+    eow = w + hts->count;
+    old = lglcntstk (&lgl->cce->cla);
+    first = 1;
+    for (p = w; p < eow; p++) {
+      if (lgl->limits->cce.steps <= INCSTEPS (cce.steps)) goto DONE;
+      blit = *p;
+      tag = blit & MASKCS;
+      if (tag == TRNCS || tag == LRGCS) p++;
+      if (tag == LRGCS) continue;
+      if (blit & REDCS) continue;
+      other = blit >> RMSHFT;
+      if (first) {
+	if (tag == BINCS) {
+	  if (lglsignedmarked (lgl, -other)) continue;
+	  if (!lglsignedmarked (lgl, other))
+	    lglpushstk (lgl, &lgl->cce->cla, other);
+	} else if (tag == TRNCS) {
+	  if (lglsignedmarked (lgl, -other)) continue;
+	  if (lglsignedmarked (lgl, -(other2 = *p))) continue;
+	  if (!lglsignedmarked (lgl, other))
+	    lglpushstk (lgl, &lgl->cce->cla, other);
+	  if (!lglsignedmarked (lgl, other2))
+	    lglpushstk (lgl, &lgl->cce->cla, other2);
+	} else { 
+	  assert (tag == OCCS);
+	  d = lglidx2lits (lgl, 0, other);
+	  assert (d != c);
+	  for (q = d; (other = *q); q++) {
+	    if (other == -lit) continue;
+	    if (lglsignedmarked (lgl, -other)) break;
+	  }
+	  if (other) continue;
+	  for (q = d; (other = *q); q++)
+	    if (other != -lit && !lglsignedmarked (lgl, other))
+	      lglpushstk (lgl, &lgl->cce->cla, other);
+	}
+	first = 0;
+      } else {
+	r = lgl->cce->cla.start + old;
+	if (tag == BINCS) {
+	  if (lglsignedmarked (lgl, -other)) continue;
+	  for (q = r; q < lgl->cce->cla.top; q++)
+	    if (*q == other) *r++ = *q;
+	} else if (tag == TRNCS) {
+	  if (lglsignedmarked (lgl, -other)) continue;
+	  if (lglsignedmarked (lgl, -(other2 = *p))) continue;
+	  for (q = r; q < lgl->cce->cla.top; q++)
+	    if (*q == other || *q == other2) *r++ = *q;
+	} else {
+	  assert (tag == OCCS);
+	  d = lglidx2lits (lgl, 0, other);
+	  assert (d != c);
+	  for (q = d; (other = *q); q++) {
+	    if (other == -lit) continue;
+	    if (lglsignedmarked (lgl, -other)) break;
+	  }
+	  if (other) continue;
+	  for (q = d; (other = *q); q++) {
+	    if (other == -lit) continue;
+	    assert (other != lit);
+	    assert (!lglsignedmarked2 (lgl, other));
+	    assert (!lglsignedmarked2 (lgl, -other));
+	    lglsignedmark2 (lgl, other);
+	  }
+	  for (q = r; q < lgl->cce->cla.top; q++)
+	    if (lglsignedmarked2 (lgl, (other = *q)))
+	      *r++ = other;
+	  for (q = d; (other = *q); q++) {
+	    if (other == -lit) continue;
+	    assert (other != lit);
+	    assert (lglsignedmarked2 (lgl, other));
+	    lglsignedunmark2 (lgl, other);
+	  }
+	}
+	if ((lgl->cce->cla.top = r) == lgl->cce->cla.start + old) break;
+      }
+    } 
+    if (lglcntstk (&lgl->cce->cla) > old) {
+      nextcla = 0;
+      lglpushstk (lgl, &lgl->cce->extend, lit);
+      for (q = lgl->cce->cla.start; q < lgl->cce->cla.start + old; q++)
+	if (*q != lit) lglpushstk (lgl, &lgl->cce->extend, *q);
+      lglpushstk (lgl, &lgl->cce->extend, 0);
+    }
+    for (q = lgl->cce->cla.start + old; !res && q < lgl->cce->cla.top; q++) {
+      if (lglsignedmarked (lgl, -*q)) {
+	LOG (CCELOGLEVEL, "CLA on %d results in ATE", *q);
+	res = 1;
+      } else {
+	LOG (CCELOGLEVEL, "CLA %d on %d", *q, lit);
+	lglpushstk (lgl, &lgl->seen, *q);
+	lglsignedmark (lgl, *q);
+      }
+    }
+    if (!res && p == eow && nextala < lglcntstk (&lgl->seen)) goto ALA;
+  }
+SKIPCLA:
+  if (res) {
+    LOGCLS (CCELOGLEVEL, c, "ATE clause");
+    lgl->stats->cce.ate++;
+  } else if (lgl->opts->block.val && cce >= 2) {
+   for (p = lgl->cce->cla.start; p < lgl->cce->cla.top; p++)
+     if (!lglifrozen (lgl, (other = *p)) && (res = lglabce (lgl, other))) 
+       break;
+    if (res) {
+      LOGCLS (CCELOGLEVEL, c, "ABCE on %d clause", other);
+      lglpushstk (lgl, &lgl->cce->extend, other);
+      for (p = lgl->cce->cla.start; p < lgl->cce->cla.top; p++)
+        if (*p != other) lglpushstk (lgl, &lgl->cce->extend, *p);
+      lglpushstk (lgl, &lgl->cce->extend, 0);
+      lgl->stats->cce.abce++;
+    }
+  }
+  if (res) lgl->stats->cce.eliminated++;
+DONE:
+  lglpopnunmarkstk (lgl, &lgl->seen);
+  lglclnstk (&lgl->cce->cla);
+  if (res && !lglmtstk (&lgl->cce->extend)) {
+    assert (cce >= 2);
+    assert (lgl->opts->block.val);
+    prev = 0;
+    for (p = lgl->cce->extend.start; p < lgl->cce->extend.top; p++) {
+      lit = *p;
+      lglepush (lgl, lit);
+      if (!prev) assert (!lglifrozen (lgl, lit)), lglblockinglit (lgl, lit);
+      prev = lit;
+    }
+  }
+  lglclnstk (&lgl->cce->extend);
+  return res;
+}
+
+static const char * lglcce2str (int cce) {
+  assert (0 <= cce), assert (cce <= 3);
+  if (cce == 3) return "ACCE";
+  else if (cce == 2) return "ABCE";
+  else if (cce == 1) return "ATE";
+  else return "none";
+}
+
+static int lglccesmallclauses (LGL * lgl, int lit) {
+  int idx = abs (lit), blit, tag, red, other, other2;
+  HTS * hts = lglhts (lgl, lit);
+  const int * p, * w, * eow;
+  CCE * cce = lgl->cce;
+  Stk * clauses;
+  assert (cce);
+  if (!lglisfree (lgl, lit)) return 1;
+  clauses = &cce->clauses;
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  INCSTEPS (cce.steps);
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == OCCS) continue;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    other = blit >> RMSHFT;
+    if (abs (other) < idx) continue;
+    if (!lglisfree (lgl, other)) continue;
+    if (tag == TRNCS) {
+      other2 = *p;
+      if (abs (other2) < idx) continue;
+      if (abs (other2) < abs (other)) continue;
+      if (!lglisfree (lgl, other2)) continue;
+      lglpushstk (lgl, clauses, other2);
+      cce->trn++;
+    } else {
+      assert (tag == BINCS);
+      cce->bin++;
+    }
+    lglpushstk (lgl, clauses, other);
+    lglpushstk (lgl, clauses, lit);
+    lglpushstk (lgl, clauses, 0);
+  }
+  return 1;
+}
+
+static void lglccesmall (LGL * lgl, int cce, int round) {
+  int count, valid, invalid, tried, eliminated, elim2, elim3;
+  int size, lit, tag;
+  const int * p, * c;
+  Stk * clauses;
+  assert (lgl->cce);
+  clauses = &lgl->cce->clauses;
+  assert (!lgl->cce->clauses.start);
+  lglrandlitrav (lgl, lglccesmallclauses);
+  lglfitstk (lgl, &lgl->cce->clauses);
+  count = lgl->cce->bin + lgl->cce->trn;
+  lglprt (lgl, 1,
+    "[cce-%d-%d] scheduling %d clauses = %d binary + %d ternary",
+    lgl->stats->cce.count, round, count, lgl->cce->bin, lgl->cce->trn);
+  tried = eliminated = invalid = elim2 = elim3 = 0;
+  for (c = clauses->start; c < clauses->top; c = p + 1) {
+    if (lgl->mt) break;
+    if (lglterminate (lgl)) break;
+    if (lgl->limits->cce.steps <= lgl->stats->cce.steps) break;
+    valid = 1;
+    for (p = c; (lit = *p); p++)
+      if (!lglisfree (lgl, lit))
+	valid = 0;
+    if (valid) {
+      tried++;
+      size = p - c;
+      assert (2 <= size), assert (size <= 3);
+      tag = size == 2 ? BINCS : TRNCS;
+      if (!lglcceclause (lgl, c, tag, cce)) continue;
+      eliminated++;
+      if (size == 2) {
+        if (!lglrmvbcls (lgl, c[0], c[1]))
+	  lgldrupligdelclsarg (lgl, c[0], c[1], 0);
+	elim2++;
+      } else {
+	assert (size == 3);
+        if (!lglrmvtcls (lgl, c[0], c[1], c[2]))
+	  lgldrupligdelclsarg (lgl, c[0], c[1], c[2], 0);
+	elim3++;
+      }
+    } else invalid++;
+  }
+  assert (count >= tried + invalid);
+  lglrelstk (lgl, &lgl->cce->clauses);
+  if (tried)
+    lglprt (lgl, 1,
+      "[cce-%d-%d] tried to eliminate %d small clauses %.0f%%",
+      lgl->stats->cce.count, round, tried, lglpcnt (tried, count));
+  if (elim2)
+    lglprt (lgl, 1,
+      "[cce-%d-%d] eliminated %d binary clauses %.0f%%",
+      lgl->stats->cce.count, round, elim2, lglpcnt (elim2, lgl->cce->bin));
+  if (elim3)
+    lglprt (lgl, 1,
+      "[cce-%d-%d] eliminated %d ternary clauses %.0f%%",
+      lgl->stats->cce.count, round, elim3, lglpcnt (elim3, lgl->cce->trn));
+  if (eliminated)
+    lglprt (lgl, 1,
+      "[cce-%d-%d] eliminated %d small clauses %.0f%%",
+      lgl->stats->cce.count, round, eliminated, lglpcnt (eliminated, count));
+}
+
+static int lglcce (LGL * lgl) {
+  int oldvars = lgl->nvars, cce, lenlim, startirr, success;
+  int oldirr, eliminated, total, idx, round;
+  int completedsmall, completedlarge;
+  int64_t oldsteps, deltasteps;
+  int elmlarge, elmsmall;
+  lglstart (lgl, &lgl->times->cce);
+  lgl->stats->cce.count++;
+  lglsetccelim (lgl);
+  round = total = 0;
+  startirr = lgl->stats->irr.clauses.cur;
+RESTART:
+  round++;
+  lenlim = INT_MAX;
+  cce = lgl->opts->cce.val;
+  if (cce == 3 && lgl->ccertc < 2 &&
+      lgl->opts->cce3wait.val >= lgl->stats->cce.count) {
+    lglprt (lgl, 2,
+      "[cce-%d-%d] restricted to ABCE since ccertc=%s",
+      lgl->stats->cce.count, round, lglcce2str (lgl->ccertc));
+    cce = 2;
+  }
+  if (cce == 2 && lgl->ccertc < 1 &&
+      lgl->opts->cce2wait.val >= lgl->stats->cce.count) {
+    lglprt (lgl, 2,
+      "[cce-%d-%d] restricted to ATE since ccertc=%s",
+      lgl->stats->cce.count, round, lglcce2str (lgl->ccertc));
+   cce = 1;
+  }
+  if (cce > 1 && !(lgl->stats->cce.count % lgl->opts->cceateint.val)) {
+    lglprt (lgl, 2,
+      "[cce-%d-%d] restricted to ATE due to ATE interval %d",
+      lgl->stats->cce.count, round, lgl->opts->cceateint.val);
+    cce = 1;
+  }
+  oldirr = lgl->stats->irr.clauses.cur;
+  lglprt (lgl, 2, "[cce-%d-%d] starting round %d (%s)",
+          lgl->stats->cce.count, round, round, lglcce2str (cce));
+  assert (!lgl->simp && !lgl->cceing && !lgl->occs);
+  lgl->cceing = lgl->simp = 1;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  NEW (lgl->cce, 1);
+  NEW (lgl->cce->rem, oldvars);
+  for (idx = 2; idx < oldvars; idx++) lgl->cce->rem[idx] = INT_MAX;
+  lglgc (lgl);
+  assert (lgl->frozen);
+  lgldense (lgl, 1);
+  oldsteps = lgl->stats->cce.steps;
+  elmlarge = 0;
+  while (!lgl->mt && 
+         lenlim > 4 &&
+	 !lglterminate (lgl) &&
+	 lgl->limits->cce.steps > lgl->stats->cce.steps) {
+    int maxlen = 0, count;
+    const int * p, * c;
+    Stk lidcs;
+    CLR (lidcs);
+    for (c = lgl->irr.start; c < lgl->irr.top; c = p + 1) {
+      int len, lidx;
+      if (*(p = c) >= NOTALIT) continue;
+      while (*p) p++;
+      len = p - c;
+      if (len >= lenlim) continue;
+      if (len < maxlen) continue;
+      if (len > maxlen) {
+	lglclnstk (&lidcs);
+	maxlen = len;
+      }
+      lidx = c - lgl->irr.start;
+      lglpushstk (lgl, &lidcs, lidx);
+    }
+    ADDSTEPS (cce.steps, lglcntstk (&lgl->irr)/128);
+    count = lglcntstk (&lidcs);
+    lglprt (lgl, 2,
+      "[cce-%d-%d] scheduling %d clauses of length %d",
+      lgl->stats->cce.count, round, count, maxlen);
+    eliminated = 0;
+    for (p = lidcs.start;
+         p < lidcs.top &&
+	 !lgl->mt &&
+	 !lglterminate (lgl) &&
+	 lgl->limits->cce.steps > lgl->stats->cce.steps; 
+	 p++) {
+      int lidx = *p;
+      c = lgl->irr.start + lidx;
+      if (*c >= NOTALIT) continue;
+      if (!lglcceclause (lgl, c, OCCS, cce)) continue;
+      lgldrupligdelclsaux (lgl, c);
+      lglrmlcls (lgl, lidx, 0);
+      eliminated++;
+    }
+    elmlarge += eliminated;
+    lglrelstk (lgl, &lidcs);
+    lenlim = maxlen;
+    lglprt (lgl, 1 + !eliminated,
+      "[cce-%d-%d] eliminated %d clauses out of %d (%.0f%%) of length %d",
+      lgl->stats->cce.count, round,
+      eliminated, count, lglpcnt (eliminated, count), maxlen);
+  }
+  completedlarge = (lgl->limits->cce.steps > lgl->stats->cce.steps);
+  if (completedlarge)
+    lglprt (lgl, 1,
+      "[cce-%d-%d] completed large round (%s)",
+      lgl->stats->cce.count, round, lglcce2str (cce));
+  else
+    lglprt (lgl, 1, 
+      "[cce-%d-%d] incomplete large round (%s)",
+      lgl->stats->cce.count, round, lglcce2str (cce));
+  deltasteps = lgl->stats->cce.steps - oldsteps;
+  lglprt (lgl, 1 + !elmlarge,
+    "[cce-%d-%d] eliminated %d large clauses in %lld steps",
+    lgl->stats->cce.count, round, elmlarge, (LGLL) deltasteps);
+  deltasteps /= 2;
+  if (LLMAX - deltasteps > lgl->limits->cce.steps) {
+    lgl->limits->cce.steps += deltasteps;
+    lglprt (lgl, 1,
+      "[cce-%d-%d] allowing another %lld steps for small clauses",
+      lgl->stats->cce.count, round, deltasteps);
+  } else {
+    lgl->limits->cce.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[cce-%d-%d] unlimited number of steps for small clauses",
+      lgl->stats->cce.count, round);
+  }
+  lglccesmall (lgl, cce, round);
+  elmsmall = oldirr - lgl->stats->irr.clauses.cur - elmlarge;
+  lglprt (lgl, 1 + !elmsmall,
+    "[cce-%d-%d] eliminated %d small clauses in %lld steps",
+    lgl->stats->cce.count, round, elmsmall,
+    (LGLL) lgl->stats->cce.steps - oldsteps - deltasteps);
+  completedsmall = (lgl->limits->cce.steps > lgl->stats->cce.steps);
+  COVER (!completedsmall && lgl->opts->ccertc.val > 1);
+  if (completedsmall)
+    lglprt (lgl, 1,
+      "[cce-%d-%d] completed small round (%s)",
+      lgl->stats->cce.count, round, lglcce2str (cce));
+  else
+    lglprt (lgl, 1, 
+      "[cce-%d-%d] incomplete small round (%s)",
+      lgl->stats->cce.count, round, lglcce2str (cce));
+  if (completedsmall && completedlarge) {
+    if (lgl->ccertc < cce) {
+      lgl->ccertc = cce;
+      lglprt (lgl, 1, 
+	"[cce-%d-%d] completed small and large (%s)",
+	lgl->stats->cce.count, round, lglcce2str (cce));
+    }
+  }
+  lglsparse (lgl);
+  lglgc (lgl);
+  lglrelstk (lgl, &lgl->cce->extend);
+  lglrelstk (lgl, &lgl->cce->cla);
+  DEL (lgl->cce->rem, oldvars);
+  DEL (lgl->cce, 1);
+  assert (oldirr >= lgl->stats->irr.clauses.cur);
+  eliminated = oldirr - lgl->stats->irr.clauses.cur;
+  total += eliminated;
+  lglprt (lgl, 1,
+    "[cce-%d-%d] eliminated %d covered clauses in round %d",
+    lgl->stats->cce.count, round, eliminated, round);
+  assert (lgl->simp && lgl->cceing);
+  lgl->cceing = lgl->simp = 0;
+  if (!lgl->mt &&
+      eliminated &&
+      !lglterminate (lgl) &&
+      round < lgl->opts->ccemaxround.val &&
+      lgl->limits->cce.steps > lgl->stats->cce.steps) goto RESTART;
+  lglprt (lgl, 1,
+    "[cce-%d] eliminated %d covered clauses in TOTAL during %d rounds",
+    lgl->stats->cce.count, total, round);
+  if (total) {
+    success = (startirr/lgl->opts->ccesuccessrat.val <= total);
+    if (!success)
+      lglprt (lgl, 1,
+	"[cce-%d] %d < 1/%d * %d = %d considered unsuccessful",
+	lgl->stats->cce.count, total, lgl->opts->ccesuccessrat.val,
+	startirr, startirr/lgl->opts->ccesuccessrat.val);
+  } else success = 0;
+  LGLUPDPEN (cce, success);
+  lglrep (lgl, 2, 'E');
+  lglstop (lgl);
+  lglbasicatestats (lgl);
+  return !lgl->mt;
+}
+
+static void lglsetelmlim (LGL * lgl, int * reschedptr) {
+  int count = lgl->stats->elm.count - lgl->opts->elmboostdel.val;
+  int pen, szpen, resched = 0;
+  int64_t limit, irrlim;
+  if (lgl->opts->elmrtc.val > 1) {
+    lgl->limits->elm.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[elim-%d] really no limit (run to completion)",
+      lgl->stats->elm.count);
+    resched = (lgl->opts->elmresched.val & 4);
+  } else if (lgl->opts->elmrtc.val ||
+             (count > 0 &&
+	      lglrem (lgl) < lgl->opts->elmrtcintvlim.val &&
+             !(count % lgl->opts->elmrtcint.val))) {
+    limit = 100000000000ll;
+    lgl->limits->elm.steps = lgl->stats->elm.steps + limit;
+    lglprt (lgl, 1,
+      "[elim-%d] almost no limit of %lld steps",
+      lgl->stats->elm.count, (LGLL) limit);
+    resched = (lgl->opts->elmresched.val & 4);
+  } else {
+    limit = (lgl->opts->elmreleff.val*lglvisearch (lgl))/1000;
+    if (limit < lgl->opts->elmineff.val) limit = lgl->opts->elmineff.val;
+    if (lgl->opts->elmaxeff.val >= 0 && limit > lgl->opts->elmaxeff.val)
+      limit = lgl->opts->elmaxeff.val;
+    if (count > 0 &&
+        (count == 1 ||
+        !(count % lgl->opts->elmboostint.val)) &&
+	lglrem (lgl) < lgl->opts->elmboostvlim.val &&
+        lgl->opts->boost.val &&
+        lgl->opts->elmboost.val > 1) {
+      lglprt (lgl, 1,
+        "[elim-%d] boosting limit by %d",
+	lgl->stats->elm.count, lgl->opts->elmboost.val);
+      limit *= lgl->opts->elmboost.val;
+      resched = (lgl->opts->elmresched.val & 2);
+    } else resched = (lgl->opts->elmresched.val & 1);
+    limit >>= (pen = lgl->limits->elm.pen + (szpen = lglszpen (lgl)));
+    irrlim = (lgl->stats->irr.clauses.cur) >> szpen;
+    if (lgl->opts->irrlim.val && limit < irrlim) {
+      limit = irrlim;
+      lglprt (lgl, 1,
+  "[elim-%d] limit of %lld steps based on %d irredundant clauses penalty %d",
+	lgl->stats->elm.count,
+	(LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+    } else
+      lglprt (lgl, 1,
+        "[elim-%d] limit of %lld steps penalty %d = %d + %d",
+	lgl->stats->elm.count, (LGLL) limit,
+	pen, lgl->limits->elm.pen, szpen);
+    lgl->limits->elm.steps = lgl->stats->elm.steps + limit;
+  }
+  lglprt (lgl, 1,					// TODO 2?
+    "[elim-%d] rescheduling of touched variables %s",
+    lgl->stats->elm.count, resched ? "enabled" : "disabled");
+  *reschedptr = resched;
+}
+
+static int lglforceschedall (LGL * lgl) {
+  const int oldonotsched = lgl->donotsched;
+  int idx, res = 0;
+  AVar * av;
+  assert (lgl->eliminating);
+  assert (lglmtstk (&lgl->esched));
+  assert (lgl->touching), lgl->touching = 0;
+  lgl->donotsched = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (lglifrozen (lgl, idx)) continue;
+    if (!lglisfree (lgl, idx)) continue;
+    av = lglavar (lgl, idx);
+    av->donotelm = 0;
+    lglesched (lgl, idx);
+    res++;
+  }
+  assert (!lgl->touching), lgl->touching = 1;
+  assert (!lgl->donotsched);
+  if (oldonotsched) lgl->donotsched = 1;
+  lglprt (lgl, 1,
+    "[elim-%d-%d] fully rescheduled %d variables %.0f%%",
+    lgl->stats->elm.count, lgl->elm->round,
+    res, lglpcnt (res, lgl->nvars - 2));
+  return res;
+}
+
+static void lgladdstrbincls (LGL * lgl, int a, int b) {
+  assert (lglisfree (lgl, a));
+  assert (lglisfree (lgl, b));
+  assert (lglmtstk (&lgl->clause));
+  lglpushstk (lgl, &lgl->clause, a);
+  lglpushstk (lgl, &lgl->clause, b);
+  lglpushstk (lgl, &lgl->clause, 0);
+  LOG (BWL, "strengthened binary clause", a, b);
+  lgldrupligaddcls (lgl, REDCS);
+  lgladdcls (lgl, 0, 0, 1);
+  lglclnstk (&lgl->clause);
+}
+
+static int lglbackwardlit (LGL * lgl,
+			   const int * clause, const int * skip,
+			   int size, int minlit,
+			   int *subptr, int *strptr) {
+  int res, blit, tag, red, other, other2, lidx, count, remove, hit;
+  const int druplig = lgl->opts->druplig.val;
+  const int * p, * w, * eow, * c, * l;
+  int marked, marked2, val;
+  Stk saved;
+  HTS * hts;
+  CLR (saved);
+  assert (!lgl->level);
+  lgl->stats->bkwd.tried.lits++;
+  LOGCLS (BWL, clause,
+    "backward subsume and strengthen clauses with %d by size %d clause",
+    minlit, size);
+  hit = res = 0;
+  hts = lglhts (lgl, minlit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; !res && p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    if (p == skip) continue;
+    red = blit & REDCS;
+    if (red) continue;
+    lgl->stats->bkwd.tried.occs++;
+    INCSTEPS (elm.steps);
+    if (tag == BINCS) {
+      if (size > 2) continue;
+      other = blit >> RMSHFT;
+      if (!lglisfree (lgl, other)) continue;
+      marked = lglmarked (lgl, other);
+      if (marked > 0) {
+	if (size == 2 && !hit++) continue;
+	LOG (BWL, "subsumed binary clause %d %d", minlit, other);
+	assert (!(w <= skip && skip < eow) || skip < p);
+	ADDSTEPS (elm.steps, 2);
+        if (druplig) lgldrupligdelclsarg (lgl, minlit, other, 0);
+	lglrmbcls (lgl, minlit, other, 0);
+	lgl->stats->bkwd.sub2++;
+	*subptr += 1;
+	res = 1;
+      } else if (marked < 0) {
+	LOG (BWL,
+	  "removing %d and thus strengthening binary clause %d %d",
+	  other, minlit, other);
+	assert (p != skip);
+	ADDSTEPS (elm.steps, 2);
+	lglunit (lgl, minlit);
+	lgl->stats->bkwd.str2++;
+	*strptr += 1;
+	res = 1;
+      }
+    } else if (tag == TRNCS) {
+      if (size > 3) continue;
+      other = blit >> RMSHFT;
+      other2 = *p;
+      if (!lglisfree (lgl, other)) continue;
+      if (!lglisfree (lgl, other2)) continue;
+      marked = lglmarked (lgl, other);
+      marked2 = lglmarked (lgl, other2);
+      if ((size == 2 && (marked > 0 || marked2 > 0)) ||
+          (size == 3 && marked > 0 && marked2 > 0)) {
+	if (size == 3 && !hit++) continue;
+	assert (!(w <= skip && skip < eow) || skip < p);
+	LOG (BWL,
+	  "subsumed ternary clause %d %d %d",
+	  minlit, other, other2);
+	ADDSTEPS (elm.steps, 3);
+        if (druplig) lgldrupligdelclsarg (lgl, minlit, other, other2, 0);
+	lglrmtcls (lgl, minlit, other, other2, 0);
+	lgl->stats->bkwd.sub3++;
+	*subptr += 1;
+	res = 1;
+      } else {
+	if (marked < 0 && marked2 > 0) {
+	  int tmp = other; other = other2; other2 = tmp;
+	} else if (marked <= 0 || marked2 >= 0) continue;
+	LOG (BWL,
+	  "removing %d and thus strengthening ternary clause %d %d %d",
+	  other2, minlit, other, other2);
+	assert (lglmarked (lgl, other) > 0);
+	assert (lglmarked (lgl, other2) < 0);
+	lgladdstrbincls (lgl, minlit, other);
+        if (druplig) lgldrupligdelclsarg (lgl, minlit, other, other2, 0);
+	lglrmtcls (lgl, minlit, other, other2, 0);
+	if (size == 3) {
+	  LOG (BWL,
+	    "removing %d and thus strengthening ternary clause %d %d %d",
+	    other2, minlit, other, -other2);
+          if (druplig) lgldrupligdelclsarg (lgl, minlit, other, -other2, 0);
+	  lglrmtcls (lgl, minlit, other, -other2, 0);
+	  lgl->stats->bkwd.str3self++;
+	}
+	ADDSTEPS (elm.steps, 3);
+	lgl->stats->bkwd.str3++;
+	*strptr += 1;
+	res = 1;
+      }
+    } else {
+      assert (tag == OCCS);
+      lidx = blit >> RMSHFT;
+      c = lglidx2lits (lgl, 0, lidx);
+      if (c == skip) continue;
+      INCSTEPS (elm.steps);
+      count = size;
+      remove = 0;
+      for (l = c; (other = *l); l++) {
+	val = lglval (lgl, other);
+	if (val > 0) { remove = INT_MAX; break; }
+	if (val < 0) continue;
+	assert (!val);
+	marked = lglmarked (lgl, other);
+	if (!marked) continue;
+	count--;
+	if (marked > 0) continue;
+	if (remove) { remove = INT_MAX; break; }
+	remove = other;
+      }
+      if (count > 0) continue;
+      if (remove == INT_MAX) continue;
+      if (!remove) {
+	assert (!(w <= skip && skip < eow) || skip < p);
+	LOGCLS (BWL, c, "subsumed large clause");
+	ADDSTEPS (elm.steps, (l - c));
+	if (druplig) lgldrupligdelclsaux (lgl, c);
+	lglrmlcls (lgl, lidx, 0);
+	lgl->stats->bkwd.subl++;
+	*subptr += 1;
+	res = 1;
+      } else if (lglsmallirr (lgl)) {
+	LOGCLS (BWL, c, "removing %d and thus strengthening clause", remove);
+	assert (lglmtstk (&lgl->clause));
+	assert (lglmtstk (&saved));
+	for (l = c; (other = *l); l++) {
+	  if (druplig) lglpushstk (lgl, &saved, other);
+	  if (other == remove) continue;
+	  val = lglval (lgl, other);
+	  if (val < 0) continue;
+	  assert (!val);
+	  lglpushstk (lgl, &lgl->clause, other);
+	}
+	lglpushstk (lgl, &lgl->clause, 0);
+	LOGCLS (BWL, lgl->clause.start, "strengthened clause");
+
+	if (druplig) {
+	  lgldrupligaddcls (lgl, REDCS);
+	  assert (l - c == lglcntstk (&saved));
+	  lglpushstk (lgl, &saved, 0);
+	  lgldrupligdelclsaux (lgl, saved.start);
+	  lglclnstk (&saved);
+	}
+	ADDSTEPS (elm.steps, (l - c));
+	lglrmlcls (lgl, lidx, 0);
+	if (l - c == size) lgl->stats->bkwd.strlself++;
+
+	lgladdcls (lgl, 0, 0, 1);
+	lglclnstk (&lgl->clause);
+	lgl->stats->bkwd.strl++;
+	*strptr += 1;
+	res = 1;
+      }
+    }
+  }
+  lglrelstk (lgl, &saved);
+  return res;
+}
+
+static int lglbackwardclause (LGL * lgl,
+                              const int * clause, const int * skip,
+			      int * subsumedptr, int * strengthenedptr) {
+  int lit, size, minlit, minlit2, minocc, minocc2, tmpocc, res, large;
+  const int * p;
+  long delta;
+  lgl->stats->bkwd.tried.clauses++;
+  INCSTEPS (elm.steps);
+  minocc = minlit = minocc2 = minlit2 = 0;
+  for (p = clause; (lit = *p); p++) {
+    lglmarkunmarked (lgl, lit);
+    tmpocc = lglocc (lgl, lit);
+    if (!minlit || tmpocc < minocc) {
+      minocc2 = minocc, minlit2 = minlit;
+      minocc = tmpocc, minlit = lit;
+    } else if (!minlit2 || tmpocc < minocc2) {
+      minocc2 = tmpocc, minlit2 = lit;
+    }
+  }
+  size = p - clause;
+  assert (size >= 2);
+  LOG (BWL, "minimum occurrence %d of literal %d", minocc, minlit);
+  LOG (BWL, "next minimum occurrence %d of literal %d", minocc2, minlit2);
+  large = (lgl->irr.start <= clause && clause < lgl->irr.top);
+  delta = large ? clause - lgl->irr.start : 0;
+  res = lglbackwardlit (lgl, clause, skip,
+		        size, minlit, subsumedptr, strengthenedptr);
+  if (!res) {
+    res = lglbackwardlit (lgl, clause, skip,
+			  size, minlit2, subsumedptr, strengthenedptr);
+  }
+  if (res && large) clause = lgl->irr.start + delta;
+  for (p = clause; (lit = *p); p++)
+    lglunmark (lgl, lit);
+  return res;
+}
+
+static void lglbackward (LGL * lgl, int * u, int * t,
+                         int64_t steps, int * completedptr) {
+  int idx, sign, lit, blit, red, tag, other, other2, clause[4], * w;
+  int oldtouched, newtouched, round, touched;
+  int64_t limit, delta, scaled;
+  const int * p, * eow, * c;
+  HTS * hts;
+  Stk stk;
+  lglstart (lgl, &lgl->times->backward);
+  lgl->elm->bkwdocclim =
+    lglfactor (lgl, lgl->opts->bkwdocclim.val, lgl->stats->elm.count);
+  CLR (stk);
+  *u = *t = 0;
+  if (LLMAX/lgl->opts->bkwdscale.val <= steps/100) scaled = LLMAX;
+  else scaled = steps/100 * lgl->opts->bkwdscale.val;
+  if (lgl->limits->elm.steps - scaled <= lgl->stats->elm.steps)
+    limit = lgl->limits->elm.steps;
+  else limit = lgl->stats->elm.steps + scaled;
+  delta = limit - lgl->stats->elm.steps;
+  lglprt (lgl, 1,
+    "[elim-%d-%d] backward subsumption/strengthening limit %lld",
+    lgl->stats->elm.count, lgl->elm->round, delta);
+  round = 0;
+RESTARTOUCHED:
+  round++;
+  oldtouched = lglcntstk (&lgl->elm->touched.stk);
+  assert (oldtouched >= lgl->elm->touched.mt);
+  oldtouched -= lgl->elm->touched.mt;
+  lglprt (lgl, 1,
+    "[elim-%d-%d-%d] backward checking %d touched variables %.0f%%",
+    lgl->stats->elm.count, lgl->elm->round, round,
+    oldtouched, lglpcnt (oldtouched, lglrem (lgl)));
+  *completedptr = 0;
+  while ((idx = lglpoptouched (lgl))) {
+    for (sign = -1; sign <= 1; sign += 2) {
+RESTARTLIT:
+      if (lgl->mt) goto DONE;
+      if (lglterminate (lgl)) goto DONE;
+
+      // TODO DID NOT WORK?  REMOVE OR FIX?
+      // if (!lglsyncunits (lgl)) goto DONE;
+
+      if (!lglisfree (lgl, idx)) continue;
+      if (INCSTEPS (elm.steps) >= limit) goto DONE;
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      lglclnstk (&stk);
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag != BINCS) continue;
+	red = blit & REDCS;
+	if (red) continue;
+	lglpushstk (lgl, &stk, blit);
+      }
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag != TRNCS) continue;
+	red = blit & REDCS;
+	if (red) continue;
+	lglpushstk (lgl, &stk, blit);
+	lglpushstk (lgl, &stk, *p);
+      }
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	red = blit & REDCS;
+	if (!red && (tag == BINCS || tag == TRNCS)) continue;
+	lglpushstk (lgl, &stk, blit);
+	if (tag == TRNCS || tag == LRGCS)
+	  lglpushstk (lgl, &stk, *p);
+      }
+      assert (lglcntstk (&stk) == hts->count);
+      memcpy (w, stk.start, lglcntstk (&stk) * sizeof *w);
+      clause[0] = lit;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	if (red) continue;
+	if (INCSTEPS (elm.steps) >= limit) goto DONE;
+	if (tag == BINCS) {
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  clause[1] = other, clause[2] = 0;
+	  if (!lglbackwardclause (lgl, clause, p, u, t)) continue;
+	} else if (tag == TRNCS) {
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	  clause[1] = other, clause[2] = other2, clause[3] = 0;
+	  if (!lglbackwardclause (lgl, clause, p, u, t)) continue;
+	} else { assert (tag == OCCS); continue; }
+	if (lglflush (lgl)) goto RESTARTLIT;
+	else goto DONE;
+      }
+    }
+  }
+  for (c = lgl->irr.start; c < lgl->irr.top; c = p + 1) {
+    if (!lglsmallirr (lgl)) goto DONE;
+    if (INCSTEPS (elm.steps) >= limit) goto DONE;
+    if (*(p = c) >= NOTALIT) continue;
+    touched = 0;
+    while ((lit = *p)) {
+      if (!touched && lgltouched (lgl, lit)) touched = 1;
+      p++;
+    }
+    if (touched) lglbackwardclause (lgl, c, c, u, t);
+  }
+  if (round < lgl->opts->bkwdroundlim.val &&
+      !lglmtstk (&lgl->elm->touched.stk))
+    goto RESTARTOUCHED;
+  *completedptr = 1;
+DONE:
+  newtouched = lglcntstk (&lgl->elm->touched.stk);
+  assert (newtouched >= lgl->elm->touched.mt);
+  newtouched -= lgl->elm->touched.mt;
+  if (*completedptr)
+    assert (!newtouched),
+    lglprt (lgl, 1,
+      "[elim-%d-%d-%d] fully completed backward checking in %d rounds",
+      lgl->stats->elm.count, lgl->elm->round, round, round);
+  else
+    lglprt (lgl, 1,
+      "[elim-%d-%d-%d] incomplete backward checking %d remain %.0f%%",
+      lgl->stats->elm.count, lgl->elm->round, round,
+      newtouched, lglpcnt (newtouched, oldtouched));
+  lglrelstk (lgl, &stk);
+  lglstop (lgl);
+}
+
+static int lglelmdone (LGL * lgl, int * allptr) {
+  int newelmd, eliminated, subsumed, strengthened, bkwdcompleted;
+  const int oldonotsched = lgl->donotsched;
+  const int newdonotsched = !lgl->opts->bkwdresched.val;
+  int64_t steps, oldsteps;
+  if (!lglsmallirr (lgl)) return 1;
+  if (lglterminate (lgl)) return 1;
+  if (lgl->limits->elm.steps <= lgl->stats->elm.steps) return 1;
+  if (!lglmtstk (&lgl->esched)) return 0;
+  steps = ((oldsteps = lgl->stats->elm.steps) - lgl->elm->oldsteps);
+  assert (steps >= 0);
+  eliminated = (newelmd = lgl->stats->elm.elmd) - lgl->elm->oldelmd;
+  assert (eliminated >= 0);
+  if (eliminated <= 0) {
+    lglprt (lgl, 1,
+      "[elim-%d-%d] no variable eliminated in round %d in %lld steps",
+      lgl->stats->elm.count, lgl->elm->round,
+      lgl->elm->round, (LGLL) steps);
+    return 1;
+  }
+  lglprt (lgl, 1,
+    "[elim-%d-%d] eliminated %d variables %.0f%% in round %d in %lld steps",
+    lgl->stats->elm.count, lgl->elm->round, eliminated, 
+    lglpcnt (eliminated, lgl->nvars - 2), lgl->elm->round, (LGLL) steps);
+  if (oldonotsched != newdonotsched) lgl->donotsched = newdonotsched;
+  lglbackward (lgl, &subsumed, &strengthened, steps, &bkwdcompleted);
+  if (oldonotsched != newdonotsched) lgl->donotsched = oldonotsched;
+  steps = lgl->stats->elm.steps - oldsteps;
+  lglprt (lgl, 1,
+    "[elim-%d-%d] subsumed %d and strengthened %d clauses in %lld steps",
+    lgl->stats->elm.count, lgl->elm->round, subsumed, strengthened,
+    (LGLL) steps);
+  lgl->stats->elm.rounds++;
+  lgl->elm->oldelmd = newelmd;
+  lgl->elm->oldsteps = lgl->stats->elm.steps;
+  if (lgl->mt) return 1;
+  if (lgl->limits->elm.steps <= lgl->stats->elm.steps) return 1;
+  if (lgl->elm->round >= lgl->opts->elmroundlim.val) return 1;
+  if (!lglmtstk (&lgl->esched)) {
+    lglprt (lgl, 1,
+      "[elim-%d-%d] rescheduled %d variables %.0f%% by backward subsumption",
+      lgl->stats->elm.count, lgl->elm->round,
+      lglcntstk (&lgl->esched),
+      lglpcnt (lglcntstk (&lgl->esched), lglrem (lgl)));
+    lgl->elm->round++;
+    return 0;
+  }
+  if (bkwdcompleted && *allptr) return 1;
+  *allptr = 1;
+  if (!lglforceschedall (lgl)) return 1;
+  lgl->elm->round++;
+  return 0;
+}
+
+static void lglinitouched (LGL * lgl) {
+  int idx;
+  assert (lgl->eliminating);
+  lgl->elm->touched.nvars = lgl->nvars;
+  NEW (lgl->elm->touched.pos, lgl->nvars);
+  for (idx = 2; idx < lgl->nvars; idx++)
+    lgl->elm->touched.pos[idx] = -1;
+}
+
+static void lglreltouched (LGL * lgl) {
+  lglrelstk (lgl, &lgl->elm->touched.stk);
+  DEL (lgl->elm->touched.pos, lgl->elm->touched.nvars);
+}
+
+static int lglelim (LGL * lgl) {
+  int res = 1, idx, elmd, oldnvars, sched, success, all, rem;
+  int oldrem = lgl->elmrem, oldall = lgl->elmall, resched;
+  assert (lgl->opts->elim.val);
+  assert (!lgl->mt);
+  assert (lgl->nvars > 2);
+  assert (!lgl->eliminating);
+  assert (!lgl->simp);
+  assert (!lgl->occs);
+  lglstart (lgl, &lgl->times->elim);
+  lgl->stats->elm.count++;
+  lgl->eliminating = lgl->simp = lgl->occs = 1;
+  NEW (lgl->elm, 1);
+  lgl->elm->oldelmd = lgl->stats->elm.elmd;
+  lgl->elm->round = 1;
+  lgl->elm->oldsteps = lgl->stats->elm.steps;
+  lgl->stats->elm.rounds++;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  oldnvars = lglrem (lgl);
+  lglgc (lgl);
+  assert (lgl->frozen);
+  assert (!(oldall && !oldrem));
+  all = !oldrem || !oldall;
+  if (all)
+    lglprt (lgl, 1,
+      "[elim-%d] scheduling all variables this time",
+       lgl->stats->elm.count);
+  else if (!lgleschedrem (lgl, 1)) all = 1, oldrem = 0;
+  if (!all) assert (!lgl->donotsched), lgl->donotsched = 1;
+  assert (!lgl->touching);
+  lgldense (lgl, 1);
+  lglinitouched (lgl);
+  if (!all) assert (lgl->donotsched), lgl->donotsched = 0;
+  assert (!lgl->touching), lgl->touching = 1;
+  lglsetelmlim (lgl, &resched);
+  if (!resched) assert (!lgl->donotsched), lgl->donotsched = 1;
+  sched = lglcntstk (&lgl->esched);
+  while (res && !lglelmdone (lgl, &all)) {
+    idx = lglpopesched (lgl);
+    lglavar (lgl, idx)->donotelm = 1;
+    lglelimlit (lgl, idx);
+    res = lglflush (lgl);
+    assert (res || lgl->mt);
+  }
+  assert (lgl->touching), lgl->touching = 0;
+  if (!resched) assert (lgl->donotsched), lgl->donotsched = 0;
+  rem = lglcntstk (&lgl->esched);
+  if (!rem) {
+    lglprt (lgl, 1,
+      "[elim-%d] fully completed in %d rounds",
+      lgl->stats->elm.count, lgl->elm->round);
+    lgl->elmrtc = 1;
+  } else {
+    lglprt (lgl, 1,
+      "[elim-%d] incomplete %d not tried %.0f%% in round %d",
+      lgl->stats->elm.count,
+      rem, lglpcnt (rem, lgl->nvars - 2),
+      lgl->elm->round);
+  }
+  lglsetdonotesched (lgl, !rem);
+  lglrelstk (lgl, &lgl->esched);
+  lglreltouched (lgl);
+  lglrelecls (lgl);
+  lglsparse (lgl);
+  lglgc (lgl);
+  DEL (lgl->elm, 1);
+  lgl->elmrem = rem > 0;
+  lgl->elmall = all && lgl->elmrem;
+  lglprt (lgl, 1,
+    "[elim-%d] transition to [ all %d rem %d ] state",
+    lgl->stats->elm.count, lgl->elmall, lgl->elmrem);
+  elmd = oldnvars - lglrem (lgl);
+  lgl->stats->irrprgss += elmd;
+  lglprt (lgl, 1,
+    "[elim-%d] eliminated %d = %.0f%% variables out of %d scheduled",
+    lgl->stats->elm.count, elmd, lglpcnt (elmd, sched), sched);
+  if (!lgl->elmrtc  &&
+      lgl->stats->elm.count <= lgl->opts->elmsuccessmaxwortc.val) {
+    success = 1;
+    lglprt (lgl, 1,
+      "[elim-%d] considered successful since not run to completion yet",
+      lgl->stats->elm.count);
+  } else if (elmd) {
+    success = (oldnvars/lgl->opts->elmsuccessrat.val <= elmd);
+    if (!success)
+      lglprt (lgl, 1,
+	"[elim-%d] %d < 1/%d * %d = %d considered unsuccessful",
+	lgl->stats->elm.count, elmd, lgl->opts->elmsuccessrat.val,
+	sched, sched/lgl->opts->elmsuccessrat.val);
+  } else success = 0;
+  LGLUPDPEN (elm, success);
+  lglrep (lgl, 2, 'e');
+  assert (lgl->eliminating && lgl->simp && lgl->occs);
+  lgl->eliminating = lgl->simp = lgl->occs = 0;
+  lglstop (lgl);
+  return !lgl->mt;
+}
+
+static int lglsynceqs (LGL * lgl) {
+  int * ereprs, emax = lgl->maxext;
+  int elit1, erepr1, elit2, erepr2;
+  int ilit1, irepr1, ilit2, irepr2;
+  int consumed = 0, produced = 0;
+  assert (!lgl->mt);
+  assert (!lgl->level);
+  if (!lgl->nvars) return 1;
+  if (!lgl->cbs) return 1;
+  if (!lgl->cbs->eqs.lock.fun) return 1;
+  assert (lgl->repr);
+  ereprs = lgl->cbs->eqs.lock.fun (lgl->cbs->eqs.lock.state);
+  produced = consumed = 0;
+  for (elit1 = 1; elit1 <= emax; elit1++) {
+    if (lglelitblockingoreliminated (lgl, elit1)) continue;
+    elit2 = lglptrjmp (ereprs, emax, elit1);
+    if (elit2 == elit1) continue;
+    if (lglelitblockingoreliminated (lgl, elit2)) continue;
+    assert (elit2 != -elit1);
+    erepr1 = lglerepr (lgl, elit1);
+    if (lglelitblockingoreliminated (lgl, erepr1)) continue;
+    erepr2 = lglerepr (lgl, elit2);
+    if (lglelitblockingoreliminated (lgl, erepr2)) continue;
+    if (erepr1 == erepr2) continue;
+    if (erepr1 == -erepr2) {
+INCONSISTENT:
+      LOG (1, "inconsistent external equivalence %d %d", elit1, elit2);
+      assert (!lgl->level);
+      lglmt (lgl);
+      goto DONE;
+    }
+    ilit1 = lglimport (lgl, elit1);
+    ilit2 = lglimport (lgl, elit2);
+    if (ilit1 == ilit2) continue;
+    if (ilit1 == -ilit2) goto INCONSISTENT;
+    if (abs (ilit1) <= 1) continue;
+    if (abs (ilit2) <= 1) continue;
+    irepr1 = lglirepr (lgl, ilit1);
+    irepr2 = lglirepr (lgl, ilit2);
+    if (irepr1 == irepr2) continue;
+    if (irepr1 == -irepr2) goto INCONSISTENT;
+    if (abs (irepr1) <= 1) continue;
+    if (abs (irepr2) <= 1) continue;
+    LOG (2, "importing external equivalence %d %d as internal %d %d",
+	 elit1, elit2, irepr1, irepr2);
+    if (!lglisfree (lgl, irepr1)) continue;
+    if (!lglisfree (lgl, irepr2)) continue;
+    consumed++;
+    lglimerge (lgl, irepr1, irepr2);
+  }
+  LOG (1, "consumed %d equivalences", consumed);
+  for (elit1 = 1; elit1 <= emax; elit1++) {
+    elit2 = lglerepr (lgl, elit1);
+    if (elit1 == elit2) continue;
+    assert (elit1 != -elit2);
+    erepr1 = lglptrjmp (ereprs, emax, elit1);
+    erepr2 = lglptrjmp (ereprs, emax, elit2);
+    if (erepr1 == erepr2) continue;
+    assert (erepr1 != -erepr2);
+    LOG (2, "exporting external equivalence %d %d", erepr1, erepr2);
+    produced++;
+    ereprs[abs (erepr1)] = (erepr1 < 0) ? -erepr2 : erepr2;
+  }
+  LOG (1, "produced %d equivalences", produced);
+DONE:
+  if (lgl->cbs->eqs.unlock.fun)
+    lgl->cbs->eqs.unlock.fun (lgl->cbs->eqs.unlock.state, consumed, produced);
+  return !lgl->mt;
+}
+
+static int lgldecomp (LGL * lgl) {
+  int res = 1, oldnvars = lgl->nvars, removed;
+  assert (lgl->opts->decompose.val || lgl->probing || lgl->gaussing || lgl->sweeping);
+  assert (!lgl->decomposing);
+  lglstart (lgl, &lgl->times->decompose);
+  lgl->stats->decomps++;
+  lgl->decomposing = 1;
+  lgl->simp++;
+  assert (lgl->simp > 0);
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  res = 0;
+  lglgc (lgl);
+  if (!lglsyncunits (lgl)) goto DONE;
+  lglgc (lgl);
+  if (lgl->mt) goto DONE;
+  if (!lgltarjan (lgl)) goto DONE;
+  if (!lglsynceqs (lgl)) goto DONE;
+  lglchkred (lgl);
+  lgldcpdis (lgl);
+  lgldcpcln (lgl);
+  lgldcpcon (lgl);
+  lglcompact (lgl);
+  lglmap (lgl);
+  if (lgl->mt) goto DONE;
+  if (!lglbcp (lgl)) { lglmt (lgl); goto DONE; }
+  lglcount (lgl);
+  lglgc (lgl);
+  if (lgl->mt) goto DONE;
+  res = 1;
+DONE:
+  if (lgl->repr) DEL (lgl->repr, lgl->nvars);
+  assert (lgl->decomposing);
+  lgl->decomposing = 0;
+  ASSERT (lgl->simp > 0);
+  lgl->simp--;
+  removed = oldnvars - lgl->nvars;
+  if (removed)
+    lglprt (lgl, 1,
+      "[decomp-%d] removed %d variables",
+      lgl->stats->decomps, removed);
+  lglrep (lgl, 2, 'd');
+  lglstop (lgl);
+  return res;
+}
+
+int lglnvars (LGL * lgl) { return lglrem (lgl); }
+
+int lglnclauses (LGL * lgl) { return lgl->stats->irr.clauses.cur; }
+
+static int lgldstpull (LGL * lgl, int lit) {
+  AVar * av;
+  av = lglavar (lgl, lit);
+  assert ((lit > 0) == av->wasfalse);
+  if (av->mark) return 0;
+  if (!lglevel (lgl, lit)) return 0;
+  av->mark = 1;
+  if (lgldecision (lgl, lit)) {
+    lglpushstk (lgl, &lgl->clause, lit);
+    LOG (3, "added %d to learned clause", lit);
+  } else {
+    lglpushstk (lgl, &lgl->seen, -lit);
+    LOG (3, "pulled in distillation literal %d", -lit);
+  }
+  return 1;
+}
+
+static int lglanalit (LGL * lgl, int lit) {
+  int r0, r1, antecedents, other, next, tag, * p, * rsn;
+  AVar * av;
+  assert (lglmtstk (&lgl->seen));
+  assert (lglmtstk (&lgl->clause));
+  antecedents = 1;
+  av = lglavar (lgl, lit);
+  rsn = lglrsn (lgl, lit);
+  r0 = rsn[0], r1 = rsn[1];
+  LOGREASON (2, lit, r0, r1, "starting literal analysis for %d with", lit);
+  LOG (3, "added %d to learned clause", lit);
+  lglpushstk (lgl, &lgl->clause, lit);
+  assert ((lit < 0) == av->wasfalse);
+  assert (!av->mark);
+  av->mark = 1;
+  next = 0;
+  for (;;) {
+    tag = r0 & MASKCS;
+    if (tag == BINCS || tag == TRNCS) {
+      other = r0 >> RMSHFT;
+      lgldstpull (lgl, other);
+      if (tag == TRNCS) lgldstpull (lgl, r1);
+    } else if (tag == UNITCS) assert (!lglevel (lgl, lit));
+    else if (tag == DECISION) assert (lglavar (lgl, lit)->assumed);
+    else {
+      assert (tag == LRGCS);
+      for (p = lglidx2lits (lgl, (r0 & REDCS), r1); (other = *p); p++)
+	if (other != lit) lgldstpull (lgl, *p);
+    }
+    if (next == lglcntstk (&lgl->seen)) break;
+    lit = lglpeek (&lgl->seen, next++);
+    assert ((lit < 0) == lglavar (lgl, lit)->wasfalse);
+    rsn = lglrsn (lgl, lit);
+    r0 = rsn[0], r1 = rsn[1];
+    LOGREASON (2, lit, r0, r1, "literal analysis of");
+    antecedents++;
+  }
+  lglpopnunmarkstk (lgl, &lgl->seen);
+  LOG (2, "literal analysis used %d antecedents", antecedents);
+  assert (lglcntstk (&lgl->clause) >= 1);
+  return antecedents;
+}
+
+static int lglfailedass (LGL * lgl) {
+  assert (lgl->level >= lgl->alevel);
+  return lgl->level == lgl->alevel && lgl->failed;
+}
+
+static void lglanafailed (LGL * lgl) {
+  int ilit, elit, erepr, failed, size;
+  unsigned bit, rbit, ibit, count;
+  Ext * ext, * rext;
+  const int * p;
+  AVar * av;
+  assert (lgl->mt || lglfailedass (lgl));
+  if (lgl->mt) {
+    LOG (1, "no failed assumptions since CNF unconditionally inconsistent");
+  } else if ((failed = lgl->failed) == -1) {
+    assert (!lgl->level);
+    elit = 0;
+    for (p = lgl->eassume.start; !elit && p < lgl->eassume.top; p++) {
+      erepr = lglerepr (lgl, *p);
+      if (lglederef (lgl, erepr) < 0) elit = *p;
+    }
+    assert (elit);
+    LOG (1, "found single external failed assumption %d", elit);
+    ext = lglelit2ext (lgl, elit);
+    assert (!ext->failed);
+    bit = 1u << (elit < 0);
+    assert (ext->assumed & bit);
+    ext->failed |= bit;
+  } else {
+    assert (abs (failed) > 1);
+    if ((av = lglavar (lgl, failed))->assumed == 3) {
+      LOG (1, "inconsistent internal assumptions %d and %d", failed, -failed);
+      assert (!av->failed);
+      av->failed = 3;
+    } else {
+      lglanalit (lgl, -failed);
+      for (p = lgl->clause.start; p < lgl->clause.top; p++) {
+	ilit = *p;
+	av = lglavar (lgl, ilit);
+	bit = (1u << (ilit > 0));
+	assert (av->assumed & bit);
+	assert (!(av->failed & bit));
+	av->failed |= bit;
+      }
+      size = lglcntstk (&lgl->clause);
+      assert (size > 0);
+      lglpushstk (lgl, &lgl->clause, 0);
+      lglprt (lgl, 2,
+	 "[analyze-final] learned clause with size %d out of %d",
+	 size, lglcntstk (&lgl->eassume));
+      LOGCLS (2, lgl->clause.start, "failed assumption clause");
+      lgldrupligaddcls (lgl, REDCS);
+      lgladdcls (lgl, REDCS, size, 0);
+      lglpopstk (&lgl->clause);
+      lglpopnunmarkstk (lgl, &lgl->clause);
+    }
+    count = 0;
+    for (p = lgl->eassume.start; p < lgl->eassume.top; p++) {
+      elit =  *p;
+      bit = 1u << (elit < 0);
+      ext = lglelit2ext (lgl, elit);
+      assert (!ext->eliminated && !ext->blocking);
+      assert (ext->assumed & bit);
+      if (ext->failed & bit) continue;
+      if (ext->equiv) {
+	erepr = ext->repr;
+	rbit = bit;
+	if (erepr < 0) rbit ^= 3;
+	if (elit < 0) erepr = -erepr;
+	rext = lglelit2ext (lgl, erepr);
+	assert (!rext->equiv);
+	if (rext->failed & rbit) continue;
+	ilit = rext->repr;
+	ibit = rbit;
+	if (ilit < 0) ilit = -ilit, ibit ^= 3;
+	if (ilit == 1) continue;
+	assert (ilit && ilit != -1);
+	av = lglavar (lgl, ilit);
+	if (!(av->failed & ibit)) continue;
+	rext->failed |= rbit;
+	count++;
+	if (rext->assumed & rbit) {
+	  LOG (2,
+	       "found representative external failed assumption %d",
+	       erepr);
+	} else {
+	  LOG (2,
+	       "found non representative external failed assumption %d",
+	       elit);
+	  ext->failed |= bit;
+	}
+      } else {
+	ilit = ext->repr;
+	ibit = bit;
+	if (ilit < 0) ilit = -ilit, ibit ^= 3;
+	if (ilit == 1) continue;
+	assert (ilit && ilit != -1);
+	av = lglavar (lgl, ilit);
+	if (!(av->failed & ibit)) continue;
+	LOG (2, "found external failed assumption %d", elit);
+	ext->failed |= bit;
+	count++;
+      }
+    }
+    LOG (1, "found %u external failed assumptions", count);
+  }
+  TRANS (FAILED);
+}
+
+static void lglternreslit (LGL * lgl, int lit) {
+  int * pw, * peow, * nw, * neow, * p, * n;
+  int pblit, ptag, pother, pother2, pdelta;
+  int nblit, ntag, nother, nother2, ndelta;
+  HTS * phts, * nhts;
+  int a, b, c;
+
+  phts = lglhts (lgl, lit);
+  pw = lglhts2wchs (lgl, phts);
+  peow = pw + phts->count;
+  nhts = lglhts (lgl, -lit);
+  nw = lglhts2wchs (lgl, nhts);
+  neow = nw + nhts->count;
+  for (n = nw; n < neow; n++) {
+    if (INCSTEPS (ternres.steps) >= lgl->limits->ternres.steps) return;
+    nblit = *n;
+    ntag = nblit & MASKCS;
+    if (ntag == BINCS || ntag == OCCS) continue;
+    if (ntag == TRNCS) break;
+    assert (ntag == LRGCS);
+    n++;
+  }
+  if (n >= neow) return;
+  for (p = pw;
+       p < peow && lgl->stats->ternres.steps < lgl->limits->ternres.steps;
+       p++) {
+    INCSTEPS (ternres.steps);
+    pblit = *p;
+    ptag = pblit & MASKCS;
+    if (ptag == BINCS || ptag == OCCS) continue;
+    if (ptag == TRNCS || ptag == LRGCS) p++;
+    if (ptag == LRGCS) continue;
+    assert (ptag == TRNCS);
+    pother = pblit >> RMSHFT;
+    if (lglval (lgl, pother)) continue;
+    pother2 = *p;
+    if (lglval (lgl, pother2)) continue;
+    for (n = nw;
+	 n < neow && lgl->stats->ternres.steps < lgl->limits->ternres.steps;
+	 n++) {
+      INCSTEPS (ternres.steps);
+      nblit = *n;
+      ntag = nblit & MASKCS;
+      if (ntag == BINCS || ntag == OCCS) continue;
+      if (ntag == TRNCS || ntag == LRGCS) n++;
+      if (ntag == LRGCS) continue;
+      assert (ntag == TRNCS);
+      nother = nblit >> RMSHFT;
+      if (lglval (lgl, nother)) continue;
+      nother2 = *n;
+      if (lglval (lgl, nother2)) continue;
+      if ((nother == pother && nother2 == pother2) ||
+	  (nother == pother2 && nother2 == pother)) {
+	a = nother, b = nother2;
+	if (lglhasbin (lgl, a, b)) continue;
+	lgl->stats->ternres.bin++;
+	LOG (2, "ternary resolvent %d %d", a, b);
+	lgldrupligaddclsarg (lgl, REDCS, a, b, 0);
+	lglwchbin (lgl, a, b, REDCS);
+	lglwchbin (lgl, b, a, REDCS);
+	lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+	lglwrktouch (lgl, a);
+	lglwrktouch (lgl, b);
+      } else {
+	a = nother, b = nother2;
+	if (nother == pother || nother2 == pother) c = pother2;
+	else if (nother == pother2 || nother2 == pother2) c = pother;
+	else continue;
+	assert (a != b && b != c && a != c);
+	assert (a != -b);
+	if (a == -c || b == -c) continue;
+	if (lglhastrn (lgl, a, b, c)) continue;
+	lgl->stats->ternres.trn++;
+	LOG (2, "ternary resolvent %d %d %d", a, b, c);
+	lgldrupligaddclsarg (lgl, REDCS, a, b, c, 0);
+	lglwchtrn (lgl, a, b, c, REDCS);
+	lglwchtrn (lgl, b, a, c, REDCS);
+	lglwchtrn (lgl, c, a, b, REDCS);
+	lgl->stats->red.trn++, assert (lgl->stats->red.trn > 0);
+	lglwrktouch (lgl, a);
+	lglwrktouch (lgl, b);
+	lglwrktouch (lgl, c);
+      }
+      pdelta = p - pw;
+      phts = lglhts (lgl, lit);
+      pw = lglhts2wchs (lgl, phts);
+      peow = pw + phts->count;
+      p = pw + pdelta;
+      ndelta = n - nw;
+      nhts = lglhts (lgl, -lit);
+      nw = lglhts2wchs (lgl, nhts);
+      neow = nw + nhts->count;
+      n = nw + ndelta;
+    }
+  }
+}
+
+static void lglternresidx (LGL * lgl, int idx) {
+  lglternreslit (lgl, idx);
+  lglternreslit (lgl, -idx);
+}
+
+static void lglseternreslim (LGL * lgl) {
+  int64_t limit, irrlim;
+  int pen, szpen;
+  if (lgl->opts->ternresrtc.val) {
+    lgl->limits->ternres.steps = LLMAX;
+    lglprt (lgl, 1,
+       "[ternres-%d] really no limit (run to completion)",
+       lgl->stats->ternres.count);
+  } else {
+    limit = (lgl->opts->trnreleff.val*lglvisearch (lgl))/1000;
+    if (limit < lgl->opts->trnrmineff.val) limit = lgl->opts->trnrmineff.val;
+    if (lgl->opts->trnrmaxeff.val >= 0 && limit > lgl->opts->trnrmaxeff.val)
+      limit = lgl->opts->trnrmaxeff.val;
+    if (lgl->stats->ternres.count <= 1 &&
+        lgl->opts->boost.val &&
+        lgl->opts->ternresboost.val > 1) {
+      lglprt (lgl, 1,
+        "[ternres-%d] boosting ternary resolution limit by %d",
+	lgl->stats->ternres.count, lgl->opts->ternresboost.val);
+      limit *= lgl->opts->ternresboost.val;
+    }
+    limit >>= (pen = lgl->limits->ternres.pen + (szpen = lglszpen (lgl)));
+    irrlim = (4*lgl->stats->irr.clauses.cur) >> szpen;
+    if (lgl->opts->irrlim.val && limit < irrlim) {
+      limit = irrlim;
+      lglprt (lgl, 1,
+  "[ternres-%d] limit %lld based on %d irredundant clauses penalty %d",
+	lgl->stats->ternres.count,
+	(LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+    } else
+      lglprt (lgl, 1, "[ternres-%d] limit %lld with penalty %d = %d + %d",
+	lgl->stats->ternres.count, (LGLL) limit,
+	pen, lgl->limits->ternres.pen, szpen);
+    lgl->limits->ternres.steps = lgl->stats->ternres.steps + limit;
+  }
+}
+
+static void lglprternresrem (LGL * lgl) {
+  int idx, ret = 0, rem = 0, sum;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    if (lglavar (lgl, idx)->donoternres) ret++; else rem++;
+  }
+  if (rem) {
+    sum = ret + rem;
+    lglprt (lgl, 1,
+      "[ternres-%d] %d variables remain %.0f%% (%d retained %.0f%%)",
+      lgl->stats->ternres.count,
+      rem, lglpcnt (rem, sum),
+      ret, lglpcnt (ret, sum));
+  } else {
+    lglprt (lgl, 1,
+      "[ternres-%d] fully completed ternary resolution",
+      lgl->stats->ternres.count);
+    for (idx = 2; idx < lgl->nvars; idx++)
+      lglavar (lgl, idx)->donoternres = 0;
+  }
+}
+
+static void lglternresinit (LGL * lgl) {
+  int idx, schedulable = 0, donoternres = 0;
+  lglwrkinit (lgl, 1, 1);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    if (lglavar (lgl, idx)->donoternres) donoternres++;
+    else schedulable++;
+  }
+  if (!schedulable) {
+    donoternres = 0;
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      if (!lglisfree (lgl, idx)) continue;
+      lglavar (lgl, idx)->donoternres = 0;
+      schedulable++;
+    }
+  }
+  if (!donoternres)
+    lglprt (lgl, 1,
+      "[ternres-%d] all %d free variables schedulable",
+      lgl->stats->ternres.count, schedulable);
+  else
+    lglprt (lgl, 1,
+      "[ternres-%d] %d schedulable variables %.0f%%",
+      lgl->stats->ternres.count, schedulable, lglpcnt (schedulable, lgl->nvars-2));
+  assert (!lgl->donotsched), lgl->donotsched = 1;
+  lglrandidxtrav (lgl, lglwrktouch);
+  assert (lgl->donotsched), lgl->donotsched = 0;
+}
+
+static int lglternres (LGL * lgl) {
+  int before, after, delta;
+  int before2, after2, delta2;
+  int before3, after3, delta3;
+  int success, lit;
+  if (lgl->nvars <= 2) return 1;
+  lglstart (lgl, &lgl->times->ternres);
+  ASSERT (!lgl->simp && !lgl->ternresing);
+  lgl->simp = lgl->ternresing = 1;
+  lgl->stats->ternres.count++;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  lglseternreslim (lgl);
+
+  lglternresinit (lgl);
+
+  before2 = lgl->stats->ternres.bin;
+  before3 = lgl->stats->ternres.trn;
+  while (lgl->stats->ternres.steps < lgl->limits->ternres.steps) {
+    if (lglterminate (lgl)) break;
+    if (!lglsyncunits (lgl)) break;
+    if (!(lit = lglwrknext (lgl))) {
+      lglprt (lgl, 2,  "[ternres-%d] saturated", lgl->stats->ternres.count);
+      break;
+    }
+    INCSTEPS (ternres.steps);
+    assert (lit > 0);
+    if (!lglisfree (lgl, lit)) continue;
+    lglavar (lgl, lit)->donoternres = 1;
+    lglternresidx (lgl, lit);
+  }
+  after2 = lgl->stats->ternres.bin;
+  after3 = lgl->stats->ternres.trn;
+  after = after2 + after3;
+  before = before2 + before3;
+  delta2 = after2 - before2;
+  delta3 = after3 - before3;
+  delta = after - before;
+  success = before < after;
+  lglprt (lgl, 1,
+    "[ternres-%d] %d ternary resolvents (%d bin, %d trn)",
+    lgl->stats->ternres.count, delta, delta2, delta3);
+  LGLUPDPEN (ternres, success);
+  assert (lgl->simp && lgl->ternresing);
+  lgl->simp = lgl->ternresing = 0;
+  lglprternresrem (lgl);
+  lglrep (lgl, 2, '3');
+  lglwrkreset (lgl);
+  lglstop (lgl);
+  return !lgl->mt;
+}
+
+typedef struct POSLIDX { int pos, lidx; } POSLIDX;
+
+int lglcmposlidx (LGL * lgl, int * lits, POSLIDX * a, POSLIDX * b) {
+  const int * c = lits + a->pos, * d = lits + b->pos;
+  int i, l, k, p, q;
+  for (i = 0; i < 4; i++) {
+    l = c[i], k = d[i];
+    ASSERT (l != INT_MIN);
+    ASSERT (k != INT_MIN);
+    p = abs (l), q = abs (k);
+    if (p < q) return -1;
+    if (p > q) return 1;
+    if (l < k) return -1;
+    if (l > k) return 1;
+  }
+  return 0;
+}
+
+#define LGLCMPOSLIDX(A,B) lglcmposlidx (lgl, lits.start, (A), (B))
+
+static int lglquatres1 (LGL * lgl, int * trnptr) {
+  int mask, size, lidx, count, lrg, total, tlrg, pos, m[4], i, j, k, l, n;
+  int glue, maxglue = lglscaleglue (lgl, 4), pivot, a, b, redi, redj, red;
+  int assigned, trn, sub;
+  const int * p, * c, * d;
+  POSLIDX * pls;
+  Stk lits, clauses, *s;
+  assert (!lgl->level);
+  assert (lgl->notrim);
+  lglstart (lgl, &lgl->times->quatres1);
+  CLR (lits); CLR (clauses);
+  total = trn = sub = tlrg = 0;
+  for (glue = -1; glue <= maxglue; glue++) {
+    count = lrg = 0;
+    if (glue < 0) mask = MAXGLUE, s = &lgl->irr;
+    else mask = glue, s = lgl->red + glue;
+    for (c = s->start; c < s->top; c = p + 1) {
+      if (*c >= REMOVED) { p = c; continue; }
+      if (glue >= 0) assert (lglisact (*c)), c++;
+      assigned = 0;
+      for (p = c; *p; p++)
+	if (lglval (lgl, *p)) assigned++;
+      if (assigned) continue;
+      size = p - c;
+      lrg++;
+      if (size > 4) continue;
+      assert (size == 4);
+      lidx = c - s->start;
+      assert (lidx >= 0);
+      lidx <<= GLUESHFT;
+      lidx |= mask;
+      pos = lglcntstk (&lits);
+      assert (!(pos & 3));
+      lglpushstk (lgl, &clauses, pos);
+      lglpushstk (lgl, &clauses, lidx);
+      for (i = 0; i < 4; i++) m[i] = c[i];
+      for (i = 0; i < 3; i++)
+	for (j = i+1; j < 4; j++)
+	  if (abs (m[i]) > abs (m[j]))
+	    SWAP (int, m[i], m[j]);
+      for (i = 0; i < 4; i++) lglpushstk (lgl, &lits, m[i]);
+      count++;
+    }
+    if (glue < 0)
+      lglprt (lgl, 2,
+	"[quatres-%d] found %d irredundant quaternary clauses %.0f%%",
+	lgl->stats->quatres.count, count, lglpcnt (count, lrg));
+    else
+      lglprt (lgl, 2,
+	"[quatres-%d] found %d glue %d quaternary clauses %.0f%%",
+	lgl->stats->quatres.count, count, glue, lglpcnt (count, lrg));
+    total += count;
+    tlrg += lrg;
+  }
+  lglfitstk (lgl, &lits), lglfitstk (lgl, &clauses);
+  lglprt (lgl, 1 + !tlrg,
+    "[quatres-%d] found %d quaternary clauses %.0f%% in total",
+    lgl->stats->quatres.count, total, lglpcnt (total, tlrg));
+  pls = (POSLIDX*) clauses.start;
+  assert (lglcntstk (&clauses) == 2*total);
+  SORT (POSLIDX, pls, total, LGLCMPOSLIDX);
+#if 0
+  for (i = 0; i < total; i++) {
+    c = lits.start + pls[i].pos;
+    lidx = pls[i].lidx;
+    printf ("c pls[%d] %d %d %d %d (glue %d, pos %d)\n",
+      i,
+      c[0], c[1], c[2], c[3],
+      (lidx & GLUEMASK), (lidx >> GLUESHFT));
+  }
+#endif
+  for (i = 0; i < total - 1; i++) {
+    pos = pls[i].pos;
+    if (pos < 0) continue;
+    c = lits.start + pos;
+    for (j = i + 1; j < total; j++) {
+      if (pls[i].pos < 0) break;
+      pos = pls[j].pos;
+      if (pos < 0) break;
+      d = lits.start + pos;
+      pivot = 0;
+      for (k = 0; k < 4; k++) {
+	a = c[k], b = d[k];
+	if (abs (a) != abs (b)) break;
+	if (a == b) continue;
+	if (pivot) break;
+	pivot = a;
+      }
+      if (k < 4) break;
+      assert (i != j);
+      assert (pls[i].lidx != pls[j].lidx);
+      redi = ((pls[i].lidx & GLUEMASK) == MAXGLUE) ? 0 : REDCS;
+      redj = ((pls[j].lidx & GLUEMASK) == MAXGLUE) ? 0 : REDCS;
+      if (pivot) {
+	n = 0;
+	for (l = 0; l < 4; l++) if (c[l] != pivot) m[n++] = c[l];
+	assert (n == 3);
+	if (lglhastrn (lgl, m[0], m[1], m[2])) continue;
+	red = redi & redj;
+	LOG (2,
+	  "self-subsuming %s ternary resolvent %d %d %d",
+	  red ? "redundant" : "irredundant", m[0], m[1], m[2]);
+	lgldrupligaddclsarg (lgl, REDCS, m[0], m[1], m[2], 0);
+	lglwchtrn (lgl, m[0], m[1], m[2], red);
+	lglwchtrn (lgl, m[1], m[0], m[2], red);
+	lglwchtrn (lgl, m[2], m[0], m[1], red);
+	if (!red) lglincirr (lgl, 3);
+	else lgl->stats->red.trn++, assert (lgl->stats->red.trn > 0);
+	lgl->stats->quatres.self2++;
+	*trnptr += 1, trn++;
+	lgldrupligdelclsarg (lgl, c[0], c[1], c[2], c[3], 0);
+	if (redi) lglrmlcls (lgl, pls[i].lidx, REDCS);
+	else lglrmlcls (lgl, (pls[i].lidx >> GLUESHFT), 0);
+	lgldrupligdelclsarg (lgl, d[0], d[1], d[2], d[3], 0);
+	if (redj) lglrmlcls (lgl, pls[j].lidx, REDCS);
+	else lglrmlcls (lgl, (pls[j].lidx >> GLUESHFT), 0);
+	pls[i].pos = pls[j].pos = -1;
+      } else if (redi) {
+	lgl->stats->quatres.dup++, sub++;
+	lgldrupligdelclsarg (lgl, c[0], c[1], c[2], c[3], 0);
+        lglrmlcls (lgl, pls[i].lidx, REDCS);
+	pls[i].pos = -1;
+      } else if (redj) {
+	lgl->stats->quatres.dup++;
+	lgldrupligdelclsarg (lgl, d[0], d[1], d[2], d[3], 0);
+	lglrmlcls (lgl, pls[j].lidx, REDCS);
+	pls[j].pos = -1;
+      } else {
+	lgl->stats->quatres.dup++;
+	lgldrupligdelclsarg (lgl, d[0], d[1], d[2], d[3], 0);
+	lglrmlcls (lgl, (pls[j].lidx >> GLUESHFT), 0);
+	pls[j].pos = -1;
+      }
+    }
+  }
+  lglrelstk (lgl, &lits), lglrelstk (lgl, &clauses);
+  lglprt (lgl, 1 + !sub,
+    "[quatres-%d-1] removed %d duplicate quaternary clauses",
+    lgl->stats->quatres.count, sub);
+  lglprt (lgl, 1 + !trn,
+    "[quatres-%d-1] added %d double-self-subsuming ternary resolvents",
+    lgl->stats->quatres.count, trn);
+  lglstop (lgl);
+  return tlrg;
+}
+
+static int lglhasquad (LGL * lgl) {
+  int blit, tag, red, other, other2, lidx, glue, count, lit, other3, val;
+  const int * p, * w, * eow, * q, * c, * d, * r, * l;
+  int maxglue = lglscaleglue (lgl, 4);
+  int maxcount, tmpcount, maxlit;
+  HTS * hts;
+  assert (lglcntstk (&lgl->clause) == 5);
+  maxcount = -1, maxlit = 0;
+  for (p = (c = lgl->clause.start); (lit = *p); p++) {
+    assert (!lglval (lgl, lit));
+    tmpcount = lglhts (lgl, lit)->count;
+    if (tmpcount <= maxcount) continue;
+    maxcount = tmpcount, maxlit = lit;
+  }
+  assert (maxlit), assert (maxcount >= 0);
+  for (p = c; (lit = *p); p++) {
+    if (lit == maxlit) continue;
+    hts = lglhts (lgl, lit);
+    w = lglhts2wchs (lgl, hts);
+    eow = w + hts->count;
+    for (q = w; q < eow; q++) {
+      blit = *q;
+      tag = blit & MASKCS;
+      if (tag == BINCS) {
+	other = blit >> RMSHFT;
+	for (r = c; (other3 = *r); r++)
+	  if (other3 == other) return 1;
+      } else if (tag == TRNCS) {
+	other = blit >> RMSHFT;
+	other2 = *++q;
+	count = 0;
+	for (r = c; (other3 = *r); r++) {
+	       if (other3 == other) { if (++count == 2) return 1; }
+	  else if (other3 == other2) { if (++count == 2) return 1; }
+	}
+      } else {
+	assert (tag == LRGCS);
+	red = blit & REDCS;
+	lidx = *++q;
+	if (red) {
+	  glue = lidx & GLUEMASK;
+	  if (glue > maxglue) continue;
+	}
+	d = lglidx2lits (lgl, red, lidx);
+	count = 0;
+	for (l = d; (other = *l); l++) {
+	  val = lglval (lgl, other);
+	  if (val > 0) break;
+	  if (val < 0) continue;
+	  if (count >= 4) break;
+	  for (r = c; (other3 = *r); r++)
+	    if (other3 == other) break;
+	  if (!other3) break;
+	  count++;
+	}
+	if (!other) return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+static void lglquatres2 (LGL * lgl, int * trnptr, int * quadptr) {
+  int lit, sign, other, blit, tag, red, lidx, trn, quat, glue, glue2;
+  int count, pos, neg, extra, pivot, other2, other3, rednew;
+  const int * start, * c, * p, * w, * eow, * q, * d, * l;
+  int maxcheck = lgl->stats->quatres.count, check;
+  int maxglue = lglscaleglue (lgl, 4), val;
+  ptrdiff_t delta;
+  HTS * hts;
+  Stk * s;
+  lglstart (lgl, &lgl->times->quatres2);
+  assert (!lgl->level);
+  assert (lgl->notrim);
+  trn = quat = 0;
+  for (glue = -1; glue <= maxglue; glue++) {
+    s = (glue < 0) ? &lgl->irr : lgl->red + glue;
+    for (c = (start = s->start); c < s->top; c = p + 1) {
+      if (*c >= REMOVED) { p = c; continue; }
+      if (glue >= 0) assert (lglisact (*c)), c++;
+      count = 0;
+      for (p = c; (lit = *p); p++) {
+	val = lglval (lgl, lit);
+	if (val < 0) continue;
+	if (val > 0) break;
+	if (++count > 4) break;
+      }
+      if (lit) {
+	while (*++p)
+	  ;
+	continue;
+      }
+      assert (count <= 4);
+      if (count < 4) continue;
+      for (p = c; (lit = *p); p++)
+	if (!lglval (lgl, lit))
+	  lglmark (lgl, lit);
+      for (p = c; (lit = *p); p++) {
+	if (lglval (lgl, lit)) continue;
+	for (sign = -1; sign <= 1; sign += 2) {
+	  hts = lglhts (lgl, sign*lit);
+	  w = lglhts2wchs (lgl, hts);
+	  eow = w + hts->count;
+	  check = 0;
+	  for (q = w; check < maxcheck && q < eow; q++) {
+	    blit = *q;
+	    tag = blit & MASKCS;
+	    red = blit & REDCS;
+	    if (tag == TRNCS || tag == LRGCS) q++;
+	    if (maxglue < MAXGLUE && tag == LRGCS) {
+	      lidx = *q;
+	      if (red) {
+		glue2 = lidx & GLUEMASK;
+		if (glue2 > maxglue) continue;
+	      } else glue2 = -1;
+	      if (glue2 < glue) continue;
+	      d = lglidx2lits (lgl, red, lidx);
+	      if (d == c) continue;
+	      if (glue2 == glue && d < c) continue;
+	      check++;
+	      count = pos = neg = extra = pivot = 0;
+	      for (l = d; (other = *l); l++) {
+		val = lglval (lgl, other);
+		if (val < 0) continue;
+		if (val > 0) break;
+		val = lglmarked (lgl, other);
+		if (val < 0) {
+		  if (neg++) break;	
+		  pivot = other;
+		} else if (val > 0) {
+		   if (++pos > 2) break;
+		} else {
+		  assert (!val);
+		  if (count++) break;
+		  extra = other;
+		}
+	      }
+	      if (other) continue;
+	      if (neg != 1 || pos != 2 || count != 1) continue;
+	      assert (extra);
+	      assert (lglmtstk (&lgl->clause));
+	      for (l = c; (other = *l); l++) {
+		if (lglval (lgl, other)) continue;
+		if (other == pivot) continue;
+		if (other == -pivot) continue;
+		lglpushstk (lgl, &lgl->clause, other);
+	      }
+	      lglpushstk (lgl, &lgl->clause, extra);
+	      lglpushstk (lgl, &lgl->clause, 0);
+	      if (!lglhasquad (lgl)) {
+		LOGCLS (0, c,
+		  "1st pivot %d quaternary scaled glue %d antecedent",
+		  -pivot, glue);
+		LOGCLS (0, d,
+		  "2nd pivot %d quaternary scaled glue %d antecedent",
+		  pivot, glue2);
+		LOGCLS (0, lgl->clause.start, "found quaternary resolvent");
+		LOG (5, "before: w + %d = q = eow - %d", (int)(q - w), (int)(eow - w));
+		lgldrupligaddcls (lgl, REDCS);
+		lgladdcls (lgl, REDCS, 4, 0);
+		delta = s->start - start;
+		if (delta) {
+		  LOG (5, "fixing glue %d clauses start by %ld", glue, delta);
+		  c += delta, p += delta, start = s->start;
+		}
+		hts = lglhts (lgl, sign*lit);
+		delta = lglhts2wchs (lgl, hts) - w;
+		if (delta) {
+		  LOG (5, "fixing %d watches start by %ld", sign*lit, delta);
+		  w += delta, q += delta;
+		}
+		if (w + hts->count != eow) {
+		  LOG (5, "fixing %d watches end from %x to %x",
+		    sign*lit, eow, w + hts->count);
+		  eow = w + hts->count;
+		}
+		LOG (5, "after: w + %d = q = eow - %d", (int)(q - w), (int)(eow - w));
+		lgl->stats->quatres.quat++;
+		*quadptr += 1, quat++;
+	      }
+	      lglclnstk (&lgl->clause);
+	    } else if (tag == TRNCS) {
+	      if (sign > 0) continue;
+	      other = blit >> RMSHFT;
+	      if (lglval (lgl, other)) continue;
+	      if (lglmarked (lgl, other) <= 0) continue;
+	      other2 = *q;
+	      if (lglval (lgl, other2)) continue;
+	      if (lglmarked (lgl, other2) <= 0) continue;
+	      // This gives a usefull ternary self-subsuming resolvent:
+	      // (lit A B C) resolved with (-lit A B) gives (A B C)
+	      // Other cases produce too many quaternary resolvents (b7ztz6).
+	      LOGCLS (0, c,
+		"1st pivot %d quaternary scaled glue %d antecedent",
+		lit, glue);
+	      LOG (0,
+	        "2nd pivot %d ternary antecedent %d %d %d",
+		-lit, -lit, other, other2);
+	      extra = 0;
+	      for (l = c; !extra; l++) {
+		other3 = *l;
+		assert (other3);
+		if (other3 == lit) continue;
+		assert (other3 != -lit);
+		if (other3 == other) continue;
+		if (other3 == other2) continue;
+		val = lglval (lgl, other3);
+		assert (val <= 0);
+		if (val) continue;
+		extra = other3;
+	      }
+	      assert (extra != -other);
+	      assert (extra != -other2);
+	      rednew = (glue >= 0) ? REDCS : 0;
+	      LOG (0,
+		"self-subsuming %s ternary resolvent %d %d %d",
+		rednew ? "redundant" : "irredundant", other, other2, extra);
+	      lgldrupligaddclsarg (lgl, REDCS, other, other2, extra, 0);
+	      lglwchtrn (lgl, other, other2, extra, rednew);
+	      lglwchtrn (lgl, other2, other, extra, rednew);
+	      lglwchtrn (lgl, extra, other, other2, rednew);
+	      // NOTE: 'hts', 'q', 'w', 'eow' might be invalid now.
+	      // But 'c' has to remain valid:
+	      assert (s->start == start), assert (c + 4 < s->top);
+	      if (!rednew) lglincirr (lgl, 3);
+	      else lgl->stats->red.trn++, assert (lgl->stats->red.trn > 0);
+	      lgl->stats->quatres.self1++;
+	      *trnptr += 1, trn++;
+	      for (p = c; (other3 = *p); p++)	// set 'p' to point after 'c'
+		if (!lglval (lgl, other3))	// reset marks now because
+		  lglunmark (lgl, other3);	// 'lglrmlcls' invalidates 'c'
+	      lidx = c - start;
+	      if (rednew) {
+		assert (lidx >= 0);
+		lidx <<= GLUESHFT;
+		assert (lidx >= 0);
+		assert (0 <= glue), assert (glue <= MAXGLUE);
+		lidx |= glue;
+	      }
+	      lgldrupligdelclsaux (lgl, c);
+	      assert (!*p);
+	      lglrmlcls (lgl, lidx, rednew);	// rednew = redold (of 'c')
+	      assert (start <= c), assert (c + 3 < p), assert (p <= s->top);
+	      assert (p[-0] == REMOVED);
+	      assert (p[-1] == REMOVED);
+	      assert (p[-2] == REMOVED);
+	      assert (p[-3] == REMOVED);
+	      assert (p[-4] == REMOVED), assert (c[0] == REMOVED);
+	      goto NEXT_CLAUSE;
+	    }
+	  }
+	}
+      }
+      for (p = c; (lit = *p); p++)
+	if (!lglval (lgl, lit))
+	  lglunmark (lgl, lit);
+NEXT_CLAUSE:
+      ;
+    }
+  }
+  lglprt (lgl, 1 + !trn,
+    "[quatres-%d-2] added %d single-self-subsuming ternary resolvents",
+    lgl->stats->quatres.count, trn);
+  lglprt (lgl, 1 + !quat,
+    "[quatres-%d-2] added %d quaternary resolvents",
+    lgl->stats->quatres.count, quat);
+  lglstop (lgl);
+}
+
+static void lglquatres (LGL * lgl) {
+  int trn, quad;
+  lglstart (lgl, &lgl->times->quatres);
+  if (lgl->level) lglbacktrack (lgl, 0);
+  assert (!lgl->simp), assert (!lgl->quatres), assert (!lgl->notrim);
+  lgl->simp = lgl->quatres = lgl->notrim = 1;
+  lgl->stats->quatres.count++;
+  trn = quad = 0;
+  if (lglquatres1 (lgl, &trn)) lglquatres2 (lgl, &trn, &quad);
+  LGLUPDPEN (quatres, trn + quad);
+  assert (lgl->simp), assert (lgl->quatres), assert (lgl->notrim);
+  lgl->simp = lgl->quatres = lgl->notrim = 0;
+  lglrep (lgl, 2, '4');
+  lglstop (lgl);
+}
+
+static int lgltrdbin (LGL * lgl, int start, int target, int irr) {
+  int lit, next, blit, tag, red, other, * p, * w, * eow, res, ign, val;
+  HTS * hts;
+  assert (lglmtstk (&lgl->seen));
+  assert (abs (start) < abs (target));
+  LOG (2, "trying transitive reduction of %s binary clause %d %d",
+       lglred2str (irr^REDCS), start, target);
+  lgl->stats->trd.bins++;
+  lglpushnmarkseen (lgl, -start);
+  next = 0;
+  res = 0;
+  ign = 1;
+  while (next < lglcntstk (&lgl->seen)) {
+    lit = lglpeek (&lgl->seen, next++);
+    INCSTEPS (trd.steps);
+    LOG (3, "transitive reduction search step %d", lit);
+    val = lglval (lgl, lit);
+    if (val) continue;
+    hts = lglhts (lgl, -lit);
+    if (!hts->count) continue;
+    w = lglhts2wchs (lgl, hts);
+    eow = w + hts->count;
+    for (p = w; p < eow; p++) {
+      blit = *p;
+      tag = blit & MASKCS;
+      if (tag == LRGCS || tag == TRNCS) p++;
+      if (tag != BINCS) continue;
+      red = blit & REDCS;
+      if (irr && red) continue;
+      other = blit >> RMSHFT;
+      if (other == start) continue;
+      if (other == target) {
+	if (lit == -start && ign) { ign = 0; continue; }
+	LOG (2, "transitive path closed with %s binary clause %d %d",
+	     lglred2str (red), -lit, other);
+	res = 1;
+	goto DONE;
+      }
+      val = lglmarked (lgl, other);
+      if (val > 0) continue;
+      if (val < 0) {
+	assert (lgl->level == 0);
+	lgl->stats->trd.failed++;
+	LOG (1, "failed literal %d in transitive reduction", -start);
+	lglunit (lgl, start);
+	val = lglbcp (lgl);
+	if (!val && !lgl->mt) lglmt (lgl);
+	assert (val || lgl->mt);
+	res = -1;
+	goto DONE;
+      }
+      lglpushnmarkseen (lgl, other);
+      LOG (3, "transitive reduction follows %s binary clause %d %d",
+	   lglred2str (red), -lit, other);
+    }
+  }
+DONE:
+  lglpopnunmarkstk (lgl, &lgl->seen);
+  return res;
+}
+
+static void lgltrdlit (LGL * lgl, int start) {
+  int target, * w, * p, * eow, blit, tag, red, val;
+#ifndef NDEBUG
+  int unassigned = lgl->unassigned;
+#endif
+  HTS * hts;
+  val = lglval (lgl, start);
+  if (val) return;
+  LOG (2, "transitive reduction of binary clauses with %d", start);
+  assert (lglmtstk (&lgl->seen));
+  hts = lglhts (lgl, start);
+  if (!hts->count) return;
+  lgl->stats->trd.lits++;
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w;
+       p < eow && (lgl->stats->trd.steps < lgl->limits->trd.steps);
+       p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag != BINCS) continue;
+    target = blit >> RMSHFT;
+    if (abs (start) > abs (target)) continue;
+    red = blit & REDCS;
+    val = lgltrdbin (lgl, start, target, red^REDCS);
+    if (!val) continue;
+    if (val < 0) { assert (lgl->mt || lgl->unassigned < unassigned); break; }
+    LOG (2, "removing transitive redundant %s binary clause %d %d",
+	 lglred2str (red), start, target);
+    lgl->stats->trd.red++;
+    lgl->stats->prgss++;
+    lgldrupligdelclsarg (lgl, start, target, 0);
+    lglrmbwch (lgl, start, target, red);
+    lglrmbwch (lgl, target, start, red);
+    assert (!lgl->dense);
+    if (red) assert (lgl->stats->red.bin > 0), lgl->stats->red.bin--;
+    else lgldecirr (lgl, 2);
+    break;
+  }
+}
+
+static void lglsetrdlim (LGL * lgl) {
+  int64_t limit, irrlim;
+  int pen, szpen;
+  limit = (lgl->opts->trdreleff.val*lglvisearch (lgl))/1000;
+  if (limit < lgl->opts->trdmineff.val) limit = lgl->opts->trdmineff.val;
+  if (lgl->opts->trdmaxeff.val >= 0 && limit > lgl->opts->trdmaxeff.val)
+    limit = lgl->opts->trdmaxeff.val;
+  limit >>= (pen = lgl->limits->trd.pen + (szpen = lglszpen (lgl)));
+  irrlim = (lgl->stats->irr.clauses.cur) >> szpen;
+  if (lgl->opts->irrlim.val && limit < irrlim) {
+    limit = irrlim;
+    lglprt (lgl, 1,
+  "[transred-%d] limit %lld based on %d irredundant clauses penalty %d",
+      lgl->stats->trd.count,
+      (LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+  } else
+    lglprt (lgl, 1, "[transred-%d] limit %lld with penalty %d = %d + %d",
+      lgl->stats->trd.count, (LGLL) limit,
+      pen, lgl->limits->trd.pen, szpen);
+  lgl->limits->trd.steps = lgl->stats->trd.steps + limit;
+}
+
+static int lgltrd (LGL * lgl) {
+  unsigned pos, delta, mod, ulit, first, last;
+  int failed = lgl->stats->trd.failed;
+  int red = lgl->stats->trd.red;
+  int lit, count, success;
+  if (lgl->nvars <= 2) return 1;
+  lgl->stats->trd.count++;
+  lglstart (lgl, &lgl->times->transred);
+  assert (!lgl->simp);
+  lgl->simp = 1;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  lglsetrdlim (lgl);
+  mod = 2*(lgl->nvars - 2);
+  assert (mod > 0);
+  pos = lglrand (lgl) % mod;
+  delta = lglrand (lgl) % mod;
+  if (!delta) delta++;
+  while (lglgcd (delta, mod) > 1)
+    if (++delta == mod) delta = 1;
+  LOG (1, "transitive reduction start %u delta %u mod %u", pos, delta, mod);
+  first = mod;
+  count = 0;
+  while (lgl->stats->trd.steps < lgl->limits->trd.steps) {
+    if (lglterminate (lgl)) break;
+    if (!lglsyncunits (lgl)) break;
+    ulit = pos + 4;
+    lit = lglilit (ulit);
+    lgltrdlit (lgl, lit);
+    count++;
+    assert (count <= mod);
+    if (lgl->mt) break;
+    last = pos;
+    pos += delta;
+    if (pos >= mod) pos -= mod;
+    if (pos == first) { assert (count == mod); break; }
+    if (mod == 1) break;
+    if (first == mod) first = last;
+  }
+  failed = lgl->stats->trd.failed - failed;
+  red = lgl->stats->trd.red - red;
+  success = failed || red;
+  LGLUPDPEN (trd, success);
+  assert (lgl->simp);
+  lglprt (lgl, 1,
+    "[transred-%d] removed %d transitive binary clauses",
+    lgl->stats->trd.count, red);
+  lglprt (lgl, 1 + !failed,
+    "[transred-%d] found %d units",
+    lgl->stats->trd.count, failed);
+  lgl->simp = 0;
+  lglrep (lgl, 2, 'D');
+  lglstop (lgl);
+  return !lgl->mt;
+}
+
+static int lglunhdhasbins (LGL * lgl, const DFPR * dfpr,
+			   int lit, int irronly) {
+  int blit, tag, other, val, red, ulit;
+  const int * p, * w, * eos;
+  HTS * hts;
+  assert (!lglval (lgl, lit));
+  hts = lglhts (lgl, lit);
+  w = lglhts2wchs (lgl, hts);
+  eos = w + hts->count;
+  for (p = w; p < eos; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == OCCS) continue;
+    if (tag == TRNCS || tag == LRGCS) { p++; continue; }
+    red = blit & REDCS;
+    if (irronly && red) continue;
+    other = blit >> RMSHFT;
+    val = lglval (lgl, other);
+    assert (val >= 0);
+    if (val > 0) continue;
+    ulit = lglulit (other);
+    if (!dfpr[ulit].discovered) return 1;
+  }
+  return 0;
+}
+
+static int lglunhdisroot (LGL * lgl, int lit, DFPR * dfpr, int irronly) {
+  int res = !lglunhdhasbins (lgl, dfpr, lit, irronly);
+  assert (!res || !dfpr[lglulit (lit)].discovered);
+  return res;
+}
+
+static int lglmtwtk (Wtk * wtk) { return wtk->top == wtk->start; }
+
+static int lglfullwtk (Wtk * wtk) { return wtk->top == wtk->end; }
+
+static int lglsizewtk (Wtk * wtk) { return wtk->end - wtk->start; }
+
+static int lglcntwtk (Wtk * wtk) { return wtk->top - wtk->start; }
+
+static void lglrelwtk (LGL * lgl, Wtk * wtk) {
+  DEL (wtk->start, lglsizewtk (wtk));
+  memset (wtk, 0, sizeof *wtk);
+}
+
+static void lglenlwtk (LGL * lgl, Wtk * wtk) {
+  int oldsize = lglsizewtk (wtk);
+  int newsize = oldsize ? 2*oldsize : 1;
+  int count = lglcntwtk (wtk);
+  RSZ (wtk->start, oldsize, newsize);
+  wtk->top = wtk->start + count;
+  wtk->end = wtk->start + newsize;
+}
+
+static void lglpushwtk (LGL * lgl, Wtk * wtk,
+			Wrag wrag, int lit, int other, int red) {
+  Work w;
+  if (lglfullwtk (wtk)) lglenlwtk (lgl, wtk);
+  w.wrag = wrag;
+  w.other = other;
+  w.red = red ? 1 : 0;
+  w.removed = 0;
+  w.lit = lit;
+  *wtk->top++ = w;
+}
+
+static int lglstamp (LGL * lgl, int root,
+		     DFPR * dfpr, DFOPF * dfopf,
+		     Wtk * work, Stk * units, Stk * sccs, Stk * trds,
+		     int * visitedptr, int stamp, int irronly) {
+  int uroot, lit, ulit, blit, tag, red, other, failed, uother, unotother;
+  int observed, discovered, pos, undiscovered;
+  unsigned start, end, mod, i, j, sccsize;
+  const int * p, * w, * eos;
+  int startstamp;
+  const Work * r;
+  int removed;
+  HTS * hts;
+  Wrag wrag;
+  if (lglval (lgl, root)) return stamp;
+  uroot =  lglulit (root);
+  if (dfpr[uroot].discovered) return stamp;
+  assert (!dfpr[uroot].finished);
+  assert (lglmtwtk (work));
+  assert (lglmtstk (units));
+  assert (lglmtstk (sccs));
+  assert (lglmtstk (trds));
+  LOG (3, "stamping dfs %s %d %s",
+       (lglunhdisroot (lgl, root, dfpr, irronly) ? "root" : "start"), root,
+       irronly ? "only over irredundant clauses" :
+		 "also over redundant clauses");
+  startstamp = 0;
+  lglpushwtk (lgl, work, PREFIX, root, 0, 0);
+  while (!lglmtwtk (work)) {
+    INCSTEPS (unhd.steps);
+    LGLPOPWTK (work, wrag, lit, other, red, removed);
+    if (removed) continue;
+    if (wrag == PREFIX) {
+      ulit = lglulit (lit);
+      if (dfpr[ulit].discovered) {
+	dfopf[ulit].observed = stamp;
+	LOG (3, "stamping %d observed %d", lit, stamp);
+	continue;
+      }
+      assert (!dfpr[ulit].finished);
+      dfpr[ulit].discovered = ++stamp;
+      dfopf[ulit].observed = stamp;
+      LOG (3, "stamping %d observed %d", lit, stamp);
+      *visitedptr += 1;
+      if (!startstamp) {
+	startstamp = stamp;
+	LOG (3, "root %d with stamp %d", lit, startstamp);
+	dfpr[ulit].root = lit;
+	LOG (4, "stamping %d root %d", lit, lit);
+	assert (!dfpr[ulit].parent);
+	LOG (4, "stamping %d parent %d", lit, 0);
+      }
+      LOG (4, "stamping %d discovered %d", lit, stamp);
+      lglpushwtk (lgl, work, POSTFIX, lit, 0, 0);
+      assert (dfopf[ulit].pushed < 0);
+      dfopf[ulit].pushed = lglcntwtk (work);
+      assert (!dfopf[ulit].flag);
+      dfopf[ulit].flag = 1;
+      lglpushstk (lgl, sccs, lit);
+      hts = lglhts (lgl, -lit);
+      w = lglhts2wchs (lgl, hts);
+      eos = w + hts->count;
+      for (undiscovered = 0; undiscovered <= 1 ; undiscovered++) {
+	start = lglcntwtk (work);
+	for (p = w; p < eos; p++) {
+	  blit = *p;
+	  tag = blit & MASKCS;
+	  if (tag == OCCS) continue;
+	  if (tag == TRNCS || tag == LRGCS) { p++; continue; }
+	  assert (tag == BINCS);
+	  red = blit & REDCS;
+	  if (irronly && red) continue;
+	  other = blit >> RMSHFT;
+	  if (lglval (lgl, other)) continue;
+	  uother = lglulit (other);
+	  if (undiscovered != !dfpr[uother].discovered) continue;
+	  // Kind of defensive, since 'lglrmbindup' should avoid it
+	  // and this fix may not really work anyhow since it does
+	  // not distinguish between irredundant and redundant clauses.
+	  // Thus we put a hard COVER here.
+	  COVER (lglsignedmarked (lgl, other) > 0);
+	  if (lglsignedmarked (lgl, other) > 0) {
+	    LOG (2, "stamping skips duplicated edge %d %d", lit, other);
+	    continue;
+	  }
+	  lglsignedmark (lgl, other);
+	  lglpushwtk (lgl, work, BEFORE, lit, other, red);
+	}
+	end = lglcntwtk (work);
+	for (r = work->start + start; r < work->top; r++)
+	  lglunmark (lgl, r->other);
+	mod = (end - start);
+	if (mod <= 1) continue;
+	for (i = start; i < end - 1;  i++) {
+	  assert (1 < mod && mod == (end - i));
+	  j = lglrand (lgl) % mod--;
+	  if (!j) continue;
+	  j = i + j;
+	  SWAP (Work, work->start[i], work->start[j]);
+	}
+      }
+    } else if (wrag == BEFORE) {	// before recursive call
+      LOG (2, "stamping edge %d %d before recursion", lit, other);
+      lglpushwtk (lgl, work, AFTER, lit, other, red);
+      ulit = lglulit (lit);
+      uother = lglulit (other);
+      unotother = lglulit (-other);
+      if (lgl->opts->unhdextstamp.val && (irronly || red) &&
+	  dfopf[uother].observed > dfpr[ulit].discovered) {
+	LOG (2, "transitive edge %d %d during stamping", lit, other);
+	lgl->stats->unhd.stamp.trds++;
+	lgl->stats->prgss++;
+	if (red) lgl->stats->unhd.tauts.red++;
+	lglrmbcls (lgl, -lit, other, red);
+	if ((pos = dfopf[unotother].pushed) >= 0) {
+	  while (pos  < lglcntwtk (work)) {
+	    if (work->start[pos].lit != -other) break;
+	    if (work->start[pos].other == -lit) {
+	      LOG (3, "removing edge %d %d from DFS stack", -other, -lit);
+	      work->start[pos].removed = 1;
+	    }
+	    pos++;
+	  }
+	}
+	work->top--;
+	assert (dfpr[uother].discovered); // and thus 'parent' + 'root' set
+	continue;
+      }
+      observed = dfopf[unotother].observed;
+      if (lgl->opts->unhdextstamp.val && startstamp <= observed) {
+	LOG (1, "stamping failing edge %d %d", lit, other);
+	for (failed = lit;
+	     dfpr[lglulit (failed)].discovered > observed;
+	     failed = dfpr[lglulit (failed)].parent)
+	  assert (failed);
+	LOG (1, "stamping failed literal %d", failed);
+	lglpushstk (lgl, units, -failed);
+	lgl->stats->unhd.stamp.failed++;
+	if (dfpr[unotother].discovered && !dfpr[unotother].finished) {
+	  LOG (2, "stamping skips edge %d %d after failed literal %d",
+	       lit, other, failed);
+	  work->top--;
+	  continue;
+	}
+      }
+      if (!dfpr[uother].discovered) {
+	dfpr[uother].parent = lit;
+	LOG (4, "stamping %d parent %d", other, lit);
+	dfpr[uother].root = root;
+	LOG (4, "stamping %d root %d", other, root);
+	lglpushwtk (lgl, work, PREFIX, other, 0, 0);
+      }
+    } else if (wrag == AFTER) {		// after recursive call
+      LOG (2, "stamping edge %d %d after recursion", lit, other);
+      uother = lglulit (other);
+      ulit = lglulit (lit);
+      if (lgl->opts->unhdextstamp.val && !dfpr[uother].finished &&
+	  dfpr[uother].discovered < dfpr[ulit].discovered) {
+	LOG (2, "stamping back edge %d %d", lit, other);
+	dfpr[ulit].discovered = dfpr[uother].discovered;
+	LOG (3, "stamping %d reduced discovered to %d",
+	     lit, dfpr[ulit].discovered);
+	if (dfopf[ulit].flag) {
+	  LOG (2, "stamping %d as being part of a non-trivial SCC", lit);
+	  dfopf[ulit].flag = 0;
+	}
+      }
+      dfopf[uother].observed = stamp;
+      LOG (3, "stamping %d observed %d", other, stamp);
+    } else {
+      assert (wrag == POSTFIX);
+      LOG (2, "stamping postfix %d", lit);
+      ulit = lglulit (lit);
+      if (dfopf[ulit].flag) {
+	stamp++;
+	sccsize = 0;
+	discovered = dfpr[ulit].discovered;
+	do {
+	  other = lglpopstk (sccs);
+	  uother = lglulit (other);
+	  dfopf[uother].pushed = -1;
+	  dfopf[uother].flag = 0;
+	  dfpr[uother].discovered = discovered;
+	  dfpr[uother].finished = stamp;
+	  LOG (3, "stamping %d interval %d %d parent %d root %d",
+	       other, dfpr[uother].discovered, dfpr[uother].finished,
+	       dfpr[uother].parent, dfpr[uother].root);
+	  sccsize++;
+	} while (other != lit);
+	assert (lgl->opts->unhdextstamp.val || sccsize == 1);
+	if (sccsize > 1) {
+	  LOG (2, "stamping non trivial SCC of size %d", sccsize);
+	  lgl->stats->unhd.stamp.sumsccsizes += sccsize;
+	  lgl->stats->unhd.stamp.sccs++;
+	}
+      } else assert (lgl->opts->unhdextstamp.val);
+    }
+  }
+  assert (lglmtwtk (work));
+  assert (lglmtstk (sccs));
+  return stamp;
+}
+
+static int lglunhlca (LGL * lgl, const DFPR * dfpr, int a, int b) {
+  const DFPR * c, * d;
+  int u, v, p;
+  if (a == b) return a;
+  u = lglulit (a), v = lglulit (b);
+  c = dfpr + u, d = dfpr + v;
+  if (c->discovered <= d->discovered) {
+    p = a;
+  } else {
+    assert (c->discovered > d->discovered);
+    p = b;
+    SWAP (const DFPR *, c, d);
+  }
+  for (;;) {
+    assert (c->discovered <= d->discovered);
+    if (d->finished <= c->finished) break;
+    p = c->parent;
+    if (!p) break;
+    u = lglulit (p);
+    c = dfpr + u;
+  }
+  LOG (3, "unhiding least common ancestor of %d and %d is %d", a, b, p);
+  return p;
+}
+
+static int lglunhidefailed (LGL * lgl, const DFPR * dfpr) {
+  int idx, sign, lit, unit, nfailed = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      if (lglterminate (lgl)) return 0;
+      if (!lglsyncunits (lgl)) return 0;
+      INCSTEPS (unhd.steps);
+      lit = sign * idx;
+      if (lglval (lgl, lit)) continue;
+      if (!dfpr[lglulit (lit)].discovered) continue;
+      if (lglunhimplincl (dfpr, lit, -lit)) {
+	unit = -lit;
+	LOG (2, "unhiding %d implies %d", lit, -lit);
+      } else if (lglunhimplincl (dfpr, -lit, lit)) {
+	unit = lit;
+	LOG (2, "unhiding %d implies %d", -lit, lit);
+      } else continue;
+      LOG (1, "unhiding failed literal %d", -unit);
+      lglunit (lgl, unit);
+      lgl->stats->unhd.failed.lits++;
+      nfailed++;
+      if (lglbcp (lgl)) continue;
+      LOG (1, "empty clause after propagating unhidden failed literal");
+      assert (!lgl->mt);
+      lglmt (lgl);
+      return 0;
+    }
+  }
+  LOG (1, "unhiding %d failed literals in this round", nfailed);
+  return 1;
+}
+
+static int lglunhroot (const DFPR * dfpr, int lit) {
+  return dfpr[lglulit (lit)].root;
+}
+
+static int lglunhidebintrn (LGL * lgl, const DFPR * dfpr, int irronly) {
+  int idx, sign, lit, blit, tag, red, other, other2, unit, root, lca;
+  int nbinred, ntrnred, nbinunits, ntrnunits, ntrnstr, ntrnhbrs;
+  const int * p, * eow;
+  int ulit, uother;
+  ptrdiff_t delta;
+  int * w , * q;
+  HTS * hts;
+  nbinred = ntrnred = nbinunits = ntrnunits = ntrnstr = ntrnhbrs = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      if (lglterminate (lgl)) return 0;
+      if (!lglsyncunits (lgl)) return 0;
+      INCSTEPS (unhd.steps);
+      lit = sign * idx;
+      if (lglval (lgl, lit)) continue;
+      ulit = lglulit (lit);
+      if (!dfpr[ulit].discovered) continue;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      q = w;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	*q++ = blit;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) *q++ = *++p;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	other = blit >> RMSHFT;
+	if (lglval (lgl, other)) continue;
+	uother = lglulit (other);
+	if (tag == BINCS) {
+	  if (lglunhimplies2 (dfpr, other, lit)) {
+	    LOG (2, "unhiding removal of literal %d "
+		    "with implication %d %d from binary clause %d %d",
+		 other, other, lit, lit, other);
+	    lgl->stats->unhd.units.bin++;
+	    nbinunits++;
+	    unit = lit;
+UNIT:
+	    lglunit (lgl, unit);
+	    p++;
+	    while (p < eow) *q++ = *p++;
+	    lglshrinkhts (lgl, hts, hts->count - (p - q));
+	    if (lglbcp (lgl)) goto NEXTIDX;
+	    LOG (1, "empty clause after propagating unhidden lifted unit");
+	    assert (!lgl->mt);
+	    lglmt (lgl);
+	    return 0;
+	  } else if ((root = lglunhroot (dfpr, -lit)) &&
+		     !lglval (lgl, root) &&
+		     root == lglunhroot (dfpr, -other)) {
+	    LOG (2, "negated literals in binary clause %d %d implied by %d",
+		 lit, other, root);
+	    lgl->stats->unhd.failed.bin++;
+	    lca = lglunhlca (lgl, dfpr, -lit, -other);
+	    unit = -lca;
+	    assert (unit);
+	    goto UNIT;
+	  } else if (!irronly && !red) continue;
+	  else {
+	    if (dfpr[uother].parent == -lit) continue;
+	    if (dfpr[ulit].parent == -other) continue;
+	    if (!lglunhimplies2 (dfpr, -lit, other)) continue;
+	    LOG (2, "unhiding tautological binary clause %d %d", lit, other);
+	    lgl->stats->unhd.tauts.bin++;
+	    lgl->stats->prgss++;
+	    if (red) lgl->stats->unhd.tauts.red++;
+	    nbinred++;
+	    lglrmbwch (lgl, other, lit, red);
+	    LOG (2, "removed %s binary clause %d %d",
+		 lglred2str (red), lit, other);
+	    lgldeclscnt (lgl, 2, red, 0);
+	    assert (!lgl->dense);
+	    q--;
+	  }
+	} else {
+	  assert (tag == TRNCS);
+	  other2 = *p;
+	  if (lglval (lgl, other2)) continue;
+	  if (lglunhimplies2incl (dfpr, other, lit) &&
+	      lglunhimplies2incl (dfpr, other2, lit)) {
+	    LOG (2,
+		 "unhiding removal of literals %d and %d with implications "
+		 "%d %d and %d %d from ternary clause %d %d %d",
+		 other, other2,
+		 other, lit,
+		 other2, lit,
+		 lit, other, other2);
+	    lgl->stats->unhd.str.trn += 2;
+	    if (red) lgl->stats->unhd.str.red += 2;
+	    lgl->stats->unhd.units.trn++;
+	    ntrnunits++;
+	    unit = lit;
+	    goto UNIT;
+	  } else if ((root = lglunhroot (dfpr, -lit)) &&
+		     !lglval (lgl, root) &&
+		     root == lglunhroot (dfpr, -other) &&
+		     root == lglunhroot (dfpr, -other2)) {
+	    LOG (2,
+	      "negation of literals in ternary clauses %d %d %d "
+	      "implied by %d", lit, other, other2, root);
+	    lgl->stats->unhd.failed.trn++;
+	    lca = lglunhlca (lgl, dfpr, -lit, -other);
+	    assert (lca);
+	    lca = lglunhlca (lgl, dfpr, lca, -other2);
+	    assert (lca);
+	    unit = -lca;
+	    goto UNIT;
+	  } else if ((red || irronly) &&
+		     (lglunhimplies2incl (dfpr, -lit, other) ||
+		      lglunhimplies2incl (dfpr, -lit, other2))) {
+
+	    if (!lgl->opts->unhdatrn.val) continue;
+	    if (red && lgl->opts->unhdatrn.val == 1) continue;
+
+	    LOG (2, "unhiding %s tautological ternary clause %d %d %d",
+		 lglred2str (red), lit, other, other2);
+	    lgl->stats->unhd.tauts.trn++;
+	    lgl->stats->prgss++;
+	    if (red) lgl->stats->unhd.tauts.red++;
+	    ntrnred++;
+	    lglrmtwch (lgl, other, lit, other2, red);
+	    lglrmtwch (lgl, other2, lit, other, red);
+	    LOG (2, "removed %s ternary clause %d %d %d",
+		 lglred2str (red), lit, other, other2);
+	    lgldeclscnt (lgl, 3, red, 0);
+	    assert (!lgl->dense);
+	    if (!red && lgl->opts->move.val >= 2) {
+	      assert (q >= w);
+	      assert (q[-2] == blit);
+	      assert (q[-1] == other2);
+	      q[-2] |= REDCS;
+	      delta = lglwchtrn (lgl, other, lit, other2, REDCS);
+	      delta += lglwchtrn (lgl, other2, lit, other, REDCS);
+	      if (delta) w += delta, eow += delta, p += delta, q += delta;
+	      LOG (2, "moved ternary clause %d %d %d", lit, other, other2);
+              lgl->stats->red.trn++, assert (lgl->stats->red.trn > 0);
+	      lgl->stats->moved.trn++;
+	    } else q -= 2;
+	  } else if (lglunhimplies2incl (dfpr, other2, lit)) {
+TRNSTR:
+	    LOG (2,
+		 "unhiding removal of literal %d with implication "
+		 "%d %d from ternary clause %d %d %d",
+		 other2, other2, lit, lit, other, other2);
+	    lgl->stats->unhd.str.trn++;
+	    lgl->stats->prgss++;
+	    if (red) lgl->stats->unhd.str.red++;
+	    ntrnstr++;
+	    lglrmtwch (lgl, other, lit, other2, red);
+	    lglrmtwch (lgl, other2, lit, other, red);
+	    LOG (2, "removed %s ternary clause %d %d %d",
+		 lglred2str (red), lit, other, other2);
+	    lgldeclscnt (lgl, 3, red, 0);
+	    if (!red) lglincirr (lgl, 2);
+	    else lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+	    delta = lglwchbin (lgl, other, lit, red);
+	    if (delta) { p += delta, q += delta, eow += delta, w += delta; }
+	    (--q)[-1] = red | BINCS | RMSHFTLIT (other);
+	    lgldrupligaddclsarg (lgl, REDCS, lit, other, 0);
+	    continue;
+	  } else if (lglunhimplies2incl (dfpr, other, lit)) {
+	    SWAP (int, other, other2);
+	    goto TRNSTR;
+	  } else if (lgl->opts->unhdhbr.val &&
+		     (root = lglunhroot (dfpr, -lit)) &&
+		     !lglval (lgl, root)) {
+	    if (root == lglunhroot (dfpr, -other2)) {
+	      lca = lglunhlca (lgl, dfpr, -lit, -other2);
+	    } else if (root == lglunhroot (dfpr, -other)) {
+	      lca = lglunhlca (lgl, dfpr, -lit, -other);
+	      SWAP (int, other, other2);
+	    } else if (lglunhimplies2incl (dfpr, root, -other2)) lca = root;
+	    else if (lglunhimplies2incl (dfpr, root, -other)) {
+	      lca = root;
+	      SWAP (int, other, other2);
+	    } else continue;
+	    assert (lca);
+	    if (abs (lca) == abs (lit)) continue;
+	    if (abs (lca) == abs (other)) continue;
+	    if (abs (lca) == abs (other2)) continue;
+	    if (lglunhimplies2incl (dfpr, lca, other)) continue;
+	    LOG (2,
+	      "negations of literals %d %d in ternary clause %d %d %d "
+	      "implied by %d", lit, other2, lit, other, other2, lca);
+	    lgl->stats->unhd.hbrs.trn++;
+	    if (red) lgl->stats->unhd.hbrs.red++;
+	    lgl->stats->prgss++;
+	    ntrnhbrs++;
+	    LOG (2, "unhidden hyper binary resolved clause %d %d",-lca,other);
+	    lgldrupligaddclsarg (lgl, REDCS, -lca, other, 0);
+	    assert (lca != -lit);
+	    lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+	    delta = lglwchbin (lgl, -lca, other, REDCS);
+	    if (delta) { p += delta, q += delta, eow += delta, w += delta; }
+	    delta = lglwchbin (lgl, other, -lca, REDCS);
+	    if (delta) { p += delta, q += delta, eow += delta, w += delta; }
+	  }
+	}
+      }
+      lglshrinkhts (lgl, hts, hts->count - (p - q));
+    }
+NEXTIDX:
+    ;
+  }
+  if (nbinred) LOG (2, "unhiding %d tautological binary clauses", nbinred);
+  if (nbinunits) LOG (2, "unhiding %d units in binary clauses", nbinunits);
+  if (ntrnred) LOG (2, "unhiding %d tautological ternary clauses", ntrnred);
+  if (ntrnstr) LOG (2, "unhiding %d strengthened ternary clauses", ntrnstr);
+  if (ntrnunits) LOG (2, "unhiding %d units in ternary clauses", ntrnunits);
+  if (ntrnstr) LOG (2, 
+    "unhidden %d hyper binary resolution from ternary clauses", ntrnhbrs);
+  return 1;
+}
+
+static int lglcmpdfl (const DFL * a, const DFL * b) {
+  return a->discovered - b->discovered;
+}
+
+static int lglunhideglue (LGL * lgl, const DFPR * dfpr, int glue, int irronly) {
+  DFL * dfl, * eodfl, * d, * e; int szdfl, posdfl, negdfl, ndfl, res;
+  int oldsize, newsize, hastobesatisfied, satisfied, tautological;
+  int watched, lit, ulit, val, sign, nonfalse, root, lca, unit;
+  int ntaut = 0, nstr = 0, nunits = 0, nhbrs = 0, lidx;
+  int * p, * q, * c, * eoc, red;
+  int lca1, lca2, root1, root2;
+  Stk * lits;
+#ifndef NLGLOG
+  char type[20];
+  if (glue < 0) sprintf (type, "irredundant");
+  else sprintf (type, "redundant glue %d", glue);
+#endif
+  assert (!lgl->mt);
+  assert (-1 <= glue && glue < MAXGLUE);
+  if (glue < 0) {
+    lits = &lgl->irr;
+    red = 0;
+  } else {
+    lits = lgl->red + glue;
+    red = REDCS;
+  }
+  res = 1;
+  dfl = 0; szdfl = 0;
+  // go through all clauses of this glue and for each do:
+  //
+  //   SHRINK  simplify clause according to current assignment
+  //   FAILED  check if it is a hidden failed literal
+  //   HTE     check if it is a hidden tautology
+  //   STRNEG  remove hidden literals using complement literals
+  //   STRPOS  remove hidden literals using positive literals
+  //   HBR     perform unhiding hyper binary resolution
+  //   NEXT    clean up, unwatch if necessary, reconnect bin/trn, bcp unit
+  //
+  for (c = lits->start; !lgl->mt && c < lits->top; c = eoc + 1) {
+    if (lglterminate (lgl) || !lglsyncunits (lgl)) { res = 0; break; }
+    if ((lit = *(eoc = c)) >= NOTALIT) continue;
+    INCSTEPS (unhd.steps);
+    lidx = c - lits->start;
+    if (red) { lidx <<= GLUESHFT; lidx |= glue; }
+    watched = 1;
+    while (*eoc) eoc++;
+    oldsize = eoc - c;
+
+    unit = hastobesatisfied = satisfied = tautological = ndfl = 0;
+//SHRINK: check satisfied + remove false literals + count visited
+    q = c;
+    nonfalse = posdfl = negdfl = 0;
+    for (p = c; p < eoc; p++) {
+      lit = *p;
+      val = lglval (lgl, lit);
+      if (val > 0) {
+	satisfied = 1;
+	q = c + 2;
+	break;
+      }
+      if (val < 0) {
+	if (p < c + 2) {
+	  *q++ = lit;		// watched, so have to keep it
+	  hastobesatisfied = 1;	// for assertion checking only
+	}
+	continue;
+      }
+      *q++ = lit;
+      nonfalse++;
+      if (dfpr[lglulit (lit)].discovered) posdfl++;	// count pos in BIG
+      if (dfpr[lglulit (-lit)].discovered) negdfl++;	// count neg in BIG
+    }
+    *(eoc = q) = 0;
+    assert (eoc - c >= 2);	// we assume bcp done before
+    ndfl = posdfl + negdfl;	// number of literals in BIG
+    if (hastobesatisfied) assert (satisfied);
+    if (satisfied || ndfl < 2) goto NEXT;
+    assert (nonfalse = eoc - c);
+    assert (nonfalse >= negdfl);
+//FAILED: find root implying all negated literals
+    if (nonfalse != negdfl) goto HTE;	// not enough complement lits in BIG
+    assert (c < eoc);
+    root = lglunhroot (dfpr, -*c);
+    if (lglval (lgl, root)) goto HTE;
+    for (p = c + 1; p < eoc && lglunhroot (dfpr, -*p) == root; p++)
+      ;
+    if (p < eoc) goto HTE;		// at least two roots
+    LOGCLS (2, c, "unhiding failed literal through large %s clause",type);
+    LOG (2, "unhiding that all negations are implied by root %d", root);
+    lca = -*c;
+    for (p = c + 1; p < eoc; p++)
+      lca = lglunhlca (lgl, dfpr, -*p, lca);
+    assert (!lglval (lgl, lca));
+    LOG (2, "unhiding failed large %s clause implied by LCA %d", type, lca);
+    lgl->stats->unhd.failed.lrg++;
+    unit = -lca;
+    goto NEXT;  // otherwise need to properly unwatch and restart etc.
+		// which is too difficult to implement so leave further
+		// simplification of this clause to next unhiding round
+HTE:
+    if (glue < 0 && !irronly) goto STRNEG; // skip tautology checking if
+					   // redundant clauses used and
+					   // we work on irredundant clauses
+    if (posdfl < 2 || negdfl < 2) goto STRNEG;
+    if (ndfl > szdfl) { RSZ (dfl, szdfl, ndfl); szdfl = ndfl; }
+    ndfl = 0;
+    // copy all literals and their complements to 'dfl'
+    for (p = c; p < eoc; p++) {
+      for (sign = -1; sign <= 1; sign += 2) {
+	lit = *p;
+	ulit = lglulit (sign * lit);
+	if (!dfpr[ulit].discovered) continue;	// not in BIG so skip
+	assert (ndfl < szdfl);
+	dfl[ndfl].discovered = dfpr[ulit].discovered;
+	dfl[ndfl].finished = dfpr[ulit].finished;
+	dfl[ndfl].sign = sign;
+#ifndef NLGLOG
+	dfl[ndfl].lit4logging = lit;
+#endif
+	ndfl++;
+      }
+    }
+    ADDSTEPS (unhd.steps, 6);				// rough guess
+    SORT (DFL, dfl, ndfl, lglcmpdfl);
+    eodfl = dfl + ndfl;
+    // Now check if there are two consecutive literals, the first
+    // a complement of a literal in the clause, which implies another
+    // literal actually occurring positive in the clause, where
+    // 'd' ranges over complement literals
+    // 'e' ranges over original literals
+    for (d = dfl; d < eodfl - 1; d++)
+      if (d->sign < 0) break;			// get first negative pos
+    while (d < eodfl - 1) {
+      assert (d->sign < 0);
+      for (e = d + 1; e < eodfl && e->finished < d->finished; e++) {
+	if (e->sign < 0) continue;		// get next positive pos
+	assert (d->sign < 0 && e->sign > 0);
+	assert (d->discovered <= e->discovered);
+	assert (e ->finished <= d->finished);
+	LOGCLS (2, c,
+		"unhiding with implication %d %d tautological %s clause",
+		-d->lit4logging, e->lit4logging, type);
+	ntaut++;
+	lgl->stats->unhd.tauts.lrg++;
+	if (red) lgl->stats->unhd.tauts.red++;
+	lgl->stats->prgss++;
+	tautological = 1;
+	goto NEXT;
+      }
+      for (d = e; d < eodfl && d->sign > 0; d++)
+	;
+    }
+STRNEG:
+    if (negdfl < 2) goto STRPOS;
+    if (negdfl > szdfl) { RSZ (dfl, szdfl, negdfl); szdfl = negdfl; }
+    INCSTEPS (unhd.steps);
+    ndfl = 0;
+    // copy complement literals to 'dfl'
+    for (p = c; p < eoc; p++) {
+      lit = *p;
+      ulit = lglulit (-lit);			// NOTE: '-lit' not 'lit'
+      if (!dfpr[ulit].discovered) continue;
+      assert (ndfl < szdfl);
+      dfl[ndfl].discovered = dfpr[ulit].discovered;	// of '-lit'
+      dfl[ndfl].finished = dfpr[ulit].finished;		// of '-lit'
+      dfl[ndfl].lit = lit;			// NOTE: but 'lit' here
+      ndfl++;
+    }
+    if (ndfl < 2) goto STRPOS;
+    ADDSTEPS (unhd.steps, 3);			// rough guess
+    SORT (DFL, dfl, ndfl, lglcmpdfl);
+    eodfl = dfl + ndfl;
+    for (d = dfl; d < eodfl - 1; d = e) {
+      assert (d->discovered);
+      for (e = d + 1; e < eodfl && d->finished >= e->finished; e++) {
+	assert (d->discovered <= e->discovered);
+	lit = e->lit;
+	LOGCLS (2, c,
+		"unhiding removal of literal %d "
+		"with implication %d %d from large %s clause",
+		lit, -d->lit, -e->lit, type);
+	e->lit = 0;
+	nstr++;
+	lgl->stats->unhd.str.lrg++;
+	if (red) lgl->stats->unhd.str.red++;
+	lgl->stats->prgss++;
+	if (!watched) continue;
+	if (lit != c[0] && lit != c[1]) continue;
+	lglrmlwch (lgl, c[0], red, lidx);
+	lglrmlwch (lgl, c[1], red, lidx);
+	watched = 0;
+      }
+    }
+    assert (eoc - c >= 1 );
+    q = c;
+    if (watched) q += 2;			// keep watched literals
+						// if we still watch
+    // move non BIG literals
+    for (p = q; p < eoc; p++) {
+      lit = *p;
+      ulit = lglulit (-lit);			// NOTE: '-lit' not 'lit'
+      if (dfpr[ulit].discovered) continue;
+      *q++ = lit;
+    }
+    // copy from 'dfl' unremoved BIG literals back to clause
+    for (d = dfl; d < eodfl; d++) {
+      lit = d->lit;
+      if (!lit) continue;
+      if (watched && lit == c[0]) continue;
+      if (watched && lit == c[1]) continue;
+      *q++ = lit;
+    }
+    *(eoc = q) = 0;
+STRPOS:
+    if (posdfl < 2) goto HBR;
+    if (posdfl > szdfl) { RSZ (dfl, szdfl, posdfl); szdfl = posdfl; }
+    ndfl = 0;
+    // copy original literals to 'dfl' but sort reverse wrt 'discovered'
+    for (p = c; p < eoc; p++) {
+      lit = *p;
+      ulit = lglulit (lit);			// NOTE: now 'lit'
+      if (!dfpr[ulit].discovered) continue;
+      assert (ndfl < szdfl);
+      dfl[ndfl].discovered = -dfpr[ulit].discovered;	// of 'lit'
+      dfl[ndfl].finished = -dfpr[ulit].finished;		// of 'lit'
+      dfl[ndfl].lit = lit;
+      ndfl++;
+    }
+    if (ndfl < 2) goto NEXT;
+    ADDSTEPS (unhd.steps, 3);			// rough guess
+    SORT (DFL, dfl, ndfl, lglcmpdfl);
+    eodfl = dfl + ndfl;
+    for (d = dfl; d < eodfl - 1; d = e) {
+      assert (d->discovered);
+      for (e = d + 1; e < eodfl && d->finished >= e->finished; e++) {
+	assert (d->discovered <= e->discovered);
+	lit = e->lit;
+	LOGCLS (2, c,
+		"unhiding removal of literal %d "
+		"with implication %d %d from large %s clause",
+		lit, e->lit, d->lit, type);
+	e->lit = 0;
+	nstr++;
+	lgl->stats->unhd.str.lrg++;
+	if (red) lgl->stats->unhd.str.red++;
+	lgl->stats->prgss++;
+	if (!watched) continue;
+	if (lit != c[0] && lit != c[1]) continue;
+	lglrmlwch (lgl, c[0], red, lidx);
+	lglrmlwch (lgl, c[1], red, lidx);
+	watched = 0;
+      }
+    }
+    assert (eoc - c >= 1 );
+    q = c;
+    if (watched) q += 2;
+    for (p = q; p < eoc; p++) {
+      lit = *p;
+      ulit = lglulit (lit);			// NOTE: now 'lit'
+      if (dfpr[ulit].discovered) continue;
+      *q++ = lit;
+    }
+    for (d = dfl; d < eodfl; d++) {
+      lit = d->lit;
+      if (!lit) continue;
+      if (watched && lit == c[0]) continue;
+      if (watched && lit == c[1]) continue;
+      *q++ = lit;
+    }
+    *(eoc = q) = 0;
+HBR:
+    if (!lgl->opts->unhdhbr.val) goto NEXT;
+    if (eoc - c < 3) goto NEXT;
+    root1 = root2 = lca1 = lca2 = 0;
+    for (p = c; (lit = *p); p++) {
+      root = lglunhroot (dfpr, -lit);
+      if (!root) root = -lit;
+      if (!root1) { root1 = root; continue; }
+      if (root1 == root) continue;
+      if (!root2) { root2 = root; continue; }
+      if (root2 == root) continue;
+      if (lglunhimplies2incl (dfpr, root1, -lit)) { lca1 = root1; continue; }
+      if (lglunhimplies2incl (dfpr, root2, -lit)) { lca2 = root2; continue; }
+      goto NEXT;			// else more than two roots ...
+    }
+    assert (root1);
+    if (!root2) goto NEXT;
+    if (root1 == -root2) goto NEXT;
+    if (lglunhimplies2incl (dfpr, root1, -root2)) goto NEXT;
+    LOGCLS (2, c, "root hyper binary resolution %d %d of %s clause",
+	    -root1, -root2, type);
+    if (!lca1 && !lca2) {
+      for (p = c; (lit = *p); p++) {
+	root = lglunhroot (dfpr, -lit);
+	if (root) {
+	  if (root == root1)
+	    lca1 = lca1 ? lglunhlca (lgl, dfpr, lca1, -lit) : -lit;
+	  if (root == root2)
+	    lca2 = lca2 ? lglunhlca (lgl, dfpr, lca2, -lit) : -lit;
+	} else {
+	  assert (!lca2);
+	  if (lca1) lca2 = -lit; else lca1 = -lit;
+	}
+      }
+    } else {
+      if (!lca1) lca1 = root1;
+      if (!lca2) lca2 = root2;
+    }
+    if (lca1 == -lca2) goto NEXT;
+    if (lglunhimplies2incl (dfpr, lca1, -lca2)) goto NEXT;
+    LOGCLS (2, c, "lca hyper binary resolution %d %d of %s clause",
+	    -lca1, -lca2, type);
+    lgl->stats->unhd.hbrs.lrg++;
+    if (red) lgl->stats->unhd.hbrs.red++;
+    lgldrupligaddclsarg (lgl, REDCS, -lca1, -lca2, 0);
+    lglwchbin (lgl, -lca1, -lca2, REDCS);
+    lglwchbin (lgl, -lca2, -lca1, REDCS);
+    lgl->stats->red.bin++;
+    assert (lgl->stats->red.bin > 0);
+NEXT:
+    newsize = eoc - c;
+    assert (satisfied || tautological || newsize >= 1);
+    if (newsize <= 3 || satisfied || tautological) {
+      lgldeclscnt (lgl, oldsize, red, glue);
+      if (watched) {
+	lglrmlwch (lgl, c[0], red, lidx);
+	lglrmlwch (lgl, c[1], red, lidx);
+      }
+    } else if (!red) {
+      assert (lgl->stats->irr.lits.cur >= c + oldsize - eoc);
+      lgl->stats->irr.lits.cur -= c + oldsize - eoc;
+    }
+    assert (!*eoc);
+    for (p = c + oldsize; p > eoc; p--) *p = REMOVED;
+    if (satisfied || tautological) {
+      while (p >= c) *p-- = REMOVED;
+      if (red) { LGLCHKACT (c[-1]); c[-1] = REMOVED; }
+      eoc = c + oldsize;
+      continue;
+    }
+    if (newsize < oldsize) lgldrupligaddclsaux (lgl, REDCS, c);
+    if (red && newsize <= 3) { LGLCHKACT (c[-1]); c[-1] = REMOVED; }
+    if (newsize > 3 && !watched) {
+      (void) lglwchlrg (lgl, c[0], c[1], red, lidx);
+      (void) lglwchlrg (lgl, c[1], c[0], red, lidx);
+    } else if (newsize == 3) {
+      LOGCLS (2, c, "large %s clause became ternary", type);
+      lglwchtrn (lgl, c[0], c[1], c[2], red);
+      lglwchtrn (lgl, c[1], c[0], c[2], red);
+      lglwchtrn (lgl, c[2], c[0], c[1], red);
+      if (!red) lglincirr (lgl, 3);
+      else lgl->stats->red.trn++, assert (lgl->stats->red.trn > 0);
+      c[0] = c[1] = c[2] = *eoc = REMOVED;
+    } else if (newsize == 2) {
+      LOGCLS (2, c, "large %s clause became binary", type);
+      lglwchbin (lgl, c[0], c[1], red);
+      lglwchbin (lgl, c[1], c[0], red);
+      if (!red) lglincirr (lgl, 2);
+      else lgl->stats->red.bin++, assert (lgl->stats->red.bin > 0);
+      c[0] = c[1] = *eoc = REMOVED;
+    } else if (newsize == 1) {
+      LOGCLS (2, c, "large %s clause became unit", type);
+      unit = c[0];		// even works if unit already set
+      c[0] = *eoc = REMOVED;
+      lgl->stats->unhd.units.lrg++;
+      nunits++;
+    }
+    if (!unit) continue;
+    lglunit (lgl, unit);
+    if (lglbcp (lgl)) continue;
+    assert (!lgl->mt);
+    lglmt (lgl);
+    LOG (1, "unhiding large clause produces empty clause");
+    res = 0;
+  }
+  if (nunits)
+    LOG (1, "unhiding %d units from large %s clauses", nunits, type);
+  if (ntaut)
+    LOG (1, "unhiding %d large tautological %s clauses", ntaut, type);
+  if (nstr)
+    LOG (1, "unhiding removal of %d literals in %s clauses", nstr, type);
+  if (nhbrs)
+    LOG (1, "unhiding %d hyper binary resolutions in %s clauses", nhbrs, type);
+  if (dfl) DEL (dfl, szdfl);
+  return res;
+}
+
+static void lglfixlrgwchs (LGL * lgl) {
+  int idx, sign, lit, blit, tag, red, lidx, fixed;
+  const int * p, * eow, * c;
+  int * q, * w;
+  HTS * hts;
+  fixed = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      q = w;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == BINCS) { *q++ = blit; continue; }
+	lidx = *++p;
+	if (tag == TRNCS) { *q++ = blit; *q++ = lidx; continue; }
+	assert (tag == LRGCS);
+	red = blit & REDCS;
+	c = lglidx2lits (lgl, red, lidx);
+	if (*c >= NOTALIT) { fixed++; continue; }
+	*q++ = blit;
+	*q++ = lidx;
+      }
+      lglshrinkhts (lgl, hts, hts->count - (p - q));
+    }
+  }
+  assert (!(fixed & 1));
+  if (fixed) LOG (1, "fixed %d large watches", fixed);
+}
+
+static int lglunhidelrg (LGL * lgl, const DFPR * dfpr, int irronly) {
+  int glue, res = 1;
+  for (glue = -1; res && glue < MAXGLUE; glue++)
+    res = lglunhideglue (lgl, dfpr, glue, irronly);
+  lglfixlrgwchs (lgl);
+  return res;
+}
+
+static int lglunhdunits (LGL * lgl) {
+  int res = lgl->stats->unhd.units.bin;
+  res += lgl->stats->unhd.units.trn;
+  res += lgl->stats->unhd.units.lrg;
+  return res;
+}
+
+static int lglunhdfailed (LGL * lgl) {
+  int res = lgl->stats->unhd.stamp.failed;
+  res += lgl->stats->unhd.failed.lits;
+  res += lgl->stats->unhd.failed.bin;
+  res += lgl->stats->unhd.failed.trn;
+  res += lgl->stats->unhd.failed.lrg;
+  return res;
+}
+
+static int lglunhdhbrs (LGL * lgl) {
+  int res = lgl->stats->unhd.hbrs.trn;
+  res += lgl->stats->unhd.hbrs.lrg;
+  return res;
+}
+
+static int lglunhdtauts (LGL * lgl) {
+  int res = lgl->stats->unhd.stamp.trds;
+  res += lgl->stats->unhd.tauts.bin;
+  res += lgl->stats->unhd.tauts.trn;
+  res += lgl->stats->unhd.tauts.lrg;
+  return res;
+}
+
+static int lglunhdstrd (LGL * lgl) {
+  int res = lgl->stats->unhd.units.bin;	// shared!
+  res += lgl->stats->unhd.str.trn;
+  res += lgl->stats->unhd.str.lrg;
+  return res;
+}
+
+static void lglrmbindup (LGL * lgl) {
+  int idx, sign, lit, blit, tag, red, other, round, redrem, irrem;
+  int * w, * eow, * p, * q;
+  HTS * hts;
+  redrem = irrem = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      assert (lglmtstk (&lgl->seen));
+      for (round = 0; round < 2; round++) {
+	hts = lglhts (lgl, lit);
+	w = lglhts2wchs (lgl, hts);
+	eow = w + hts->count;
+	q = w;
+	for (p = w; p < eow; p++) {
+	  blit = *p;
+	  tag = blit & MASKCS;
+	  if (tag != BINCS) *q++ = blit;
+	  if (tag== LRGCS || tag == TRNCS) *q++ = *++p;
+	  if (tag != BINCS) continue;
+	  red = blit & REDCS;
+	  other = blit >> RMSHFT;
+	  if (lglsignedmarked (lgl, other)) {
+	    if (round && !red) goto ONLYCOPY;
+	    if (red) redrem++; else irrem++;
+	    if (abs (lit) > abs (other)) {
+	      LOG (2,
+		"removing duplicated %s binary clause %d %d and 2nd watch %d",
+		lglred2str (red), lit, other, other);
+	      lgldeclscnt (lgl, 2, red, 0);
+	      if (!red && lgl->dense)
+		lgldecocc (lgl, lit), lgldecocc (lgl, other);
+	      lgl->stats->bindup.removed++;
+	      if (red) lgl->stats->bindup.red++;
+	    } else
+	      LOG (2,
+		"removing 1st watch %d of duplicated %s binary clause %d %d",
+		other, lglred2str (red), other, lit);
+	  } else {
+	    if ((!round && !red) || (round && red))
+	      lglsignedmarknpushseen (lgl, other);
+ONLYCOPY:
+	    *q++ = blit;
+	  }
+	}
+	lglshrinkhts (lgl, hts, hts->count - (p - q));
+      }
+      lglpopnunmarkstk (lgl, &lgl->seen);
+    }
+  }
+  assert (!(irrem & 1));
+  assert (!(redrem & 1));
+}
+
+static DFPR * lglstampall (LGL * lgl, int irronly) {
+  int roots, searches, noimpls, unassigned, visited;
+  unsigned pos, delta, mod, ulit, first, last, count;
+  int root, stamp, rootsonly, lit;
+  Stk units, sccs, trds;
+  DFOPF * dfopf, * q;
+  DFPR * dfpr;
+  Wtk work;
+  Val val;
+  if (lgl->nvars <= 2) return 0;
+  lglrmbindup (lgl);
+  NEW (dfpr, 2*lgl->nvars);
+  NEW (dfopf, 2*lgl->nvars);
+  CLR (work); CLR (sccs); CLR (trds); CLR (units);
+  for (q = dfopf; q < dfopf + 2*lgl->nvars; q++) q->pushed = -1;
+  searches = roots = noimpls = unassigned = stamp = visited = 0;
+  for (rootsonly = 1; rootsonly >= 0; rootsonly--) {
+    count = 0;
+    first = mod = 2*(lgl->nvars - 2);
+    assert (mod > 0);
+    pos = lglrand (lgl) % mod;
+    delta = lglrand (lgl) % mod;
+    if (!delta) delta++;
+    while (lglgcd (delta, mod) > 1)
+      if (++delta == mod) delta = 1;
+    LOG (2, "unhiding %s round start %u delta %u mod %u",
+	 (rootsonly ? "roots-only": "non-root"), pos, delta, mod);
+    for (;;) {
+      if (lglterminate (lgl)) { searches = 0; goto DONE; }
+      if (!lglsyncunits (lgl)) { assert (lgl->mt); goto DONE; }
+      ulit = pos + 4;
+      root = lglilit (ulit);
+      INCSTEPS (unhd.steps);
+      count++;
+      if (lglval (lgl, root)) goto CONTINUE;
+      if (rootsonly) unassigned++;
+      if (dfpr[lglulit (root)].discovered) goto CONTINUE;
+      if (rootsonly &&
+	  !lglunhdisroot (lgl, root, dfpr, irronly)) goto CONTINUE;
+      if (!lglunhdhasbins (lgl, dfpr, -root, irronly)) {
+	if (rootsonly) noimpls++; goto CONTINUE;
+      }
+      if (rootsonly) roots++;
+      searches++;
+      assert (lglmtstk (&units));
+      stamp = lglstamp (lgl, root, dfpr, dfopf,
+			&work, &units, &sccs, &trds, &visited,
+			stamp, irronly);
+      while (!lglmtstk (&units)) {
+	lit = lglpopstk (&units);
+	val = lglval (lgl, lit);
+	if (val > 0) continue;
+	if (val < 0) {
+	  assert (!lgl->mt);
+	  LOG (1, "unhidding stamp unit %d already false", lit);
+	  lglmt (lgl);
+	  goto DONE;
+	}
+	lglunit (lgl, lit);
+	if (!lglbcp (lgl)) {
+	  assert (!lgl->mt);
+	  LOG (1, "propagating unhidden stamp unit %d failed", lit);
+	  lglmt (lgl);
+	  goto DONE;
+	}
+      }
+CONTINUE:
+      last = pos;
+      pos += delta;
+      if (pos >= mod) pos -= mod;
+      if (pos == first) { assert (count == mod); break; }
+      if (mod == 1) break;
+      if (first == mod) first = last;
+    }
+  }
+  assert (searches >= roots);
+  lglprt (lgl, 2,
+	  "[unhd-%d-%d] %d unassigned variables out of %d (%.0f%%)",
+	  lgl->stats->unhd.count, lgl->stats->unhd.rounds,
+	  lgl->unassigned, lgl->nvars - 2,
+	    lglpcnt (lgl->unassigned, lgl->nvars - 2));
+  lglprt (lgl, 2,
+	  "[unhd-%d-%d] %d root literals out of %d (%.0f%%)",
+	  lgl->stats->unhd.count, lgl->stats->unhd.rounds,
+	  roots, unassigned, lglpcnt (roots, unassigned));
+  lglprt (lgl, 2,
+    "[unhd-%d-%d] %d additional non-root searches out of %d (%.0f%%)",
+	  lgl->stats->unhd.count, lgl->stats->unhd.rounds,
+	  searches - roots, unassigned,
+	    lglpcnt (searches - roots, unassigned));
+  lglprt (lgl, 2,
+	  "[unhd-%d-%d] %d literals not in F2 out of %d (%.0f%%)",
+	  lgl->stats->unhd.count, lgl->stats->unhd.rounds,
+	  noimpls, unassigned, lglpcnt (noimpls, unassigned));
+  lglprt (lgl, 2,
+	  "[unhd-%d-%d] %d visited literals out of %d (%.0f%%)",
+	  lgl->stats->unhd.count, lgl->stats->unhd.rounds,
+	  visited, unassigned, lglpcnt (visited, unassigned));
+  lglprt (lgl, 2,
+	  "[unhd-%d-%d] %.2f average number visited literals per search",
+	  lgl->stats->unhd.count, lgl->stats->unhd.rounds,
+	  lglavg (visited, searches));
+DONE:
+  if (!searches || lgl->mt) { DEL (dfpr, 2*lgl->nvars); dfpr = 0; }
+  lglrelwtk (lgl, &work);
+  lglrelstk (lgl, &units);
+  lglrelstk (lgl, &sccs);
+  lglrelstk (lgl, &trds);
+  DEL (dfopf, 2*lgl->nvars);
+  return dfpr;
+}
+
+static void lglsetunhdlim (LGL * lgl) {
+  int64_t limit, irrlim;
+  int pen, szpen;
+  limit = (lgl->opts->unhdreleff.val*lglvisearch (lgl))/1000;
+  if (limit < lgl->opts->unhdmineff.val) limit = lgl->opts->unhdmineff.val;
+  if (lgl->opts->unhdmaxeff.val >= 0 && limit > lgl->opts->unhdmaxeff.val)
+    limit = lgl->opts->unhdmaxeff.val;
+  limit >>= (pen = lgl->limits->unhd.pen + (szpen = lglszpenaux (lgl, 1, 1)));
+  irrlim = (lgl->stats->irr.clauses.cur/16) >> szpen;
+  if (lgl->opts->irrlim.val && limit < irrlim) {
+    limit = irrlim;
+    lglprt (lgl, 1,
+      "[unhide-%d] limit %lld based on %d irredundant clauses penalty %d",
+      lgl->stats->unhd.count,
+      (LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+  } else
+    lglprt (lgl, 1, "[unhide-%d] limit %lld with penalty %d = %d + %d",
+      lgl->stats->unhd.count, (LGLL) limit,
+      pen, lgl->limits->unhd.pen, szpen);
+  lgl->limits->unhd.steps = lgl->stats->unhd.steps + limit;
+}
+
+static int lglunhide (LGL * lgl) {
+  int irronly, round, maxrounds, noprgssrounds, success;
+  int oldunits, oldfailed, oldtauts, oldhbrs, oldstrd;
+  int deltaunits, deltafailed;
+  int64_t roundprgss = 0;
+  DFPR * dfpr = 0;
+  assert (lgl->opts->unhide.val);
+  if (lgl->nvars <= 2) return 1;
+  lgl->stats->unhd.count++;
+  assert (!lgl->unhiding);
+  lgl->unhiding = 1;
+  assert (!lgl->simp);
+  lgl->simp = 1;
+  lglstart (lgl, &lgl->times->unhide);
+  irronly = !lgl->stats->red.bin || (lgl->stats->unhd.count & 1);
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  maxrounds = lgl->opts->unhdroundlim.val;
+  lglsetunhdlim (lgl);
+  oldunits = lglunhdunits (lgl);
+  oldfailed = lglunhdfailed (lgl);
+  oldtauts = lglunhdtauts (lgl);
+  oldhbrs = lglunhdhbrs (lgl);
+  oldstrd = lglunhdstrd (lgl);
+  noprgssrounds = round = 0;
+  while (!lgl->mt) {
+    if (round >= maxrounds) break;
+    if (round > 0 &&
+        roundprgss == lgl->stats->prgss &&
+	noprgssrounds++ == lgl->opts->unhdlnpr.val) {
+      LOG (1, "too many non progress unhiding rounds");
+      break;
+    }
+    round++;
+    roundprgss = lgl->stats->prgss;
+    lgl->stats->unhd.rounds++;
+    lglgc (lgl);
+    if (!lgl->nvars || lgl->mt) break;
+    assert (!dfpr);
+    dfpr = lglstampall (lgl, irronly);
+    if (!dfpr) break;
+    if (!lglunhidefailed (lgl, dfpr)) break;
+    if (!lglunhidebintrn (lgl, dfpr, irronly)) break;
+    if (!lglunhidelrg (lgl, dfpr, irronly)) break;
+    if (lgl->stats->unhd.steps >= lgl->limits->unhd.steps) break;
+    irronly = !lgl->stats->red.bin || !irronly;
+    DEL (dfpr, 2*lgl->nvars);
+    assert (!dfpr);
+  }
+  if (dfpr) DEL (dfpr, 2*lgl->nvars);
+  lglprt (lgl, 1,
+    "[unhide-%d-%d] %d units, %d failed, %d tauts, %d hbrs, %d literals",
+    lgl->stats->unhd.count, lgl->stats->unhd.rounds,
+    (deltaunits = lglunhdunits (lgl) - oldunits),
+    (deltafailed = lglunhdfailed (lgl) - oldfailed),
+    lglunhdtauts (lgl) - oldtauts,
+    lglunhdhbrs (lgl) - oldhbrs,
+    lglunhdstrd (lgl) - oldstrd);
+  success = deltaunits + deltafailed;
+  LGLUPDPEN (unhd, success);
+  assert (lgl->simp);
+  lgl->simp = 0;
+  assert (lgl->unhiding);
+  lgl->unhiding = 0;
+  lglrep (lgl, 2, 'u');
+  lglstop (lgl);
+  return !lgl->mt;
+}
+
+static int lglpar64 (uint64_t i) {
+  unsigned x;
+  int res = 0;
+  for (x = i; x; x = x & (x - 1))
+    res = !res;
+  return res;
+}
+
+static uint64_t lgldec64 (uint64_t i) {
+  uint64_t res;
+  for (res = i - 1; lglpar64 (res); res--)
+    ;
+  return res;
+}
+
+static void lglgdump (LGL * lgl) {
+#ifndef NLGLOG
+  const int * p, * start, * top;
+  start = lgl->gauss->xors.start;
+  top = lgl->gauss->xors.top;
+  for (p = start; p < top; p++) {
+    if (*p >= NOTALIT) continue;
+    fprintf (lgl->out, "c eqn[%lld]", (LGLL)(p - start));
+    while (*p > 1) fprintf (lgl->out, " %d", *p++);
+    fprintf (lgl->out, " = %d\n", *p);
+  }
+#endif
+}
+
+static int lglgaussubclsaux (LGL * lgl, uint64_t signs,  const int * c) {
+  int lit, i, min, minocc, tmpocc, blit, tag, other, other2, red, lidx;
+  const int * p, * w, * eow, * d, * q;
+  HTS * hts;
+  assert (lgl->dense);
+  minocc = INT_MAX;
+  min = i = 0;
+  INCSTEPS (gauss.steps.extr);
+  for (p = c; (lit = *p); p++) {
+    if (lglmarked (lgl, lit)) return 0;
+    assert (i < 8 * sizeof signs);
+    if (signs & (1ull << i++)) lit = -lit;
+    lglsignedmark (lgl, lit);
+    tmpocc = lglocc (lgl, lit) + lglhts (lgl, lit)->count;
+    assert (tmpocc < INT_MAX);
+    if (tmpocc >= minocc) continue;
+    minocc = tmpocc;
+    min = lit;
+  }
+  assert (min);
+  hts = lglhts (lgl, min);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    INCSTEPS (gauss.steps.extr);
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    if (tag == BINCS) {
+      other = blit >> RMSHFT;
+      if (lglsignedmarked (lgl, other)) return 1;
+    } else if (tag == TRNCS) {
+      other = blit >> RMSHFT;
+      if (!lglsignedmarked (lgl, other)) continue;
+      other2 = *p;
+      if (lglsignedmarked (lgl, other2)) return 1;
+    } else {
+      assert (tag == OCCS);
+      red = blit & REDCS;
+      lidx = blit >> RMSHFT;
+      d = lglidx2lits (lgl, red, lidx);
+      for (q = d; (other = *q); q++)
+	if (!lglsignedmarked (lgl, other)) break;
+      if (!other) return 1;
+    }
+  }
+  return 0;
+}
+
+static int lglgaussubcls (LGL * lgl, uint64_t signs,  const int * c) {
+  int res = lglgaussubclsaux (lgl, signs, c), lit;
+  const int * p;
+  for (p = c; (lit = *p); p++) lglunmark (lgl, lit);
+  return res;
+}
+
+static void lglgaussextractedxorincstats (LGL * lgl, int size) {
+  lgl->stats->gauss.arity.sum.total += size;
+  if (lgl->stats->gauss.arity.max.total < size)
+    lgl->stats->gauss.arity.max.total = size;
+  if (lgl->stats->gauss.arity.max.last < size)
+    lgl->stats->gauss.arity.max.last = size;
+  lgl->stats->gauss.extracted.total++;
+  lgl->stats->gauss.extracted.last++;
+}
+
+#define GL 2
+
+static int lglgaussextractxoraux (LGL * lgl, const int * c) {
+  int lit, val, size, maxsize, negs, start, max, *d, * q;
+  int allxors = lgl->opts->gaussextrall.val;
+  uint64_t signs;
+  const int * p;
+  assert (!lgl->level);
+  maxsize = lgl->opts->gaussmaxor.val;
+  max = negs = size = 0;
+  start = lglcntstk (&lgl->gauss->xors);
+  for (p = c; (lit = *p); p++) {
+    if ((val = lglval (lgl, lit)) > 0) return 0;
+    if (val < 0) continue;
+    if (lit < 0) { 
+      if (!allxors && negs) return 0;
+      negs = !negs; 
+    }
+    if (!max || abs (max) < abs (lit)) max = lit;
+    lglpushstk (lgl, &lgl->gauss->xors, lit);
+    if (++size > maxsize) return 0;
+  }
+  assert (negs == 0 || negs == 1);
+  if (size <= 1) return 0;
+  if (!allxors && negs && max > 0) return 0;
+  lglpushstk (lgl, &lgl->gauss->xors, 0);
+  d = lgl->gauss->xors.start + start;
+  assert (size <= 8 * sizeof signs);
+  signs = lgldec64 (1ull << size);
+  do {
+    if (!lglgaussubcls (lgl, signs, d)) break;
+    signs = lgldec64 (signs);
+  } while (signs &&
+           lgl->stats->gauss.steps.extr < lgl->limits->gauss.steps.extr);
+  if (signs) return 0;
+  for (q = d; (lit = *q); q++) *q = abs (lit);
+  *q = !negs;
+  LOGEQN (GL, start, "extracted %d-ary XOR constraint",  size);
+  lglgaussextractedxorincstats (lgl, size);
+  return 1;
+}
+
+static int lglgaussextractexactly1 (LGL * lgl, const int * c) {
+  const int * p, * q;
+  int l, k, size, par;
+#ifndef NLGLOG
+  int start = lglcntstk (&lgl->gauss->xors);
+#endif
+  if (!lgl->opts->gausscardweak.val) return 0;
+  for (p = c; (l = *p); p++) {
+    if (lgl->stats->gauss.steps.extr >= lgl->limits->gauss.steps.extr) return 0;
+    for (q = p + 1; (k = *q); q++) {
+      INCSTEPS (gauss.steps.extr);
+      if (!lglhasbin (lgl, -l, -k)) return 0;
+    }
+  }
+  par = 1;
+  size = p - c;
+  for (p = c; (l = *p); p++) {
+    if (l < 0) l = -l, par = !par;
+    lglpushstk (lgl, &lgl->gauss->xors, l);
+  }
+  lglpushstk (lgl, &lgl->gauss->xors, par);
+  LOGEQN (GL, start, "extracted %d-ary exactly 1 constraint",  size);
+  lglgaussextractedxorincstats (lgl, size);
+  lgl->stats->gauss.arity.sum.exactly1 += size;
+  lgl->stats->gauss.extracted.exactly1++;
+  return 1;
+}
+
+static int lglgaussextractxor (LGL * lgl, const int * c) {
+  int res;
+  if (lglgaussextractexactly1 (lgl, c)) res = 1;
+  else {
+    int old = lglcntstk (&lgl->gauss->xors);
+    if (!(res = lglgaussextractxoraux (lgl, c)))
+    lglrststk (&lgl->gauss->xors, old);
+  }
+  return res;
+}
+
+static int lglgaussextractsmallit (LGL * lgl, int lit) {
+  int allxors = lgl->opts->gaussextrall.val;
+  int cls[4], blit, tag, other, other2;
+  const int * w, * eow, * p;
+  HTS * hts;
+  if (lgl->stats->gauss.steps.extr >= lgl->limits->gauss.steps.extr) 
+    return 0;
+  if (lglval (lgl, lit) > 0) return 1;
+  hts = lglhts (lgl, lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == OCCS || tag == LRGCS) continue;
+    other = blit >> RMSHFT;
+    if (!allxors && abs (other) < lit) continue;
+    cls[0] = lit;
+    cls[1] = other;
+    if (tag == TRNCS) {
+      other2 = *p;
+      if (!allxors && abs (other2) < lit) continue;
+      cls[2] = other2;
+      cls[3] = 0;
+    } else {
+      assert (tag == BINCS);
+      cls[2] = 0;
+    }
+    lglgaussextractxor (lgl, cls);
+  }
+  return 1;
+}
+
+static int lglgaussextractsmall (LGL * lgl) {
+  int64_t before = lgl->stats->gauss.extracted.total, after, delta;
+  int res;
+  lglrandlitrav (lgl, lglgaussextractsmallit);
+  after = lgl->stats->gauss.extracted.total;
+  delta = after - before;
+  res = (delta > INT_MAX) ? INT_MAX : delta;
+  return res;
+}
+
+static int lglgaussextractlarge (LGL * lgl) {
+  const int * p, * c;
+  int res = 0;
+  for (c = lgl->irr.start; c < lgl->irr.top; c = p + 1) {
+    if (lgl->stats->gauss.steps.extr >= lgl->limits->gauss.steps.extr) break;
+    if (*(p = c) >= NOTALIT) continue;
+    res += lglgaussextractxor (lgl, c);
+    while (*p) p++;
+  }
+  return res;
+}
+
+static void lglgaussconeqn (LGL * lgl, int eqn) {
+  const int * xors = lgl->gauss->xors.start;
+  int i, var;
+  INCSTEPS (gauss.steps.elim);
+  for (i = eqn; (var = xors[i]) > 1; i++)
+    lglpushstk (lgl, lgl->gauss->occs + var, eqn);
+}
+
+static void lglgaussdiseqn (LGL * lgl, int eqn) {
+  int * xors = lgl->gauss->xors.start, i, var;
+  for (i = eqn; (var = xors[i]) > 1; i++) {
+    xors[i] = NOTALIT;
+    lgl->gauss->garbage++;
+    INCSTEPS (gauss.steps.elim);
+    lglrmstk (lgl->gauss->occs + var, eqn);
+  }
+  xors[i] = NOTALIT;
+  lgl->gauss->garbage++;
+}
+
+static void lglgaussconnect (LGL * lgl) {
+  int c, i, eox = lglcntstk (&lgl->gauss->xors), connected, var, vars;
+  const int * xors = lgl->gauss->xors.start;
+  Stk * occs;
+  LOG (2,  "connecting equations");
+  assert (!lgl->gauss->occs);
+  NEW (lgl->gauss->occs, lgl->nvars);
+  vars = connected = 0;
+  for (c = 0; c < eox; c = i + 1) {
+    INCSTEPS (gauss.steps.elim);
+    for (i = c; (var = xors[i]) > 1; i++) {
+      occs = lgl->gauss->occs + var;
+      if (lglmtstk (occs)) vars++;
+      lglpushstk (lgl, lgl->gauss->occs + var, c);
+      connected++;
+    }
+  }
+  lglprt (lgl, 1, 
+     "[gauss-%d] connected %d occurrences of %d variables (average %.1f)",
+      lgl->stats->gauss.count, connected, vars, lglavg (connected, vars));
+}
+
+static int lglgaussorderidx (LGL * lgl,  int var) {
+  assert (2 <= var && var < lgl->nvars);
+  if (!lglmtstk (lgl->gauss->occs + var))
+    lglpushstk (lgl, &lgl->gauss->order, var);
+  return 1;
+}
+
+static void lglgaussorder (LGL * lgl) {
+  lglrandidxtrav (lgl, lglgaussorderidx);
+  NEW (lgl->gauss->eliminated, lgl->nvars);
+}
+
+static void lglgaussdisconnect (LGL * lgl) {
+  int idx;
+  assert (lgl->gauss->occs);
+  LOG (2, "disconnecting equations");
+  for (idx = 2; idx < lgl->nvars; idx++)
+    lglrelstk (lgl, lgl->gauss->occs + idx);
+  DEL (lgl->gauss->occs, lgl->nvars);
+  assert (!lgl->gauss->occs);
+}
+
+static void lglgaussextract (LGL * lgl) {
+  int extracted, lits;
+  assert (lglsmallirr (lgl));
+  if (lgl->level) lglbacktrack (lgl, 0);
+  lglgc (lgl);
+  if (lgl->mt) return;
+  lgldense (lgl, 0);
+  extracted = lglgaussextractsmall (lgl);
+  extracted += lglgaussextractlarge (lgl);
+  lits = lglcntstk (&lgl->gauss->xors) - extracted;
+  lglprt (lgl, 1,
+    "[gauss-%d] extracted %d xors of average arity %.1f",
+    lgl->stats->gauss.count, extracted, lglavg (lits, extracted));
+  lglsparse (lgl);
+  lglgc (lgl);
+  if (lgl->mt) return;
+  lglfitstk (lgl, &lgl->gauss->xors);
+}
+
+static int lglgaussoccs (LGL * lgl, int a) {
+  return lglcntstk (lgl->gauss->occs + a);
+}
+
+static int lglcmpgauss (LGL * lgl, int a, int b) {
+  int res = lglgaussoccs (lgl, a) - lglgaussoccs (lgl, b);
+  if (!res) res = a - b;
+  return res;
+}
+
+#define LGLCMPGAUSS(A,B) lglcmpgauss (lgl, *(A), *(B))
+
+static void lglgaussort (LGL * lgl) {
+  int max = lglcntstk (&lgl->gauss->order), rest, * start;
+  assert (lgl->gauss->next <= max);
+  rest = max - lgl->gauss->next;
+  start = lgl->gauss->order.start + lgl->gauss->next;
+  ADDSTEPS (gauss.steps.elim, rest);
+  SORT (int, start, rest, LGLCMPGAUSS);
+  lglprt (lgl, 3, 
+     "[gauss-%d] sorted %d remaining variables",
+      lgl->stats->gauss.count, rest);
+}
+
+static int lglgausspickeqn (LGL * lgl, int pivot) {
+  int res, cand, weight, size, tmp, other, found;
+  const int * p, * e, * q;
+  Stk * occs;
+  assert (lglgaussoccs (lgl, pivot));
+  res = -1;
+  weight = INT_MAX; size = INT_MAX;
+  occs = lgl->gauss->occs + pivot;
+  for (p = occs->start; p < occs->top; p++) {
+    e = lgl->gauss->xors.start + (cand = *p);
+    found = tmp = 0;
+    INCSTEPS (gauss.steps.elim);
+    for (q = e; (other = *q) > 1; q++) {
+      if (lgl->gauss->eliminated[other]) break;
+      if (other == pivot) { assert (!found); found++; continue; }
+      tmp += lglgaussoccs (lgl, other) - 1;
+    }
+    if (other > 1) continue;
+    assert (found);
+    if (res >= 0 && q - e >= size) continue;
+    if (res >= 0 && q - e == size && tmp >= weight) continue;
+    weight = tmp;
+    size = q - e;
+    res = cand;
+  }
+  if (res >= 0)
+    LOGEQN (2, res, "picking size %d weight %d equation", size, weight);
+  else
+    LOG (2, "no uneliminated equation for pivot %d left", pivot);
+  return res;
+}
+
+static void lglcpystk (LGL * lgl, Stk * dst, Stk * src) {
+  const int * p;
+  for (p = src->start; p < src->top; p++)
+    lglpushstk (lgl, dst, *p);
+}
+
+static int lglgaussaddeqn (LGL * lgl, int eqn) {
+  const int * p;
+  AVar * av;
+  int var;
+  for (p = lgl->gauss->xors.start + eqn; (var = *p) > 1; p++) {
+    av = lglavar (lgl, var);
+    if (!av->mark) lglpushstk (lgl, &lgl->clause, var);
+    av->mark = !av->mark;
+  }
+  return var;
+}
+
+static void lglgaussubst (LGL * lgl, int pivot, int subst) {
+  Stk * occs = lgl->gauss->occs + pivot;
+  int eqn, rhs, res;
+  const int * p;
+  int * q;
+  assert (lglcntstk (occs) > 1);
+  while (lglcntstk (occs) > 1) {
+    if (lglterminate (lgl)) return;
+    eqn = occs->start[0];
+    if (eqn == subst) eqn = occs->start[1];
+    assert (lglmtstk (&lgl->clause));
+    LOGEQN (2, subst, "  1st row (kept)     ");
+    rhs = lglgaussaddeqn (lgl, eqn);
+    LOGEQN (2, eqn, "  2nd row (replaced) ");
+    if (lglgaussaddeqn (lgl, subst)) rhs = !rhs;
+    lglgaussdiseqn (lgl, eqn);
+    q = lgl->clause.start;
+    for (p = q; p < lgl->clause.top; p++)
+      if (lglmarked (lgl, *p)) *q++ = *p;
+    lgl->clause.top = q;
+    if (!lglmtstk (&lgl->clause)) {
+      res = lglcntstk (&lgl->gauss->xors);
+      lglcpystk (lgl, &lgl->gauss->xors, &lgl->clause);
+      lglpushstk (lgl, &lgl->gauss->xors, rhs);
+      LOGEQN (2, res, "  result row         ");
+      lglgaussconeqn (lgl, res);
+    } else if (rhs == 0) {
+      LOG (2, "trivial result row 0 = 0");
+    } else {
+      assert (rhs == 1);
+      LOG (1, "inconsistent result row 0 = 1 from gaussian elimination");
+      lgl->mt= 1;
+    }
+    lglpopnunmarkstk (lgl, &lgl->clause);
+  }
+}
+
+static void lglgausschkeliminated (LGL * lgl) {
+#ifndef NDEBUG
+  int idx, eliminated, occs;
+  if (!lgl->opts->check.val) return;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    eliminated = lgl->gauss->eliminated[idx];
+    occs = lglgaussoccs (lgl, idx);
+    if (eliminated == 1) assert (occs == 1);
+    if (eliminated == 2) assert (occs == 0);
+  }
+#endif
+}
+
+static void lglgaussgc (LGL * lgl) {
+  int count = lglcntstk (&lgl->gauss->xors), * q;
+  const int * p;
+  if (lgl->gauss->garbage < count/2 + 10000) return;
+  lgl->stats->gauss.gcs++;
+  lglprt (lgl, 2, 
+     "[gauss-%d] collecting %d garbage out of %d",
+     lgl->stats->gauss.count, lgl->gauss->garbage, count);
+  lglgaussdisconnect (lgl);
+  q = lgl->gauss->xors.start;
+  for (p = q; p < lgl->gauss->xors.top; p++)
+    if (*p != NOTALIT) *q++ = *p;
+  lgl->gauss->xors.top = q;
+  lglfitstk (lgl, &lgl->gauss->xors);
+  lglgaussconnect (lgl);
+  lgl->gauss->garbage = 0;
+}
+
+static int lglgausselimvar (LGL * lgl, int pivot) {
+  int subst, changed, occs, eliminated;
+  LOG (2, "eliminating variable %d occurring %d times",
+       pivot, lglgaussoccs (lgl, pivot));
+  assert (!lgl->gauss->eliminated[pivot]);
+  if (!(occs = lglgaussoccs (lgl, pivot))) {
+    LOG (2, "variable %d disappeared ", pivot);
+    eliminated = 2;
+    changed = 0;
+  } else if (occs == 1) {
+    LOG (2, "eliminated variable %d occurrs exactly once", pivot);
+    eliminated = 1;
+    changed = 0;
+  } else {
+    lglgaussgc (lgl);
+    subst = lglgausspickeqn (lgl, pivot);
+    if (subst >= 0) {
+      lglgaussubst (lgl, pivot, subst);
+      eliminated = 1;
+      changed = 1;
+    } else {
+      eliminated = 3;
+      changed = 0;
+    }
+  }
+  lgl->gauss->eliminated[pivot] = eliminated;
+  lglgausschkeliminated (lgl);
+  return changed;
+}
+
+static void lglgausselim (LGL * lgl) {
+  int pivot, changed = 1;
+  while (!lgl->mt && lgl->gauss->next < lglcntstk (&lgl->gauss->order)) {
+    if (lgl->stats->gauss.steps.elim >= lgl->limits->gauss.steps.elim) break;
+    if (lglterminate (lgl)) break;
+    if (changed) lglgaussort (lgl);
+    pivot = lglpeek (&lgl->gauss->order, lgl->gauss->next++);
+    changed = lglgausselimvar (lgl, pivot);
+  }
+}
+
+static void lglgaussinit (LGL * lgl) {
+  assert (!lgl->gauss);
+  NEW (lgl->gauss, 1);
+}
+
+static void lglgaussreset (LGL * lgl) {
+  assert (lgl->gauss);
+  if (lgl->gauss->occs) lglgaussdisconnect (lgl);
+  if (lgl->gauss->eliminated) DEL (lgl->gauss->eliminated, lgl->nvars);
+  lglrelstk (lgl, &lgl->gauss->xors);
+  lglrelstk (lgl, &lgl->gauss->order);
+  DEL (lgl->gauss, 1);
+}
+
+static int lglgaussexp2 (LGL * lgl, int a, int b) {
+  assert (lgl->gaussing);
+  assert (lglmtstk (&lgl->clause));
+  if (lglhasbin (lgl, a, b)) return 0;
+  lglpushstk (lgl, &lgl->clause, a);
+  lglpushstk (lgl, &lgl->clause, b);
+  lglpushstk (lgl, &lgl->clause, 0);
+  LOGCLS (2, lgl->clause.start, "gauss exported binary clause");
+  lgladdcls (lgl, REDCS, 0, 0);
+  lglclnstk (&lgl->clause);
+  return 1;
+}
+
+static int lglgaussexp3 (LGL * lgl, int a, int b, int c) {
+  assert (lgl->gaussing);
+  assert (lglmtstk (&lgl->clause));
+  if (lglhastrn (lgl, a, b, c)) return 0;
+  lglpushstk (lgl, &lgl->clause, a);
+  lglpushstk (lgl, &lgl->clause, b);
+  lglpushstk (lgl, &lgl->clause, c);
+  lglpushstk (lgl, &lgl->clause, 0);
+  LOGCLS (2, lgl->clause.start, "gauss exported ternary clause");
+  lgladdcls (lgl, REDCS, 0, 0);
+  lglclnstk (&lgl->clause);
+  return 1;
+}
+
+static int lglgaussexport (LGL * lgl) {
+  int var, size, val, rhs, unit, a, b, c, exported;
+  const int * e, * p, * q;
+  for (e = lgl->gauss->xors.start; e < lgl->gauss->xors.top; e = p + 1) {
+    if (*(p = e) >= NOTALIT) continue;
+    while ((var = *p) > 1) p++;
+    rhs = *p;
+    assert (lglmtstk (&lgl->clause));
+    for (q = e; q < p; q++) {
+      var = *q;
+      val = lglval (lgl, var);
+      if (val < 0) continue;
+      if (val > 0) { rhs = !rhs; continue; }
+      lglpushstk (lgl, &lgl->clause, var);
+    }
+    size = lglcntstk (&lgl->clause);
+    if (!size && !rhs) continue;
+    if (!size && rhs) {
+      LOGEQN (1, e - lgl->gauss->xors.start, 
+              "gauss exporting inconsistent equation");
+      return 0;
+    }
+    a = (size > 0) ? lgl->clause.start[0] : 0;
+    b = (size > 1) ? lgl->clause.start[1] : 0;
+    c = (size > 2) ? lgl->clause.start[2] : 0;
+    lglclnstk (&lgl->clause);
+    if (size == 1) {
+      unit = a;
+      if (!rhs) unit = -unit;
+      LOG (1, "gauss exporting unit %d", unit);
+      lgl->stats->gauss.units++;
+      lglunit (lgl, unit);
+    } else if (size == 2) {
+      if (rhs) b = -b;
+      exported = lglgaussexp2 (lgl, -a, b);
+      exported |= lglgaussexp2 (lgl, a, -b);
+      if (exported) {
+	LOG (1, "gauss exporting equivalence %d = %d", a, b);
+	lgl->stats->gauss.equivs++;
+      }
+    } else if (size == 3 && lgl->opts->gaussexptrn.val) {
+      if (!rhs) c = -c;
+      exported = lglgaussexp3 (lgl, a, b, c);
+      exported |= lglgaussexp3 (lgl, a, -b, -c);
+      exported |= lglgaussexp3 (lgl, -a, b, -c);
+      exported |= lglgaussexp3 (lgl, -a, -b, c);
+      if (exported) {
+	LOG (1, "gauss exporting ternary equation %d + %d + %d = 1", 
+	     a, b, c);
+	lgl->stats->gauss.trneqs++;
+      }
+    }
+  }
+  return 1;
+}
+
+static void lglsetgausslim (LGL * lgl) {
+  int64_t limit, irrlim;
+  int pen, szpen;
+  limit = (lgl->opts->gaussreleff.val*lglvisearch (lgl))/1000;
+  if (limit < lgl->opts->gaussmineff.val) limit = lgl->opts->gaussmineff.val;
+  if (lgl->opts->gaussmaxeff.val >= 0 && limit > lgl->opts->gaussmaxeff.val)
+    limit = lgl->opts->gaussmaxeff.val;
+  limit >>= (pen = lgl->limits->gauss.pen + (szpen = lglszpen (lgl)));
+  irrlim = (lgl->stats->irr.clauses.cur/2) >> szpen;
+  if (lgl->opts->irrlim.val && limit < irrlim) {
+    limit = irrlim;
+    lglprt (lgl, 1,
+      "[gauss-%d] limit %lld based on %d irredundant clauses penalty %d",
+      lgl->stats->gauss.count,
+      (LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+  } else
+    lglprt (lgl, 1, "[gauss-%d] limit %lld penalty %d = %d + %d",
+      lgl->stats->gauss.count, (LGLL) limit,
+      pen, lgl->limits->gauss.pen, szpen);
+  lgl->limits->gauss.steps.extr = lgl->stats->gauss.steps.extr + limit;
+  lgl->limits->gauss.steps.elim = lgl->stats->gauss.steps.elim + limit;
+}
+
+static int lglgauss (LGL * lgl) {
+  int oldunits, oldequivs, oldtrneqs;
+  int units, equivs, trneqs;
+  int success;
+  assert (lgl->opts->gauss.val);
+  if (lgl->mt) return 0;
+  if (lgl->nvars <= 2) return 1;
+  lglstart (lgl, &lgl->times->gauss);
+  assert (!lgl->simp && !lgl->gaussing);
+  lgl->simp = lgl->gaussing = 1;
+  lgl->stats->gauss.count++;
+  lgl->stats->gauss.extracted.last = 0;
+  lgl->stats->gauss.arity.max.last = 0;
+  lglsetgausslim (lgl);
+  lglgaussinit (lgl);
+  lglgaussextract (lgl);
+  oldunits = lgl->stats->gauss.units;
+  oldequivs = lgl->stats->gauss.equivs;
+  oldtrneqs = lgl->stats->gauss.trneqs;
+  if (!lglmtstk (&lgl->gauss->xors)) {
+    lglgaussconnect (lgl);
+    lglgaussorder (lgl);
+    lglsetgausslim (lgl);
+    lglgausselim (lgl);
+    if (!lgl->mt && !lglterminate (lgl)) {
+      if (lgl->opts->verbose.val >= 3) lglgdump (lgl);
+      lglgaussdisconnect (lgl);
+      if (!lglgaussexport (lgl) || !lglbcp (lgl)) lglmt (lgl);
+      else if (lgl->limits->gauss.steps.extr > lgl->stats->gauss.steps.extr &&
+               lgl->limits->gauss.steps.elim > lgl->stats->gauss.steps.elim)
+	lglprt (lgl, 1, "[gauss-%d] fully completed", lgl->stats->gauss.count);
+    }
+  }
+  lglgaussreset (lgl);
+  units = lgl->stats->gauss.units - oldunits;
+  equivs = lgl->stats->gauss.equivs - oldequivs;
+  trneqs = lgl->stats->gauss.trneqs - oldtrneqs;
+  success = units || equivs;
+  if (!lgl->mt && success && !lglterminate (lgl) && lgl->opts->decompose.val)
+    lgldecomp (lgl);
+  if (trneqs) success = 1;
+  if (lgl->mt)
+    lglprt (lgl, 1, "[gauss-%d] proved unsatisfiability",
+      lgl->stats->gauss.count);
+  else {
+    lglprt (lgl, 1, 
+      "[gauss-%d] exported %d unary, %d binary and %d ternary equations",
+      lgl->stats->gauss.count, units, equivs, trneqs);
+  }
+  LGLUPDPEN (gauss, success);
+  lglrep (lgl, 2, 'G');
+  assert (lgl->simp && lgl->gaussing);
+  lgl->simp = lgl->gaussing = 0;
+  lglstop (lgl);
+  return !lgl->mt;
+}
+
+/*------------------------------------------------------------------------*/
+
+#define CARDLOGLEVEL 2
+
+static int lglcardsub (LGL * lgl, const int * lits, int bound) {
+  int count, size, res, minlit, minocc, nocc, lit, pos, otherbound;
+  Card * card = lgl->card;
+  const int * p, * c, * q;
+  Stk * s;
+  minocc = INT_MAX;
+  minlit = 0;
+  for (p = lits; minocc && (lit = *p); p++) {
+    lglmarkunmarked (lgl, lit);
+    s = card->occs + lit;
+    INCSTEPS (card.steps);
+    nocc = lglcntstk (s);
+    if (nocc > minocc) continue;
+    minlit = lit;
+    minocc = nocc;
+  }
+  res = 0;
+  if (minocc && minlit) {
+    size = p - lits;
+    s = card->occs + minlit;
+    for (p = s->start; p < s->top; p++) {
+      pos = *p;
+      c = card->cards.start + pos;
+      INCSTEPS (card.steps);
+      otherbound = *c;
+      if (otherbound > bound) continue;
+      count = 0;
+      INCSTEPS (card.steps);
+      for (q = c + 1; *q; q++) count++;
+      if (count < size) continue;
+      count = 0;
+      INCSTEPS (card.steps);
+      for (q = c + 1; (count < size) && (lit = *q); q++)
+	if (lglmarked (lgl, lit) > 0) count++;
+      if (count >= size) {
+	LOGCLS (CARDLOGLEVEL, lits,
+	  "subsumed cardinality constraint %d >=", bound);
+	LOGCLS (CARDLOGLEVEL, c + 1,
+	  "subsuming cardinality constraint %d >=", otherbound);
+	res = 1;
+      }
+    }
+  }
+  for (p = lits; (lit = *p); p++) lglunmark (lgl, lit);
+  return res;
+}
+
+static int lglcard1sub (LGL * lgl, const int * lits) {
+  int res, minlit, minocc, nocc, lit, count, size;
+  Card * card = lgl->card;
+  const int * p, * c, * q;
+  Stk * s;
+  minocc = INT_MAX;
+  minlit = 0;
+  for (p = lits; minocc && (lit = *p); p++) {
+    lglmarkunmarked (lgl, lit);
+    s = card->occs + lit;
+    INCSTEPS (card.steps);
+    nocc = lglcntstk (s);
+    if (nocc > minocc) continue;
+    minlit = lit;
+    minocc = nocc;
+  }
+  res = 0;
+  if (!minocc || !minlit) goto DONE;
+  size = p - lits;
+  s = card->occs + minlit;
+  count = 0;
+  for (p = s->start; !res && p < s->top; p++) {
+    c = card->atmost1.start + *p;
+    for (q = c; (lit = *q); q++)
+      if (lglmarked (lgl, lit) && ++count >= size)
+	break;
+    if (!lit) continue;
+    LOGCLS (CARDLOGLEVEL, lits,
+      "subsumed at-most-one cardinality constraint 1 >=");
+    LOGCLS (CARDLOGLEVEL, c,
+      "subsuming at-most-one cardinality constraint 1 >=");
+    res = 1;
+  }
+DONE:
+  for (p = lits; (lit = *p); p++) lglunmark (lgl, lit);
+  return res;
+}
+
+static int lglcard2sub (LGL * lgl, const int * lits, int * minlitptr) {
+  int res, minlit, minocc, nocc, lit, count, size;
+  Card * card = lgl->card;
+  const int * p, * c, * q;
+  Stk * s;
+  minocc = INT_MAX;
+  minlit = 0;
+  for (p = lits; minocc && (lit = *p); p++) {
+    lglmarkunmarked (lgl, lit);
+    s = card->occs + lit;
+    INCSTEPS (card.steps);
+    nocc = lglcntstk (s);
+    if (nocc > minocc) continue;
+    minlit = lit;
+    minocc = nocc;
+  }
+  assert (!minocc || p + 1 == card->atmost2.top);
+  res = 0;
+  if (!minocc || !minlit || *minlitptr == minlit) goto DONE;
+  *minlitptr = minlit;
+  size = p - lits;
+  s = card->occs + minlit;
+  count = 0;
+  for (p = s->start; !res && p < s->top; p++) {
+    c = card->atmost2.start + *p;
+    for (q = c; (lit = *q); q++)
+      if (lglmarked (lgl, lit) && ++count >= size)
+	break;
+    if (!lit) continue;
+    LOGCLS (CARDLOGLEVEL, lits,
+      "subsumed at-most-two cardinality constraint 2 >=");
+    LOGCLS (CARDLOGLEVEL, c,
+      "subsuming at-most-two cardinality constraint 2 >=");
+    res = 1;
+  }
+DONE:
+  for (p = lits; (lit = *p); p++) lglunmark (lgl, lit);
+  return res;
+}
+
+static int lgladdcard (LGL * lgl, 
+                       const int * lits,
+		       int bound, int * subsumed_ptr) {
+  Card * card = lgl->card;
+  const int * p;
+  int start, lit;
+#if !defined(NDEBUG) || !defined(NLGLOG)
+  int size = 0;
+  for (p = lits; *p; p++) size++;
+#endif
+  if (lglcardsub (lgl, lits, bound)) {
+    lgl->stats->card.subsumed++;
+    if (subsumed_ptr) *subsumed_ptr += 1;
+    return 0;
+  }
+  LOGCLS (CARDLOGLEVEL, lits,
+    "new %s cardinality constraint %d >=",
+    (bound + 1 < size ? "real" : "pseudo"), bound);
+  assert (bound <= size);
+  assert (size <=
+    lglfactor (lgl, lgl->stats->card.count, lgl->opts->cardmaxlen.val));
+#ifndef NDEBUG
+  for (p = lits; (lit = *p); p++) assert (!card->eliminated[abs (lit)]);
+  for (p = lits; (lit = *p); p++) assert (!card->count[abs (lit)]);
+#endif
+  assert (card);
+  start = lglcntstk (&card->cards);
+  lglpushstk (lgl, &card->cards, bound);
+  for (p = lits; (lit = *p); p++) {
+    lglpushstk (lgl, &card->cards, lit);
+    lglpushstk (lgl, card->occs + lit, start);
+  }
+  lglpushstk (lgl, &card->cards, 0);
+  return 1;
+}
+
+static void lglcardfmstep (LGL * lgl, int pivot,
+                           int cardposidx, int cardnegidx) {
+  int bn, bp, ln, lp, b, c, s, lit, idx, addcard, len, unit[2], div, elim;
+  const int cardcut = lgl->opts->cardcut.val;
+  const int * p, * q, * cn, * cp;
+  int * r, divsame, cardmaxlen;
+  Card * card = lgl->card;
+  INCSTEPS (card.steps);
+  lgl->stats->card.resolved++;
+  assert (0 <= cardposidx && cardposidx < lglcntstk (&card->cards));
+  assert (0 <= cardnegidx && cardnegidx < lglcntstk (&card->cards));
+  cp = card->cards.start + cardposidx;
+  cn = card->cards.start + cardnegidx;
+  bp = *cp++; assert (bp >= 0);
+  bn = *cn++; assert (bp >= 0);
+  LOGCLS (CARDLOGLEVEL, cp,
+    "first antecedent fourier-motzkin on %d cardinality constraint %d >=",
+    pivot, bp);
+  LOGCLS (CARDLOGLEVEL, cn,
+    "second antecedent fourier-motzkin on %d cardinality constraint %d >=",
+    -pivot, bn);
+  b = bp + bn;
+  LOG (CARDLOGLEVEL, "starting with bound %d", b);
+  assert (lglmtstk (&lgl->clause));
+  for (p = cp; (lit = *p); p++) {
+    idx = abs (lit);
+    assert (!card->count[idx]);
+    lglpushstk (lgl, &lgl->clause, idx);
+    card->count[idx] += lglsgn (lit);
+  }
+  lp = p - cp;
+  assert (bp < lp);
+  elim = 0;
+  div = 1;
+  for (q = cn; (lit = *q); q++) {
+    idx = abs (lit);
+    c = card->count[idx];
+    assert (!c || abs (c) == 1);
+    s = lglsgn (lit);
+    if (!c) lglpushstk (lgl, &lgl->clause, idx);
+    card->count[idx] += s;
+    if (c && c != s) elim++;
+    if (c == s) div = 2;
+  }
+  ln = q - cn;
+  assert (bn < ln);
+  divsame = 1;
+  for (p = lgl->clause.start; divsame && p < lgl->clause.top; p++) {
+    idx = abs (*p);
+    c = card->count[idx];
+    if (!c) continue;
+    if (c < 0) c = -c;
+    divsame = (c == div);
+  }
+#ifndef NLGLOG
+  if (lgl->opts->log.val >= CARDLOGLEVEL) {
+    int first = 1;
+    lglogstart (lgl, CARDLOGLEVEL,
+      "pseudo-boolean resolvent %d - %d >= ", b, elim);
+    for (p = lgl->clause.start; p < lgl->clause.top; p++) {
+      idx = *p;
+      assert (1 < idx), assert (idx < lgl->nvars);
+      c = card->count[idx];
+      if (!c) continue;
+      if (!first)
+	fprintf (lgl->out, " %c ", (c < 0) ? '-' : '+');
+      else if (c < 0)
+	fputs ("-", lgl->out);
+      first = 0;
+      c = abs (c);
+      assert (c > 0);
+      if (c != 1) fprintf (lgl->out, "%d*", c);
+      fprintf (lgl->out, "%d", idx);
+    }
+    if (first) fputs ("0", lgl->out);
+    lglogend (lgl);
+  }
+#endif
+  LOG (CARDLOGLEVEL,
+    "size %d cardinalty resolvent contains %d eliminated division %d %s", 
+    lglcntstk (&lgl->clause) - elim, elim, div, divsame ? "all" : "some");
+  r = lgl->clause.start;
+  for (p = r; p < lgl->clause.top; p++) {
+    idx = *p;
+    c = card->count[idx];
+    if (divsame || cardcut == 1) c /= div;
+    else if (abs (c) != 1 && cardcut == 2 && div == 2) c = 0;
+    if (!c) continue;
+    lit = (c < 0) ? -idx : idx;
+    *r++ = lit;
+  }
+  lgl->clause.top = r;
+  b -= elim;
+  assert (div == 1 || div == 2);
+  if ((divsame || cardcut == 1) && div == 2) b /= 2;
+  len = lglcntstk (&lgl->clause);
+  lglpushstk (lgl, &lgl->clause, 0);
+  addcard = 0;
+  cardmaxlen =
+    lglfactor (lgl, lgl->stats->card.count, lgl->opts->cardmaxlen.val);
+  if (!cardcut && div > 1) {
+    LOG (CARDLOGLEVEL,
+      "ignoring resolved cardinality constraint which requires cut");
+    assert (!addcard);
+  } else if (b < 0) {
+    assert (!addcard);
+    assert (!lgl->mt);
+    LOGCLS (CARDLOGLEVEL, lgl->clause.start,
+      "inconsistent cardinality constraint %d >=", b);
+    lglmt (lgl);
+  } else if (b == 0) {
+    assert (!addcard);
+    LOGCLS (CARDLOGLEVEL, lgl->clause.start,
+      "forcing cardinality constraint %d >=", b);
+    for (p = lgl->clause.start; p < lgl->clause.top - 1; p++) {
+      lit = *p;
+      assert (lit);
+      lgl->stats->card.units++;
+      lglpushstk (lgl, &lgl->card->units, -lit);
+      card->count[abs (lit)] = 0;
+      unit[0] = lit;
+      unit[1] = 0;
+      (void) lgladdcard (lgl, unit, 0, 0);
+    }
+  } else if (b >= len) {
+    LOGCLS (CARDLOGLEVEL, lgl->clause.start,
+      "trivial resolved cardinality constraint %d >=", b);
+    assert (!addcard);
+  } else if (len > cardmaxlen) {
+    LOGCLS (CARDLOGLEVEL, lgl->clause.start, 
+      "length %d exceeds limit %d of resolved cardinality constraint %d >=",
+      len, cardmaxlen, b);
+  } else {
+    addcard = 1;
+    assert (0 < b);
+    LOGCLS (CARDLOGLEVEL, lgl->clause.start,
+      "resolved cardinality constraint %d >=", b);
+    if (b == 1 && 
+        ((ln >= 3 && lp >= 3) ||
+         lglcntstk (&lgl->clause) > 
+	   lglfactor (lgl,
+	     lgl->stats->card.count, lgl->opts->cardexpam1.val))) {
+      LOGCLS (CARDLOGLEVEL, lgl->clause.start,
+        "saving to export at-most-one constraint 1 >=");
+      for (p = lgl->clause.start; p < lgl->clause.top; p++)
+	lglpushstk (lgl, &lgl->card->expam1, *p);
+    }
+  }
+  cp = card->cards.start + cardposidx + 1;
+  cn = card->cards.start + cardnegidx + 1;
+  for (p = cp; (lit = *p); p++) card->count[abs (lit)] = 0;
+  for (q = cn; (lit = *q); q++) card->count[abs (lit)] = 0;
+  if (addcard > 0)
+    (void) lgladdcard (lgl, lgl->clause.start, b, 0);
+  lglclnstk (&lgl->clause);
+  // COVER (cardcut == 2 && div == 2 && divsame);
+}
+
+static void lglrmcardexcept (LGL * lgl, int cardidx, int except) {
+  Card * card = lgl->card;
+  int * c, * p, lit;
+  assert (0 <= cardidx && cardidx < lglcntstk (&card->cards));
+  c = card->cards.start + cardidx + 1;
+  LOGCLS (CARDLOGLEVEL, c, "removing cardinality constraint %d >=", c[-1]);
+  for (p = c; (lit = *p); p++)
+    if (lit != except)
+      lglrmstk (card->occs + lit, cardidx);
+}
+
+static int lglcardocc (LGL * lgl, int a) {
+  return lglcntstk (lgl->card->occs + a);
+}
+
+static int lglcmpcard (LGL * lgl, int a, int b) {
+  int64_t s = lglcardocc (lgl, a) * (int64_t) lglcardocc (lgl, -a);
+  int64_t t = lglcardocc (lgl, b) * (int64_t) lglcardocc (lgl, -b);
+  if (s > t) return -1;
+  if (s < t) return 1;
+  return b - a;
+}
+
+#define LGLCMPCARD(A,B) lglcmpcard (lgl, *(A), *(B))
+
+static void lglcardresched (LGL * lgl) {
+  Stk * elim = &lgl->card->elim;
+  int count = lglcntstk (elim);
+  ADDSTEPS (card.steps, 4*count);
+  SORT (int, elim->start, lglcntstk (elim), LGLCMPCARD);
+  lgl->stats->card.resched++;
+}
+
+static void lglcardfmlit (LGL * lgl, int pivot) {
+  Stk * poccs = lgl->card->occs + pivot, * noccs = lgl->card->occs - pivot;
+  int pcnt = lglcntstk (poccs), ncnt = lglcntstk (noccs);
+  int count = lgl->stats->card.count;
+  const int * p, * q;
+  assert (pivot > 0);
+  assert (!lgl->card->eliminated[pivot]);
+  if (!pcnt || !ncnt) goto DONE;
+  if (pcnt > lglfactor (lgl, lgl->opts->cardocclim1.val, count)) goto DONE;
+  if (ncnt > lglfactor (lgl, lgl->opts->cardocclim1.val, count)) goto DONE;
+  if (pcnt > lglfactor (lgl, lgl->opts->cardocclim2.val, count) &&
+      ncnt > lglfactor (lgl, lgl->opts->cardocclim2.val, count)) goto DONE;
+  lgl->stats->card.eliminated++;
+  lgl->card->eliminated[pivot] = 1;
+  LOG (CARDLOGLEVEL,
+    "fourier-motzkin pivot %d with %d positive and %d negative occurrences",
+    pivot, pcnt, ncnt);
+  for (p = poccs->start; !lgl->mt && p < poccs->top; p++)
+    for (q = noccs->start; !lgl->mt && q < noccs->top; q++)
+      lglcardfmstep (lgl, pivot, *p, *q);
+DONE:
+  for (p = poccs->start; !lgl->mt && p < poccs->top; p++) {
+    lglrmcardexcept (lgl, *p, pivot);
+    INCSTEPS (card.steps);
+  }
+  for (q = noccs->start; !lgl->mt && q < noccs->top; q++) {
+    lglrmcardexcept (lgl, *q, -pivot);
+    INCSTEPS (card.steps);
+  }
+  lglrelstk (lgl, poccs);
+  lglrelstk (lgl, noccs);
+  if (!(lgl->stats->card.eliminated % lgl->opts->cardreschedint.val))
+    lglcardresched (lgl);
+}
+
+static void lglcardfm (LGL * lgl) {
+  Stk * elim;
+  lglcardresched (lgl);
+  elim = &lgl->card->elim;
+  while (!lgl->mt && 
+         !lglmtstk (elim) &&
+         !lglterminate (lgl) &&
+         lgl->limits->card.steps >= INCSTEPS (card.steps))
+    lglcardfmlit (lgl, lglpopstk (elim));
+}
+
+static int64_t lglsetcardlim (LGL * lgl) {
+  int64_t limit, irrlim;
+  int pen, szpen;
+  limit = (lgl->opts->cardreleff.val*lglvisearch (lgl))/1000;
+  if (limit < lgl->opts->cardmineff.val) limit = lgl->opts->cardmineff.val;
+  if (lgl->opts->cardmaxeff.val >= 0 && limit > lgl->opts->cardmaxeff.val)
+    limit = lgl->opts->cardmaxeff.val;
+  limit >>= (pen = lgl->limits->card.pen + (szpen = lglszpen (lgl)));
+  irrlim = (lgl->stats->irr.clauses.cur/4) >> szpen;
+  if (lgl->opts->irrlim.val && limit < irrlim) {
+    limit = irrlim;
+    lglprt (lgl, 1,
+      "[card-%d] limit %lld based on %d irredundant clauses penalty %d",
+      lgl->stats->card.count,
+      (LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+  } else
+    lglprt (lgl, 1, "[card-%d] limit %lld penalty %d = %d + %d",
+      lgl->stats->card.count, (LGLL) limit,
+      pen, lgl->limits->card.pen, szpen);
+  lgl->limits->card.steps = lgl->stats->card.steps + limit;
+  return limit;
+}
+
+static void lglsetcardlimagain (LGL * lgl, int64_t limit) {
+  lglprt (lgl, 1,
+    "[card-%d] using previous limit %lld for elimination",
+    lgl->stats->card.count, (LGLL) limit, lgl->stats->irr.clauses.cur);
+  lgl->limits->card.steps = lgl->stats->card.steps + limit;
+}
+
+static int lglcard1extractlit (LGL * lgl, int lit) {
+  const int ignused = lgl->opts->cardignused.val;
+  int blit, tag, other, other2, i, j, cntother;
+  int start, size, trivial, subsumed;
+  const int * p, * w, * eow;
+  Card * card;
+  HTS * hts;
+  lgl->stats->card.found.am1.last.cnt = 0;
+  lgl->stats->card.found.am1.last.max = 0;
+  if (lglterminate (lgl)) return 0;
+  if (lgl->limits->card.steps < INCSTEPS (card.steps)) return 0;
+  card = lgl->card;
+  if (ignused && card->lit2used[lit]) return 1;
+  start = lglcntstk (&card->atmost1);
+  LOG (CARDLOGLEVEL + 1,
+    "starting at-most-one clique[%d] for %d",
+    start, lit);
+  lglpushstk (lgl, &card->atmost1, lit);
+  card->marked[lit] = 1;
+  hts = lglhts (lgl, -lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  INCSTEPS (card.steps);
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag != BINCS) continue;
+    other = -(blit >> RMSHFT);
+    if (ignused && card->lit2used[other]) continue;
+    for (i = start + 1; i < lglcntstk (&card->atmost1); i++) {
+      other2 = lglpeek (&card->atmost1, i);
+      if (!lglhasbin (lgl, -other, -other2)) break;
+    }
+    if (i < lglcntstk (&card->atmost1)) continue;
+    card->marked[other] = 1;
+    assert (i == lglcntstk (&card->atmost1));
+    lglpushstk (lgl, &card->atmost1, other);
+    LOG (CARDLOGLEVEL + 1,
+       "adding %d to at-most-one clique[%d] for %d", other, start, lit);
+    cntother = lglhts (lgl, -other)->count;
+    for (j = start + 1; j < i; j++) {
+      int tmp = lglpeek (&card->atmost1, j);
+      int cntmp = lglhts (lgl, -tmp)->count;
+      if (cntmp > cntother) break;
+    }
+    if (j < i) {
+      int k;
+      for (k = i; k > j; k--)
+	card->atmost1.start[k] = card->atmost1.start[k - 1];
+      card->atmost1.start[j] = other;
+    }
+#ifndef NDEBUG
+    for (j = start + 1; j + 1 < i; j++) 
+      assert (lglhts (lgl, -lglpeek (&card->atmost1, j))->count <=
+              lglhts (lgl, -lglpeek (&card->atmost1, j+1))->count);
+#endif
+  }
+  size = lglcntstk (&card->atmost1) - start;
+  trivial = (size <= 2);
+  if (!ignused) {
+    lglpushstk (lgl, &card->atmost1, 0);
+    subsumed = lglcard1sub (lgl, card->atmost1.start + start);
+    lglpopstk (&card->atmost1);
+  } else subsumed = 0;
+  for (p = card->atmost1.start + start; p < card->atmost1.top; p++) {
+    other = *p;
+    assert (card->marked[other]);
+    card->marked[other] = 0;
+    if (!trivial && !subsumed) card->lit2used[other] = 1;
+  }
+  if (trivial || subsumed) {
+    LOG (CARDLOGLEVEL + 1,
+      "resetting at-most-one clique[%d] for %d of trivial size %d",
+      start, lit, size);
+    lglrststk (&card->atmost1, start);
+  } else {
+#ifndef NLGLOG
+    if (lgl->opts->log.val >= CARDLOGLEVEL) {
+      lglogstart (lgl, CARDLOGLEVEL,
+	"non trivial size %d at-most-one constraint 1 >= ", size);
+      for (i = start; i < start + size; i++) {
+	if (i > start) fputs (" + ", lgl->out);
+	fprintf (lgl->out, "%d", lglpeek (&card->atmost1, i));
+      }
+      lglogend (lgl);
+    }
+#endif
+    if (!ignused) {
+      for (i = start; i < start + size; i++) {
+	other = lglpeek (&card->atmost1, i);
+	lglpushstk (lgl, &card->occs[other], start);
+      }
+    }
+    lglpushstk (lgl, &card->atmost1, 0);
+    lgl->stats->card.found.am1.total.sum += size;
+    lgl->stats->card.found.am1.total.cnt++;
+    lgl->stats->card.found.am1.last.cnt++;
+    if (lgl->stats->card.found.am1.total.max < size)
+      lgl->stats->card.found.am1.total.max = size;
+    if (lgl->stats->card.found.am1.last.max < size)
+      lgl->stats->card.found.am1.last.max = size;
+  }
+  return 1;
+}
+
+static void lglcardreloccs (LGL * lgl) {
+  Card * card = lgl->card;
+  int sign, idx, lit;
+  assert (card), assert (!lgl->nvars || card->occs);
+  for (sign = -1; sign <= 1; sign += 2)
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      lit = sign * idx;
+      lglrelstk (lgl, &card->occs[lit]);
+    }
+  card->occs -= lgl->nvars;
+  DEL (card->occs, 2*lgl->nvars);
+}
+
+static int lglcard1extract (LGL * lgl) {
+  struct { int cnt; int64_t sum; } before, after, delta;
+  const int ignused = lgl->opts->cardignused.val;
+  Card * card = lgl->card;
+
+  lglpushstk (lgl, &card->atmost1, 0);
+
+  NEW (card->lit2used, 2*lgl->nvars);
+  card->lit2used += lgl->nvars;
+  NEW (card->marked, 2*lgl->nvars);
+  card->marked += lgl->nvars;
+  if (!ignused) {
+    NEW (card->occs, 2*lgl->nvars);
+    card->occs += lgl->nvars;
+  }
+
+  before.cnt = lgl->stats->card.found.am1.total.cnt;
+  before.sum = lgl->stats->card.found.am1.total.sum;
+
+  lglrandlitrav (lgl, lglcard1extractlit);
+
+  after.cnt = lgl->stats->card.found.am1.total.cnt;
+  after.sum = lgl->stats->card.found.am1.total.sum;
+  assert (after.cnt >= before.cnt);
+  assert (after.sum >= before.sum);
+  delta.cnt = after.cnt - before.cnt;
+  delta.sum = after.sum - before.sum;
+
+  card->lit2used -= lgl->nvars;
+  DEL (card->lit2used, 2*lgl->nvars);
+  card->marked -= lgl->nvars;
+  DEL (card->marked, 2*lgl->nvars);
+  if (!ignused) lglcardreloccs (lgl);
+
+  if (delta.cnt)
+    lglprt (lgl, 1, 
+      "[card-%d] found %d at-most-one constraints of average size %.1f",
+      lgl->stats->card.count, delta.cnt, lglavg (delta.sum, delta.cnt));
+  else
+    lglprt (lgl, 1,
+      "[card-%d] no at-most-one constraint found",
+      lgl->stats->card.count);
+
+  return delta.cnt;
+}
+
+static int lglcard2extractlit (LGL * lgl, int lit) {
+  int blit, tag, other, other2, other3, i, j, k, res = 1;
+  const int ignused = lgl->opts->cardignused.val;
+  int start, size, minlit;
+  const int * p, * w, * eow;
+  int * q;
+  Card * card;
+  HTS * hts;
+  lgl->stats->card.found.am2.last.cnt = 0;
+  lgl->stats->card.found.am2.last.max = 0;
+  if (lglterminate (lgl)) return 0;
+  if (lgl->limits->card.steps < INCSTEPS (card.steps)) return 0;
+  card = lgl->card;
+  if (ignused && card->lit2used[lit]) return 1;
+
+  start = lglcntstk (&card->atmost2);
+  LOG (CARDLOGLEVEL + 1, "starting at-most-two clique[%d] for %d", start, lit);
+  assert (!card->lit2count[lit]);
+  hts = lglhts (lgl, -lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  INCSTEPS (card.steps);
+  for (p = w; p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag != TRNCS) continue;
+    other = -(blit >> RMSHFT);
+    other2 = -*p;
+    if (card->lit2count[-other] || card->lit2count[-other2]) continue;
+    if (!card->lit2count[lit]++) lglpushstk (lgl, &card->atmost2, lit);
+    if (!card->lit2count[other]++) lglpushstk (lgl, &card->atmost2, other);
+    if (!card->lit2count[other2]++) lglpushstk (lgl, &card->atmost2, other2);
+  }
+  q = card->atmost2.start + start;
+  for (p = q; p < card->atmost2.top; p++) {
+    if (card->lit2count [other =*p] > 1) *q++ = other;
+    else card->lit2count[other] = 0;
+  }
+  card->atmost2.top = q;
+  size = lglcntstk (&card->atmost2) - start;
+  if (size < 4) {
+    LOG (CARDLOGLEVEL + 1,
+      "less than 4 literals occuring 2 times in ternary clauses with %d",
+       -lit);
+FAILED:
+    while (lglcntstk (&card->atmost2) > start) {
+      int lit = lglpopstk (&card->atmost2);
+      assert (card->lit2count[lit] > 0);
+      card->lit2count[lit] = 0;
+    }
+    return res;
+  }
+  minlit = 0;
+RESTART:
+  if (!ignused) {
+    int subsumed;
+    lglpushstk (lgl, &card->atmost2, 0);
+    subsumed = lglcard2sub (lgl, card->atmost2.start + start, &minlit);
+    lglpopstk (&card->atmost2);
+    if (subsumed) goto FAILED;
+  }
+  LOG (CARDLOGLEVEL + 1, "trying to connect %d literals", size-1);
+  for (i = 0; i < size-2; i++) {
+    other = -lglpeek (&card->atmost2, start + i);
+    for (j = i+1; j < size-1; j++) {
+      other2 = -lglpeek (&card->atmost2, start + j);
+      for (k = j+1; k < size; k++) {
+	if (lgl->limits->card.steps < INCSTEPS (card.steps)) {
+	  LOG (CARDLOGLEVEL + 1, "cardinality extraction step limit hit");
+	  res = 0;
+	  goto FAILED;
+	}
+	other3 = -lglpeek (&card->atmost2, start + k);
+	if (!lglhastrn (lgl, other, other2, other3)) {
+	  LOG (CARDLOGLEVEL + 1,
+	    "ternary clause %d %d %d missing", other, other2, other3);
+	  assert (size >= 4);
+	  if (size == 4) goto FAILED;
+	  int l, tmp;
+	  if (k > j + 1) l = k;
+	  else {
+	    int occ2 = card->lit2count[-other2];
+	    int occ3 = card->lit2count[-other3];
+	    if (occ2 > occ3) l = k;
+	    else if (occ2 < occ3) l = j;
+	    else {
+	      occ2 = lglhts (lgl, other2)->count;
+	      occ3 = lglhts (lgl, other3)->count;
+	      if (occ2 > occ3) l = k;
+	      else if (occ2 < occ3) l = j;
+	      else l = (lglrand (lgl) & 1) ? j : k;
+	    }
+	  }
+	  tmp = lglpeek (&card->atmost2, start + l);
+	  assert (abs (tmp) != abs (lit));
+	  assert (card->lit2count[tmp] > 0);
+	  card->lit2count[tmp] = 0;
+	  while (l + 1 < size) {
+	    tmp = lglpeek (&card->atmost2, start + l + 1);
+	    assert (abs (tmp) != abs (lit));
+	    lglpoke (&card->atmost2, start + l++, tmp);
+	  }
+	  assert (l == size - 1);
+	  card->atmost2.top--;
+	  size--;
+	  assert (size >= 4);
+	  assert (card->atmost2.start + start + size == card->atmost2.top);
+	  goto RESTART;
+	}
+      }
+    }
+  }
+#ifndef NLGLOG
+  if (lgl->opts->log.val >= CARDLOGLEVEL) {
+    lglogstart (lgl, CARDLOGLEVEL,
+      "non trivial size %d at-most-two constraint 2 >= ", size);
+    for (i = start; i < start + size; i++) {
+      if (i > start) fputs (" + ", lgl->out);
+      fprintf (lgl->out, "%d", lglpeek (&card->atmost2, i));
+    }
+    lglogend (lgl);
+  }
+#endif
+  for (i = start; i < start + size; i++) {
+    other = lglpeek (&card->atmost2, i);
+    card->lit2count[other] = 0;
+    card->lit2used[other] = 1;
+    if (!ignused) lglpushstk (lgl, &card->occs[other], start);
+  }
+  lglpushstk (lgl, &card->atmost2, 0);
+  lgl->stats->card.found.am2.total.sum += size;
+  lgl->stats->card.found.am2.total.cnt++;
+  lgl->stats->card.found.am2.last.cnt++;
+  if (lgl->stats->card.found.am2.total.max < size)
+    lgl->stats->card.found.am2.total.max = size;
+  if (lgl->stats->card.found.am2.last.max < size)
+    lgl->stats->card.found.am2.last.max = size;
+  return res;
+}
+
+static int lglcard2extract (LGL * lgl) {
+  struct { int cnt; int64_t sum; } before, after, delta;
+  const int ignused = lgl->opts->cardignused.val;
+  Card * card = lgl->card;
+
+  lglpushstk (lgl, &card->atmost2, 0);
+  NEW (card->lit2used, 2*lgl->nvars);
+  card->lit2used += lgl->nvars;
+  NEW (card->lit2count, 2*lgl->nvars);
+  card->lit2count += lgl->nvars;
+  if (!ignused) {
+    NEW (card->occs, 2*lgl->nvars);
+    card->occs += lgl->nvars;
+  }
+
+  before.cnt = lgl->stats->card.found.am2.total.cnt;
+  before.sum = lgl->stats->card.found.am2.total.sum;
+
+  lglrandlitrav (lgl, lglcard2extractlit);
+
+  after.cnt = lgl->stats->card.found.am2.total.cnt;
+  after.sum = lgl->stats->card.found.am2.total.sum;
+  assert (after.cnt >= before.cnt);
+  assert (after.sum >= before.sum);
+  delta.cnt = after.cnt - before.cnt;
+  delta.sum = after.sum - before.sum;
+
+  card->lit2used -= lgl->nvars;
+  DEL (card->lit2used, 2*lgl->nvars);
+  card->lit2count -= lgl->nvars;
+  DEL (card->lit2count, 2*lgl->nvars);
+  if (!ignused) lglcardreloccs (lgl);
+
+  if (delta.cnt)
+    lglprt (lgl, 1, 
+      "[card-%d] found %d at-most-two constraints of average size %.1f",
+      lgl->stats->card.count, delta.cnt, lglavg (delta.sum, delta.cnt));
+  else
+    lglprt (lgl, 1,
+      "[card-%d] no at-most-two constraint found",
+      lgl->stats->card.count);
+
+  return delta.cnt;
+}
+
+static int lglcarduseclswithlit (LGL * lgl, int lit) {
+  int pos = !lglmtstk (lgl->card->occs + lit);
+  int neg = !lglmtstk (lgl->card->occs - lit);
+  int level = lgl->opts->carduse.val;
+  switch (level) {
+    case 0: return 0;
+    case 1: return pos && !neg;
+    case 2: return pos;
+    default: assert (level == 3); return pos || neg;
+  }
+}
+
+static int lglcardelim (LGL * lgl, int count) {
+  int blit, tag, other, other2, bound, used;
+  int idx, sign, lit, start, len, res, glue;
+  const int * p, * w, * eow, * c, * q;
+  int cardmaxlen, subsumed = 0;
+  Card * card = lgl->card;
+  int clause[4];
+  HTS * hts;
+  Stk * s;
+
+  NEW (card->occs, 2*lgl->nvars);
+  NEW (card->eliminated, lgl->nvars);
+  NEW (card->count, lgl->nvars);
+  card->occs += lgl->nvars;
+  used = 0;
+  cardmaxlen =
+    lglfactor (lgl, lgl->stats->card.count, lgl->opts->cardmaxlen.val);
+  for (start = 1; start < lglcntstk (&card->atmost1); start++) {
+    for (len = 0; lglpeek (&card->atmost1, start + len); len++)
+      ;
+    if (len >= lgl->opts->cardminlen.val &&
+	len <= cardmaxlen &&
+        lgladdcard (lgl, card->atmost1.start + start, 1, &subsumed)) {
+      lgl->stats->card.used.am1.sum += len;
+      lgl->stats->card.used.am1.cnt++;
+      used++;
+    }
+    start += len;
+  }
+  for (start = 1; start < lglcntstk (&card->atmost2); start++) {
+    for (len = 0; lglpeek (&card->atmost2, start + len); len++)
+      ;
+    if (len >= lgl->opts->cardminlen.val &&
+	len <= cardmaxlen &&
+        lgladdcard (lgl, card->atmost2.start + start, 2, &subsumed)) {
+      lgl->stats->card.used.am2.sum += len;
+      lgl->stats->card.used.am2.cnt++;
+      used++;
+    }
+    start += len;
+  }
+  if (used) {
+    lglprt (lgl, 1,
+      "[card-%d] using %d out of %d constraints (%.0f%%), %d subsumed",
+      lgl->stats->card.count, used, count, lglpcnt (used, count), subsumed);
+  } else {
+    lglprt (lgl, 1,
+      "[card-%d] no constraint out of %d used (%d subsumed)",
+      lgl->stats->card.count, count, subsumed);
+    goto SKIP;
+  }
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (lglmtstk (card->occs + idx) &&
+	lglmtstk (card->occs - idx)) continue;
+    LOG (CARDLOGLEVEL, "variable %d scheduled for elimination", idx);
+    lglpushstk (lgl, &card->elim, idx);
+  }
+  if (!lgl->opts->carduse.val) goto DO_NOT_USE_CLAUSES;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (lglterminate (lgl) ||
+	lgl->limits->card.steps < INCSTEPS (card.steps)) goto SKIP;
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      if (!lglcarduseclswithlit (lgl, lit)) continue;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == BINCS) {
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  clause[0] = -lit, clause[1] = -other, clause[2] = 0;
+	  (void) lgladdcard (lgl, clause, 1, 0);
+	} else if (tag == TRNCS) {
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	  clause[0] = -lit, clause[1] = -other,
+	  clause[2] = -other2, clause[3] = 0;
+	  (void) lgladdcard (lgl, clause, 2, 0);
+	} else assert (tag == LRGCS);
+      }
+    }
+  }
+  for (glue = -1; glue <= lgl->opts->cardglue.val; glue++) {
+    s = (glue < 0) ? &lgl->irr : lgl->red + glue;
+    for (c = s->start; c < s->top; c = p + 1) {
+      if (*(p = c) >= NOTALIT) continue;
+      for (p = c; *p; p++)
+	;
+      for (q = c; (lit = *q); q++)
+	if (lglcarduseclswithlit (lgl, lit)) break;
+      if (!lit) continue;
+      len = p - c;
+      if (len > cardmaxlen) continue;
+      assert (len >= 4);
+      bound = len - 1;
+      assert (lglmtstk (&lgl->clause));
+      for (q = c; (lit = *q); q++)
+	lglpushstk (lgl, &lgl->clause, -lit);
+      lglpushstk (lgl, &lgl->clause, 0);
+      (void) lgladdcard (lgl, lgl->clause.start, bound, 0);
+      lglclnstk (&lgl->clause);
+      if (lglterminate (lgl) ||
+	  lgl->limits->card.steps < INCSTEPS (card.steps)) goto SKIP;
+    }
+  }
+DO_NOT_USE_CLAUSES:
+  lglcardfm (lgl);
+SKIP:
+  lglcardreloccs (lgl);
+  DEL (card->count, lgl->nvars);
+  lglrelstk (lgl, &card->cards);
+  lglrelstk (lgl, &card->elim);
+  DEL (card->eliminated, lgl->nvars);
+  if (lgl->mt)
+    lglprt (lgl, 1,
+      "[card-%d] produced empty clause",
+      lgl->stats->card.count);
+  else if (!lglmtstk (&card->units)) {
+    lglprt (lgl, 1,
+       "[card-%d] found %d units",
+       lgl->stats->card.count, lglcntstk (&card->units));
+    while (!lgl->mt && !lglmtstk (&card->units)) {
+      lit = lglpopstk (&card->units);
+      if (lglval (lgl, lit) > 0) continue;
+      if (lglval (lgl, lit) < 0) {
+	lglprt (lgl, 1,
+	  "[card-%d] found inconsistent unit",
+	  lgl->stats->card.count);
+	lglmt (lgl);
+      } else {
+	lglunit (lgl, lit);
+	if (!lglbcp (lgl)) {
+	  lglprt (lgl, 1,
+	    "[card-%d] inconsistent unit propagation",
+	    lgl->stats->card.count);
+	  assert (!lgl->mt);
+	  lglmt (lgl);
+	}
+      }
+    }
+  }
+  res = lglcntstk (&card->units);
+  lglrelstk (lgl, &card->units);
+  if (!lgl->mt) {
+    if (res)
+      lglprt (lgl, 1, 
+	"[card-%d] found %d units", lgl->stats->card.count, res);
+    else
+      lglprt (lgl, 1, "[card-%d] no units found", lgl->stats->card.count);
+
+    if (!lglmtstk (&card->expam1)) {
+      int generated = 0, exported = 0, genused = 0;
+      for (c = card->expam1.start; c < card->expam1.top; c = p + 1) {
+	int a, usefull = 0;
+	generated++;
+	for (p = c; (a = *p); p++) if (lglval (lgl, a)) break;
+	if (a) {
+	  while (*++p)
+	    ;
+	  continue;
+	}
+	for (p = c; (a = -*p); p++) {
+	  int b;
+	  for (q = p + 1; (b = -*q); q++)
+	    if (!lglhasbin (lgl, a, b)) {
+	      LOG (CARDLOGLEVEL,
+	        "exporting at-most-one constraint binary clause %d %d",
+		a, b);
+	      assert (lglmtstk (&lgl->clause));
+	      lglpushstk (lgl, &lgl->clause, a);
+	      lglpushstk (lgl, &lgl->clause, b);
+	      lglpushstk (lgl, &lgl->clause, 0);
+	      lgladdcls (lgl, REDCS, 0, 1);
+	      lglclnstk (&lgl->clause);
+	      lgl->stats->card.expam1++;
+	      exported++;
+	      usefull = 1;
+	    }
+	}
+	if (usefull) genused++;
+      }
+      lglprt (lgl, 1,
+        "[card-%d] generated %d at-most-one constraints, %d used %.0f%%",
+        lgl->stats->card.count,
+	generated, genused, lglpcnt (genused, generated));
+      lglprt (lgl, 1,
+	"[card-%d] exported %d binary clauses, %.1f per/constraint",
+        lgl->stats->card.count, exported, lglavg (exported, genused));
+    } else
+      lglprt (lgl, 1, 
+        "[card-%d] no at-most-one constraints generated",
+        lgl->stats->card.count);
+  }
+  lglrelstk (lgl, &card->expam1);
+  return res;
+}
+
+static int lglcard (LGL * lgl) {
+  int success, count;
+  int64_t limit;
+  assert (!lgl->mt);
+  lglstart (lgl, &lgl->times->card);
+  lgl->stats->card.count++;
+  if (lgl->level) lglbacktrack (lgl, 0);
+  limit = lglsetcardlim (lgl);
+  assert (!lgl->card);
+  NEW (lgl->card, 1);
+  count = lglcard1extract (lgl) + lglcard2extract (lgl);
+  if (!lglterminate (lgl) && count) {
+    lglsetcardlimagain (lgl, limit);
+    success = lglcardelim (lgl, count);
+  } else success = 0;
+  lglrelstk (lgl, &lgl->card->atmost1);
+  lglrelstk (lgl, &lgl->card->atmost2);
+  DEL (lgl->card, 1);
+  LGLUPDPEN (card, success);
+  lglstop (lgl);
+  return !lgl->mt;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglbcaoccmin (LGL * lgl, int lit) {
+  int * p, * w, * eow;
+  int res, blit, red, tag;
+  HTS * hts;
+  hts = lglhts (lgl, lit);
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  res = 0;
+  for (p = w; res <= 3 && p < eow; p++) {
+    blit = *p;
+    tag = blit & MASKCS;
+    red = blit & REDCS;
+    if (tag == TRNCS || tag == LRGCS) p++;
+    if (tag == LRGCS) continue;
+    if (!red) res++;
+  }
+  return res;
+}
+
+static int lglbcaskiplit (LGL * lgl, int lit) {
+  int pocc, nocc;
+  if (lgl->opts->bca.val >= 2) return 0;
+  pocc = lglbcaoccmin (lgl, lit);
+  if (pocc <= 1) return 1;
+  nocc = lglbcaoccmin (lgl, -lit);
+  if (nocc <= 1) return 1;
+  return pocc == 2 && nocc == 2;
+}
+
+static void lglbcalitaux (LGL * lgl, int lit) {
+  int first, blit, tag, red, lidx, other, tmp, found, other2, found2, * r;
+  const int * w, * p, * eow, * c, * q;
+  Stk * covered = &lgl->bca->covered;
+  int round;
+  HTS * hts;
+  assert (lglisfree (lgl, lit));
+  assert (lgl->opts->bca.val);
+  assert (!(lglavar (lgl, lit)->inred & (1 << (lit < 0))));
+  hts = lglhts (lgl, lit);
+  if (!hts->count) return;
+  if (lglbcaskiplit (lgl, lit)) { lgl->stats->bca.skipped++; return; }
+  assert (lglmtstk (covered));
+  first = 1;
+  w = lglhts2wchs (lgl, hts);
+  eow = w + hts->count;
+  for (round = 0; round < 2; round++) {
+    for (p = w; (first || !lglmtstk (covered)) && p < eow; p++) {
+      blit = *p;
+      tag = blit & MASKCS;
+      red = blit & REDCS;
+      if (tag == TRNCS || tag == LRGCS) p++;
+      assert (!red || tag != LRGCS);
+      if (tag == LRGCS) continue;
+      if (round != (tag == OCCS)) continue;
+      INCSTEPS (bca.steps);
+      if (tag == BINCS) {
+	assert (!round);
+	other = blit >> RMSHFT;
+	if (lglval (lgl, other) > 0) continue;
+	assert (!lglval (lgl, other));
+	found = first;
+	while (!lglmtstk (covered))
+	  if (other == lglpopstk (covered)) found = 1;
+	if (found) lglpushstk (lgl, covered, other);
+      } else if (tag == TRNCS) {
+	assert (!round);
+	other = blit >> RMSHFT;
+	if (lglval (lgl, other) > 0) continue;
+	other2 = *p;
+	if (lglval (lgl, other2) > 0) continue;
+	found = found2 = first;
+	while (!lglmtstk (covered))
+	  if (other == (tmp = lglpopstk (covered))) found = 1;
+	  else if (tmp == other2) found2 = 1;
+	if (found && !lglval (lgl, other)) lglpushstk (lgl, covered, other);
+	if (found2 && !lglval (lgl, other2)) lglpushstk (lgl, covered, other2);
+      } else {
+	assert (!red);
+	assert (round);
+	assert (tag == OCCS);
+	lidx = blit >> RMSHFT;
+	c = lglidx2lits (lgl, red, lidx);
+	INCSTEPS (bca.steps);
+	for (q = c; (other = *q); q++)
+	  if (other != lit && lglval (lgl, other) > 0) break;
+	if (other) continue;
+	if (first) {
+	  for (q = c; (other = *q); q++)
+	    if (other != lit && !lglval (lgl, other))
+	      lglpushstk (lgl, covered, other);
+	} else {
+	  for (q = covered->start; q < covered->top; q++)
+	    assert (!lglsignedmarked (lgl, *q)), lglsignedmark (lgl, *q);
+	  for (q = c; (other = *q); q++)
+	    if (other != lit && lglsignedmarked (lgl, other))
+	      assert (!lglval (lgl, other)), lglsignedunmark (lgl, other);
+	  r = covered->start;
+	  for (q = r; q < covered->top; q++)
+	    if (lglsignedmarked (lgl, (other = *q)))
+	      lglsignedunmark (lgl, other);
+	    else *r++ = other;
+	  covered->top = r;
+	}
+      }
+      first = 0;
+    }
+  }
+}
+
+static int lglbcalit (LGL * lgl, int lit) {
+  unsigned bit;
+  AVar * av;
+  int other;
+  if (lgl->limits->bca.steps < lgl->stats->bca.steps) return 0;
+  if (lgl->limits->bca.added < lgl->stats->bca.added) return 0;
+  if (lglterminate (lgl)) return 0;
+  if (lglifrozen (lgl, lit)) return 1;
+  if (!lglisfree (lgl, lit)) return 1;
+  av = lglavar (lgl, lit);
+  bit = (1 << (lit < 0));
+  if (av->inred & bit) return 1;
+  lglbcalitaux (lgl, lit);
+  while (!lglmtstk (&lgl->bca->covered)) {
+    INCSTEPS (bca.steps);
+    other = lglpopstk (&lgl->bca->covered);
+    if (lglhasbin (lgl, -lit, -other)) continue;
+    LOG (2, "adding binary blocked clause %d %d", -lit, -other);
+    assert (lglmtstk (&lgl->clause));
+    lglpushstk (lgl, &lgl->clause, -lit);
+    lglpushstk (lgl, &lgl->clause, -other);
+    lglpushstk (lgl, &lgl->clause, 0);
+    lgladdcls (lgl, REDCS, 0, 1);
+    lglclnstk (&lgl->clause);
+    lgl->stats->bca.added++;
+  }
+  return 1;
+}
+
+static void lglupdbcadel (LGL * lgl, int success) {
+  if (success && lgl->limits->bca.del.cur)
+    lgl->limits->bca.del.cur /= 2;
+  if (!success && lgl->limits->bca.del.cur < lgl->opts->delmax.val)
+    lgl->limits->bca.del.cur++;
+  lgl->limits->bca.del.rem = lgl->limits->bca.del.cur;
+}
+
+static void lglbca (LGL * lgl) {
+  int oldadded = lgl->stats->bca.added, added, limadded;
+  int idx, glue, other, inred, usable, scale;
+  const int * c, * p;
+  int64_t oldsteps, lim64;
+  unsigned bit;
+  AVar * av;
+
+  lglstart (lgl, &lgl->times->bca);
+
+  NEW (lgl->bca, 1);
+
+  lgl->stats->bca.count++;
+  oldsteps = lgl->stats->bca.steps;
+  lgl->limits->bca.steps = oldsteps + lgl->opts->bcamaxeff.val;
+
+  limadded = lgl->stats->irr.clauses.cur;
+  scale = lgl->opts->bcaddlimldscale.val;
+  if (scale < 0) limadded >>= -scale;
+  else if ((INT_MAX >> scale) < limadded) limadded = INT_MAX;
+  else limadded <<=scale;
+  lim64 = lgl->stats->bca.added/2;
+  lim64 += limadded/2 + 500;
+  if (lim64 > (int64_t) INT_MAX) lim64 = INT_MAX;
+  lgl->limits->bca.added = lim64;
+
+  lglprt (lgl, 1,
+    "[bca-%d] limit of %d steps and %d added (scaled %d)",
+    lgl->stats->bca.count, lgl->opts->bcamaxeff.val,
+    lgl->limits->bca.added, scale);
+
+  assert (!lgl->bcaing);
+  lgl->bcaing = 1;
+
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  lglgc (lgl);
+  assert (lgl->frozen);
+
+  for (idx = 2; idx < lgl->nvars; idx++) lglavar (lgl, idx)->inred = 0;
+  inred = 0;
+  for (glue = 0; glue <= MAXGLUE; glue++) {
+    Stk * s = lgl->red + glue;
+    for (c = s->start; c < s->top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      INCSTEPS (bca.steps);
+      while ((other = *p)) {
+	p++;
+	bit = (1 << (other < 0));
+	av = lglavar (lgl, other);
+	if (av->inred & bit) continue;
+	av->inred |= bit;
+	inred++;
+      }
+    }
+  }
+  lglprt (lgl, 2, 
+    "[bca-%d] %d out of %d literals in large redundant clauses %.0f%%",
+    lgl->stats->bca.count,
+    inred, 2*(lgl->nvars-1), lglpcnt (inred, 2*(lgl->nvars-1)));
+
+  usable = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (lglifrozen (lgl, idx)) continue;
+    if (!lglisfree (lgl, idx)) continue;
+    av = lglavar (lgl, idx);
+    for (bit = 1; bit <= 2; bit++) if (!(av->inred & bit)) usable++;
+  }
+  lglprt (lgl, 1, 
+    "[bca-%d] %d out of %d literals actually usable %.0f%%",
+    lgl->stats->bca.count,
+    usable, 2*(lgl->nvars-1), lglpcnt (usable, 2*(lgl->nvars-1)));
+
+  if (usable < lgl->opts->bcaminuse.val) {
+    lglprt (lgl, 1, "[bca-%d] not enough literals usable",
+            lgl->stats->bca.count);
+    goto DONE;
+  }
+
+  lgldense (lgl, 0);
+  lglrandlitrav (lgl, lglbcalit);
+  lglsparse (lgl);
+  lglgc (lgl);
+
+DONE:
+  added = lgl->stats->bca.added - oldadded;
+  lglprt (lgl, 1, "[bca-%d] added %d blocked clauses in %lld steps",
+          lgl->stats->bca.count, added, 
+	  (LGLL) lgl->stats->bca.steps - oldsteps);
+  assert (lgl->bcaing);
+  lgl->bcaing = 0;
+  lglupdbcadel (lgl, added);
+  lglrelstk (lgl, &lgl->bca->covered);
+  DEL (lgl->bca, 1);
+  lglstop (lgl);
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lgltreducing (LGL * lgl) {
+  if (lgldelaying (lgl, "transred", &lgl->limits->trd.del.rem)) return 0;
+  if (lglwaiting (lgl, "transred", lgl->opts->transredwait.val)) return 0;
+  return lgl->opts->transred.val;
+}
+
+static int lglunhiding (LGL * lgl) { 
+  if (lgldelaying (lgl, "unhide", &lgl->limits->unhd.del.rem)) return 0;
+  if (lglwaiting (lgl, "unhide", lgl->opts->unhidewait.val)) return 0;
+  return lgl->opts->unhide.val;
+}
+
+static int lgldecomposing (LGL * lgl) { return lgl->opts->decompose.val; }
+
+static int lglblocking (LGL * lgl) {
+  if (!lgl->opts->block.val) return 0;
+  if (lgl->allfrozen) return 0;
+  if (lgldelaying (lgl, "block", &lgl->limits->blk.del.rem)) return 0;
+  if (lgl->opts->blockwait.val && lgl->wait &&
+      (!lgl->opts->elim.val || !lgl->elmrtc)) {
+    lglprt (lgl, 2, 
+      "[block-waiting] for bounded variable elimination to be completed");
+    return 0;
+  }
+  if (!lglsmallirr (lgl)) return 0;
+  if (lgl->nvars <= 2) return 0;
+  if (lgl->mt) return 0;
+  if (lgl->blkrem) return 1;
+  return lgl->stats->irrprgss > lgl->limits->blk.irrprgss;
+}
+
+static int lgleliminating (LGL * lgl) {
+  if (!lgl->opts->elim.val) return 0;
+  if (lgl->allfrozen) return 0;
+  if (lgldelaying (lgl, "elim", &lgl->limits->elm.del.rem)) return 0;
+  if (!lglsmallirr (lgl)) return 0;
+  if (lgl->nvars <= 2) return 0;
+  if (lgl->mt) return 0;
+  if (lgl->elmrem) return 1;
+  return lgl->stats->irrprgss > lgl->limits->elm.irrprgss;
+}
+
+static int lglbcaing (LGL * lgl) {
+  if (!lgl->opts->bca.val) return 0;
+  if (lgl->allfrozen) return 0;
+  if (lgldelaying (lgl, "bca", &lgl->limits->bca.del.rem)) return 0;
+  if (lglwaiting (lgl, "bca", lgl->opts->bcawait.val)) return 0;
+  if (!lglsmallirr (lgl)) return 0;
+  return 1;
+}
+
+static int lglreducing (LGL * lgl) {
+  int reducable;
+  if (!lgl->opts->reduce.val) return 0;
+  reducable = lgl->stats->red.lrg;
+  assert (reducable >= lgl->lrgluereasons);
+  reducable -= lgl->lrgluereasons;
+  assert (reducable >= lgl->stats->lir[0].clauses);
+  reducable -= lgl->stats->lir[0].clauses;
+  return reducable >= lgl->limits->reduce.redlarge;
+}
+
+static int lgldefragmenting (LGL * lgl) {
+  int relfree;
+  if (lgl->stats->pshwchs < lgl->limits->dfg) return 0;
+  if (!lgl->nvars) return 0;
+  relfree = (100 * lgl->wchs->free + 99) / lgl->nvars;
+  return relfree >= lgl->opts->defragfree.val;
+}
+
+static int lglforcerestart (LGL * lgl) {
+  const int64_t  percent = lgl->opts->restartforcelim.val;
+  int64_t actual, smoothed, limit;
+  int forcing;
+  assert (lgl->opts->restartcheckforced.val);
+  assert (percent);
+  switch (lgl->opts->restartforcemode.val) {
+    default:
+    case 0:
+      actual = lgl->stats->glue.fast.val;
+      smoothed = lgl->stats->avglue.val;
+      break;
+    case 1:
+      actual = lgl->stats->glue.fast.val;
+      smoothed = lgl->stats->glue.slow.val;
+      break;
+    case 2:
+      actual = lgl->stats->glue.diff.actual;
+      smoothed = lgl->stats->glue.diff.smoothed.val;
+      break;
+  }
+  assert (lglvalidint64 (smoothed));
+  limit = (smoothed < 0 ? -smoothed : smoothed);
+  assert (limit >= 0);
+  if (!lglvalidint64 (limit)) return 0;
+  limit /= 100;
+  if (INT64MAX/percent < limit) return 0;
+  limit *= percent;
+  forcing = (limit < actual);
+  LOG (2,
+    "%s glue MACD %g * %.2f = %g %s %g at %lld conflicts",
+    (forcing ? "forcing" : "not forcing"),
+    smoothed/(double)(1ll<<32),
+    lgl->opts->restartforcelim.val/100.0,
+    limit/(double)(1ll<<32),
+    forcing ? "<" : ">=",
+    actual/(double)(1ll<<32),
+    (LGLL) lgl->stats->confs);
+  return forcing;
+}
+
+static int lgldelayrestart (LGL * lgl) {
+  const int64_t   actual = ((int64_t)lgl->level) << 32;
+  const int64_t smoothed = lgl->stats->jlevel.slow.val;
+  const int64_t  percent = lgl->opts->restartdelaylim.val;
+  int64_t limit;
+  int delaying;
+  assert (lgl->opts->restartdelay.val);
+  assert (percent);
+  assert (lglvalidint64 (smoothed));
+  limit = (smoothed < 0 ? -smoothed : smoothed);
+  assert (limit >= 0);
+  if (!lglvalidint64 (limit)) return 0;
+  limit /= 100;
+  if (INT64MAX/percent < limit) return 0;
+  limit *= percent;
+  delaying = (limit > actual);
+  LOG (2,
+    "%s restart MACD %g * %.2f = %g %s %g at %lld conflicts",
+    (delaying ? "delaying" : "not delaying"),
+    smoothed/(double)(1ll<<32),
+    lgl->opts->restartdelaylim.val/100.0,
+    limit/(double)(1ll<<32),
+    delaying ? ">" : "<=",
+    actual/(double)(1ll<<32),
+    (LGLL) lgl->stats->confs);
+  return delaying;
+}
+
+static int lglrestarting (LGL * lgl) {
+  int assumptions;
+  if (lgl->stats->confs < lgl->limits->restart.confs) return 0;
+  if (!lgl->opts->restart.val) return 0;
+  if (!lgl->level) return 0;
+  if ((assumptions = lglcntstk (&lgl->assume))) {
+    if (lgl->assumed < assumptions) return 0;
+    assert (lgl->alevel <= lgl->level);
+    if (lgl->alevel == lgl->level) return 0;
+  }
+  lgl->stats->restarts.checked++;
+  lgl->limits->restart.confs = lgl->stats->confs + 1;
+  if (lgl->opts->restartfixed.val) return 1;
+  if (lgl->opts->agility.val &&
+      ((100*lgl->stats->agility) >> 32) > lgl->opts->agilitylim.val) {
+    lgl->stats->restarts.agile++;
+NORESTART:
+    lgl->stats->restarts.skipped++;
+    lglrep (lgl, 3, 'L');
+    return 0;
+  }
+  if (lgl->opts->restartdelay.val && lgldelayrestart (lgl)) {
+    lgl->stats->restarts.delayed++;
+    goto NORESTART;
+  }
+  if (lgl->opts->restartblock.val == 2 && lglblockrestart (lgl)) {
+    lgl->limits->restart.confs = lgl->stats->confs + lgl->opts->restartint.val;
+    lgl->stats->restarts.blocked++;
+    goto NORESTART;
+  }
+  if (lgl->opts->restartcheckforced.val && !lglforcerestart (lgl)) {
+    lgl->stats->restarts.notforced++;
+    goto NORESTART;
+  }
+  lgl->stats->restarts.forced++;
+#ifndef NLGLFILES
+  {
+    static FILE * restartfile = 0;
+    if (!restartfile) restartfile = fopen ("/tmp/restarts", "w");
+    fprintf (restartfile, "%lld\n", (LGLL) lgl->stats->confs);
+    fflush (restartfile);
+  }
+#endif
+  return 1;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglpruning (LGL * lgl) {
+  if (lgl->mt) return 0;
+  if (!lgl->unassigned) return 0;
+  if (!lgl->opts->prune.val) return 0;
+  if (lgl->opts->drupligcheck.val) return 0;
+  if (!lglmtstk (&lgl->assume)) return 0;
+  assert (!lgl->alevel);
+  if (!lgl->level) return 0;
+  if (lgl->level > lgl->opts->prunelevel.val) return 0;
+  return lgl->limits->prune.decisions <= lgl->stats->decisions;
+}
+
+static void lglictrav (LGL * lgl,
+  int internal, int redtoo,
+  void * state, void (*trav)(void *, int red, int lit));
+
+struct PruneState {
+  LGL * parent;
+  LGL * child;
+  Stk clause;
+  int * map;
+  int nvars;
+  int red;
+  int irr;
+};
+
+typedef struct PruneState PruneState;
+
+static void lglpruneaddcls (PruneState * state, int red) {
+  int sat = 0, nfalse = 0, ntrue = 0, nunassigned = 0, size = 0;
+  const int * p;
+  int * q;
+#ifndef NLGLOG
+  LGL * lgl = state->parent;
+  int origsize = lglcntstk (&state->clause);
+  const char * redstr = red ? "redundant" : "irredundant";
+  lglpushstk (state->parent, &state->clause, 0);
+  lglpopstk (&state->clause);
+  LOGCLS (4, state->clause.start,
+    "trying to add parent %s size %d clause",
+    redstr, origsize);
+#endif
+  for (p = state->clause.start; !sat && p < state->clause.top; p++) {
+    const int plit = *p;
+    int tmp = lglifixed (state->parent, plit);
+    if (tmp < 0) {
+      LOG (3, "ignoring root-level falsified literal %d", plit);
+    } else if (tmp > 0) {
+      LOG (3, "found root-level satisfied literal %d", plit);
+      sat = 1;
+    } else {
+      tmp = lglval (state->parent, plit);
+      if (tmp < 0) nfalse++;
+      else if (tmp > 0) ntrue++;
+      else nunassigned++;
+      size++;
+    }
+  }
+  if (sat) {
+    LOGCLS (3, state->clause.start,
+      "ignoring satisfied parent %s size %d clause",
+      redstr, origsize);
+  } else if (size == nunassigned) {
+    LOGCLS (3, state->clause.start,
+      "ignoring completely unassigned parent %s size %d clause",
+      redstr, origsize);
+  } else if (!ntrue) {
+    LOGCLS (3, state->clause.start,
+      "ignoring parent %s size %d clause "
+      "without true but %d false literals",
+      redstr, origsize, nfalse);
+  } else {
+    assert (size > 0);
+    assert (ntrue > 0);
+    LOGCLS (3, state->clause.start,
+      "copying parent %s original size %d clause "
+      "with %d true and %d false literals and %d skipped",
+      redstr, origsize, ntrue, nfalse, nunassigned);
+    q = state->clause.start;
+    for (p = q; p < state->clause.top; p++) {
+      int plit = *p, tmp = lglval (state->parent, plit);
+      if (tmp && !lglifixed (state->parent, plit)) {
+	int pidx = abs (plit), cidx = state->map[pidx], clit;
+	if (!cidx) {
+	  cidx = ++state->nvars;
+	  LOG (3,
+	    "mapping parent internal variable %d "
+	    "to child external variable %d",
+	    pidx, cidx);
+	  state->map[pidx] = cidx;
+	}
+	clit = plit < 0 ? -cidx : cidx;
+	*q++ = clit;
+      }
+    }
+    state->clause.top = q;
+#ifndef NLGLOG
+    size = lglcntstk (&state->clause);
+    lglpushstk (state->parent, &state->clause, 0);
+    lglpopstk (&state->clause);
+    LOGCLS (4, state->clause.start,
+      "add child %s size %d external clause",
+      redstr, size);
+#endif
+    if (red) state->red++; else state->irr++;
+    for (p = state->clause.start; p < state->clause.top; p++)
+      lgladd (state->child, *p);
+    lgladd (state->child, 0);
+  }
+  lglclnstk (&state->clause);
+}
+
+static int lglprunered (LGL * lgl) {
+  if (lgl->opts->block.val) return 1;
+  if (lgl->opts->prunered.val) return 1;
+  return 0;
+}
+
+static void lglpruneadd (void * ptr, int red, int lit) {
+  PruneState * state = ptr;
+  if (red && !lglprunered (state->parent)) return;
+  if (lit) lglpushstk (state->parent, &state->clause, lit);
+  else lglpruneaddcls (state, red);
+}
+
+static void lglpruneana (PruneState * state) {
+  LGL * parent = state->parent;
+#ifndef NLGLDRUPLIG
+  LGL * child = state->child;
+  int first = 0;
+#endif
+#ifndef NLGLOG
+  LGL * lgl = parent;
+#endif
+  int len;
+  Ctr * c;
+  assert (parent->level - parent->alevel > 0);
+  assert (lglmtstk (&parent->seen));
+  assert (lglmtstk (&parent->clause));
+  assert (!parent->opts->drupligcheck.val);
+  LOG (2, "analyzing and pruning level %d clause", parent->level);
+  for (c = parent->control.start + 1; c < parent->control.top; c++) {
+    int decision = c->decision;
+    lglpushstk (parent, &parent->clause, -decision);
+    lglpushstk (parent, &parent->seen, decision);
+#ifndef NLGLDRUPLIG
+    if (lgldruplig (parent)) {
+      if (!first) {
+	int pidx = abs (decision);
+	int cidx = state->map[pidx];
+	if (cidx)  {
+	  int clit = (decision < 0 ? -cidx : cidx);
+	  int tmp = lglderef (child, clit);
+	  assert (tmp);
+	  if (tmp < 0) {
+	    first = -decision;
+	    LOG (3, "first (parent internal) literal %d", first);
+	  }
+	}
+      }
+      druplig_add_literal (parent->druplig, lglexport (parent, -decision));
+    }
+#endif
+  }
+#ifndef NLGLDRUPLIG
+  if (lgldruplig (parent)) {
+    int found = 0, pidx;
+    assert (first);
+    druplig_add_literal (parent->druplig, lglexport (parent, first));
+    for (pidx = 2; pidx < parent->nvars; pidx++) {
+      int cidx = state->map[pidx], tmp, lit;
+      if (!cidx) continue;
+      tmp = lglderef (child, cidx);
+      assert (tmp);
+      lit = (tmp < 0) ? -pidx : pidx;
+      assert (first != -lit);
+      if (first == lit) found++;
+      else druplig_add_literal (parent->druplig, lglexport (parent, lit));
+    }
+    lgldrupligreallyadd (parent, REDCS);
+    assert (found == 1), (void) found;
+  }
+#endif
+  lglbumpseenlits (parent);
+  len = parent->level;
+  assert (len == lglcntstk (&parent->clause));
+  parent->stats->lits.nonmin += len;
+  parent->stats->clauses.glue += len-1;
+  parent->stats->clauses.realglue += len-1;
+  parent->stats->lits.learned += len;
+  parent->stats->clauses.learned++;
+  parent->stats->mincls.size++;
+  parent->stats->decflipped++;
+  parent->stats->confs++;
+  lglbacktrack (parent, len-1);
+  lglpushstk (parent, &parent->clause, 0);
+  (void) lgladdcls (parent, (lglprunered (parent) ? REDCS : 0), len-1, 1);
+  lglrndcls (parent, len, 1);
+  lglclnstk (&parent->clause);
+  lglclnstk (&parent->seen);
+}
+
+static void lglsetpruneprefix (LGL * child, LGL * parent, int level) {
+  int len = strlen (parent->prefix);
+  int allocated = len + 80;
+  char * prefix = lglnew (child, allocated);
+  char buffer[80];
+  sprintf (buffer,
+    "[prune-%lld-%lld-%d] .. ",
+    (LGLL) parent->stats->prune.decs,
+    (LGLL) parent->stats->prune.calls,
+    level);
+  strcpy (prefix, parent->prefix);
+  if (len && child->prefix[len-1] != ' ') strcat (prefix, " ");
+  strcat (prefix, buffer);
+  lgldelstr (child, child->prefix);
+  child->prefix = lglstrdup (child, prefix);
+  lgldel (child, prefix, allocated);
+}
+
+static void lglupdprunelim (LGL * lgl, int success) {
+  if (success) {
+    lgl->limits->prune.inc /= 2;
+    if (lgl->limits->prune.inc < lgl->opts->prunemin.val)
+      lgl->limits->prune.inc = lgl->opts->prunemin.val;
+  } else {
+    int64_t inc = lgl->limits->prune.inc/10;
+    if (!inc) inc = 1;
+    lgl->limits->prune.inc += inc;
+    if (lgl->limits->prune.inc > lgl->opts->prunemax.val)
+      lgl->limits->prune.inc = lgl->opts->prunemax.val;
+  }
+  lgl->limits->prune.decisions =
+    lgl->stats->decisions + lgl->limits->prune.inc;
+  lglprt (lgl, 2,
+    "[prune-%lld-%lld] %s new decision increment %lld limit %lld",
+    (LGLL) lgl->stats->prune.decs,
+    (LGLL) lgl->stats->prune.calls,
+    success ? "successful" : "unsuccessful",
+    (LGLL) lgl->limits->prune.inc, (LGLL) lgl->limits->prune.decisions);
+}
+
+#if 1
+
+#if 0
+
+static int lglprunedecidefirst (LGL * lgl) {
+  int valit, valother, valother2, decision, pos, neg, level, glue, sat;
+  int idx, sign, lit, blit, tag, red, other, other2, size, pure, tmp;
+  const int skipred = !lglprunered (lgl);
+  const int * p, * w, * eow, * c;
+  int * bincount, * count;
+  long best, score;
+  HTS * hts;
+  Stk * s;
+  NEW (count, 2*lgl->nvars);
+  NEW (bincount, 2*lgl->nvars);
+  bincount += lgl->nvars;
+  count += lgl->nvars;
+  level = lgl->level - lgl->alevel;
+  assert (!level);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      valit = lglval (lgl, lit);
+      if (valit > 0) continue;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	if (skipred && red) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	other2 = (tag == BINCS) ? 0 : *p;
+	if (other2 && abs (other2) < idx) continue;
+	valother = lglval (lgl, other);
+	if (valother > 0) continue;
+	valother2 = (other2 ? lglval (lgl, other2) : -1);
+	if (valother2 > 0) continue;
+	size = 0;
+	if (!valit) size++;
+	if (!valother) size++;
+	if (!valother2) size++;
+	assert (size > 1);
+	if (!valit) count[lit]++;
+	if (!valother) count[other]++;
+	if (!valother2) count[other2]++;
+	if (size > 2) continue;
+	if (!valit) bincount[lit]++;
+	if (!valother) bincount[other]++;
+	if (!valother2) bincount[other2]++;
+      }
+    }
+  }
+
+  for (glue = -1; glue < MAXGLUE; glue++) {
+    if (glue >= 0 && skipred) break;
+    s = glue < 0 ? &lgl->irr : &lgl->red[glue];
+    for (c = s->start; c < s->top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      size = sat = 0;
+      while ((other = *p)) {
+	tmp = lglval (lgl, other);
+	if (tmp > 0) sat = 1;
+	if (!tmp) size++;
+	p++;
+      }
+      if (sat) continue;
+      assert (size > 1);
+      p = c;
+      while ((other = *p)) {
+	tmp = lglval (lgl, other);
+	if (!tmp) {
+	  if (size == 2) bincount[other]++;
+	  count[other]++;
+	}
+	p++;
+      }
+    }
+  }
+
+  pure = 0;
+  for (idx = 2; !pure && !skipred && idx < lgl->nvars; idx++) {
+    if (lglval (lgl, idx)) continue;
+    if (lglifrozen (lgl, idx)) continue;
+    for (sign = -1; !pure && sign <= 2; sign += 2) {
+      lit = sign * idx;
+      tmp = count[-lit];
+      if (!tmp) pure = lit;
+    }
+  }
+
+  if (pure && !lgl->opts->drupligcheck.val) {
+    decision = INT_MIN;
+    lglprt (lgl, 2,
+      "[prune-%lld-%lld-%d] pure literal %d in %d clauses",
+      (LGLL) lgl->stats->prune.decs,
+      (LGLL) lgl->stats->prune.calls,
+      level+1,
+      pure, count[pure]);
+    lgl->stats->prune.pure++;
+    lglunit (lgl, pure);
+  } else {
+    decision = 0, best = LLMAX;
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      if (lglval (lgl, idx)) continue;
+      if (lglifrozen (lgl, idx)) continue;
+      pos = bincount[idx];
+      neg = bincount[-idx];
+      score = pos * (long) neg + pos + neg;
+      if (score >= best) continue;
+      decision = (pos < neg ? idx : -idx);
+      best = score;
+    }
+
+    lglprt (lgl, 2,
+      "[prune-%lld-%lld-%d] "
+      "best decision %d with %d positive and %d negated binary occurrences",
+      (LGLL) lgl->stats->prune.decs,
+      (LGLL) lgl->stats->prune.calls,
+      level+1,
+      decision, bincount[decision], bincount[-decision]);
+  }
+
+  count -= lgl->nvars;
+  bincount -= lgl->nvars;
+  DEL (bincount, 2*lgl->nvars);
+  DEL (count, 2*lgl->nvars);
+
+  return decision;
+}
+
+#else
+
+static int lglprunedecidefirst (LGL * lgl) {
+  int idx, sign, lit, blit, tag, red, other, other2, size, pure, tmp;
+  int valit, valother, valother2, decision, glue, sat;
+  const int skipred = !lglprunered (lgl);
+  const int * p, * w, * eow, * c;
+  int * count, bestcount;
+  int64_t * sum, bestsum;
+  HTS * hts;
+  Stk * s;
+  NEW (count, 2*lgl->nvars);
+  NEW (sum, 2*lgl->nvars);
+  count += lgl->nvars;
+  sum += lgl->nvars;
+  assert (!lgl->level);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      valit = lglval (lgl, lit);
+      if (valit > 0) continue;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	if (skipred && red) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	other2 = (tag == BINCS) ? 0 : *p;
+	if (other2 && abs (other2) < idx) continue;
+	valother = lglval (lgl, other);
+	if (valother > 0) continue;
+	valother2 = (other2 ? lglval (lgl, other2) : -1);
+	if (valother2 > 0) continue;
+	size = 0;
+	if (!valit) size++;
+	if (!valother) size++;
+	if (!valother2) size++;
+	assert (size > 1);
+	if (!valit) count[lit]++, sum[lit] += size;
+	if (!valother) count[other]++, sum[other] += size;
+	if (!valother2) count[other2]++, sum[other2] += size;
+      }
+    }
+  }
+
+  for (glue = -1; glue < MAXGLUE; glue++) {
+    if (glue >= 0 && skipred) break;
+    s = glue < 0 ? &lgl->irr : &lgl->red[glue];
+    for (c = s->start; c < s->top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      size = sat = 0;
+      while ((other = *p)) {
+	tmp = lglval (lgl, other);
+	if (tmp > 0) sat = 1;
+	if (!tmp) size++;
+	p++;
+      }
+      if (sat) continue;
+      assert (size > 1);
+      p = c;
+      while ((other = *p)) {
+	tmp = lglval (lgl, other);
+	if (!tmp) count[other]++, sum[other] += size;
+	p++;
+      }
+    }
+  }
+
+  pure = 0;
+  if (lgl->opts->prunepure.val &&
+      !lgl->opts->drupligcheck.val &&
+      !skipred) {
+    for (idx = 2; !pure && idx < lgl->nvars; idx++) {
+      if (lglval (lgl, idx)) continue;
+      if (lglifrozen (lgl, idx)) continue;
+      for (sign = 1; !pure && sign >= -1; sign -= 2)
+	if (!count[lit = sign * idx]) pure = -lit;
+    }
+  }
+
+  if (pure) {
+    decision = INT_MIN;
+    lglprt (lgl, 2,
+      "[prune-%lld-%lld-%d] found pure literal %d in %d clauses",
+      (LGLL) lgl->stats->prune.decs,
+      (LGLL) lgl->stats->prune.calls,
+      lgl->level+1,
+      pure, count[pure]);
+    lgl->stats->prune.pure++;
+    lglunit (lgl, pure);
+  } else {
+    decision = 0, bestsum = 0, bestcount = INT_MAX;
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      if (lglval (lgl, idx)) continue;
+      if (lglifrozen (lgl, idx)) continue;
+      for (sign = 1; !pure && sign >= -1; sign -= 2) {
+	int tmpcount, update = 0;;
+	int64_t tmpsum;
+	lit = sign * idx;
+	tmpcount = count[lit];
+	tmpsum = sum[lit];
+	if (tmpcount < bestcount) update = 1;
+	else if (tmpcount && tmpcount == bestcount) {
+	  int64_t L, R;
+	  if (LLMAX / tmpcount <= bestsum) L = LLMAX;
+	  else L = bestsum * tmpcount;
+	  if (LLMAX / bestcount <= tmpsum) R = LLMAX;
+	  else R = tmpsum * bestcount;
+	  update = L < R;
+	}
+	if (!update) continue;
+	decision = lit;
+	bestcount = tmpcount;
+	bestsum = tmpsum;
+      }
+    }
+
+    lglprt (lgl, 2,
+      "[prune-%lld-%lld-%d] "
+      "best decision %d with %d occurrences and average length %.3f",
+      (LGLL) lgl->stats->prune.decs,
+      (LGLL) lgl->stats->prune.calls,
+      lgl->level+1,
+      decision, count[decision], lglavg (sum[decision], count[decision]));
+  }
+
+  sum -= lgl->nvars;
+  count -= lgl->nvars;
+  DEL (sum, 2*lgl->nvars);
+  DEL (count, 2*lgl->nvars);
+
+  return decision;
+}
+
+#endif
+
+static int lglprunedecidelater (LGL * lgl) {
+  int decision, shortest, size, tmp, sat, reduced, lit, glue;
+  int idx, sign, blit, tag, red, other, other2;
+  const int skipred = !lglprunered (lgl);
+  int valit, valother, valother2;
+  const int * p, * w, * eow, * c;
+  HTS * hts;
+  Stk * s;
+
+  assert (lgl->level);
+  assert (lgl->level < lgl->opts->prunelevel.val);
+
+  decision = 0, shortest = INT_MAX;
+
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      valit = lglval (lgl, lit);
+      if (valit > 0) continue;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == BINCS) continue;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	if (skipred && red) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	valother = lglval (lgl, other);
+	if (valother > 0) continue;
+	other2 = *p;
+	if (abs (other2) < idx) continue;
+	valother2 = lglval (lgl, other2);
+	if (valother2 > 0) continue;
+	size = 0;
+	if (!valit) size++;
+	if (!valother) size++;
+	if (!valother2) size++;
+	assert (size > 1);
+	if (size > 2) continue;
+	assert (size == 2);
+	tmp = 0;
+	if (!valit && !lglifrozen (lgl, lit)) tmp = lit;
+	if (!valother && !lglifrozen (lgl, other)) tmp = other;
+	if (!valother2 && !lglifrozen (lgl, other2)) tmp = other2;
+	if (!tmp || abs (tmp) >= abs (decision)) continue; 
+	decision = tmp;
+	shortest = 2;
+      }
+    }
+  }
+
+  if (!decision)  {
+    for (glue = -1; glue < MAXGLUE; glue++) {
+      if (glue >= 0 && skipred) break;
+      s = glue < 0 ? &lgl->irr : &lgl->red[glue];
+      for (c = s->start; c < s->top; c = p + 1) {
+	p = c;
+	if (*p >= NOTALIT) continue;
+	reduced = sat = lit = size = 0;
+	while ((other = *p)) {
+	  tmp = lglval (lgl, other);
+	  if (tmp > 0) sat = 1;
+	  if (!tmp) {
+	    if (!lglifrozen (lgl, other) &&
+		(!lit || abs (other) < abs (lit)))
+	      lit = other;
+	    size++;
+	  } else if (lglevel (lgl, other)) reduced = 1;
+	  p++;
+	}
+	if (sat || !lit || !reduced) continue;
+	assert (size > 1);
+	if (size > shortest) continue;
+	if (size == shortest && abs (lit) >= abs (decision)) continue;
+	assert (lit);
+	decision = lit;
+	shortest = size;
+      }
+    }
+  }
+
+  lglprt (lgl, 2,
+    "[prune-%lld-%lld-%d] "
+    "best decision %d in shortest reduced clause of size %d",
+    (LGLL) lgl->stats->prune.decs,
+    (LGLL) lgl->stats->prune.calls,
+    lgl->level+1, decision, shortest);
+  
+  return decision;
+}
+
+#else
+
+static void lglprunedecidecands (LGL * lgl, char * cands) {
+  int size, reduced, sat, valit, valother, valother2, count, glue;
+  int blit, tag, red, other, other2, idx, sign, lit, tmp;
+  const int skipred = !lglprunered (lgl);
+  const int * p, * w, * eow, * c;
+  HTS * hts;
+  Stk * s;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    cands[idx] = cands[-idx] = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      valit = lglval (lgl, lit);
+      if (valit > 0) continue;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == BINCS && lgl->level) continue;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == LRGCS) continue;
+	red = blit & REDCS;
+	if (skipred && red) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	valother = lglval (lgl, other);
+	if (valother > 0) continue;
+	if (tag == TRNCS) {
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	  valother2 = lglval (lgl, other2);
+	  if (valother2 > 0) continue;
+	  size = 0;
+	  if (!valit) size++;
+	  if (!valother) size++;
+	  if (!valother2) size++;
+	  assert (size > 1);
+	  if (size > 2) continue;
+	  assert (size == 2);
+	  if (lgl->level) {
+	    reduced = 0;
+	    if (valit < 0 && lglevel (lgl, lit)) reduced++;
+	    if (valother < 0 && lglevel (lgl, valother)) reduced++;
+	    if (valother2 < 0 && lglevel (lgl, valother2)) reduced++;
+	    if (!reduced) continue;
+	  }
+	  if (!valit && !lglifrozen (lgl, lit)) cands[lit] = 1;
+	  if (!valother && !lglifrozen (lgl, other)) cands[other] = 1;
+	  if (!valother2 && !lglifrozen (lgl, other2)) cands[other2] = 1;
+	} else {
+	  assert (!valit);
+	  assert (!valother);
+	  if (!lglifrozen (lgl, lit)) cands[lit] = 1;
+	  if (!lglifrozen (lgl, other)) cands[other] = 1;
+	}
+      }
+    }
+  }
+  for (glue = -1; glue < MAXGLUE; glue++) {
+    if (glue >= 0 && skipred) break;
+    s = glue < 0 ? &lgl->irr : &lgl->red[glue];
+    for (c = s->start; c < s->top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      reduced = sat = size = 0;
+      while ((other = *p)) {
+	tmp = lglval (lgl, other);
+	if (tmp > 0) sat++;
+	if (!tmp && !lglifrozen (lgl, other)) size++;
+	if (tmp < 0 && lglevel (lgl, other)) reduced++;
+	p++;
+      }
+      if (sat || !size) continue;
+      if (lgl->level && !reduced) continue;
+      p = c;
+      while ((other = *p)) {
+	tmp = lglval (lgl, other);
+	if (!tmp && !lglifrozen (lgl, other)) cands[other] = 1;
+	p++;
+      }
+    }
+  }
+  count = 0;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2)
+      if (cands[sign * idx]) count++;
+  lglprt (lgl, 2,
+    "[prune-%lld-%lld-%d] "
+    "found %d decision candidates at level %d",
+    (LGLL) lgl->stats->prune.decs,
+    (LGLL) lgl->stats->prune.calls,
+    lgl->level + 1, count, lgl->level);
+}
+
+static int lglprunedecidesize (LGL * lgl, char * cands, int size, int * nextsizeptr) {
+  int nextsize = INT_MAX;
+  *nextsizeptr = nextsize;
+  return 0;
+}
+
+static int lglprunedecidephase (LGL * lgl, int idx) {
+  return idx;
+}
+
+static int lglprunedecidelit (LGL * lgl) {
+  int size, next, idx = 0, res;
+  char * cands;
+  NEW (cands, 2*lgl->nvars);
+  cands += lgl->nvars;
+  lglprunedecidecands (lgl, cands);
+  for (size = 2;
+       !idx &&
+       size != INT_MAX &&
+       size < lgl->opts->prunesize.val;
+       size = next)
+    idx = lglprunedecidesize (lgl, cands, size, &next);
+  cands -= lgl->nvars;
+  DEL (cands, 2*lgl->nvars);
+  res = lglprunedecidephase (lgl, idx);
+  return res;
+}
+
+#define lglprunedecidefirst lglprunedecidelit
+#define lglprunedecidelater lglprunedecidelit
+
+#endif
+
+static int lglprunedecide (LGL * lgl) {
+  int decision;
+  if (lgl->mt) return 0;
+  if (!lgl->unassigned) return 0;
+  if (!lgl->opts->prune.val) return 0;
+  if (lgl->opts->prunevsids.val) return 0;
+  if (!lglmtstk (&lgl->assume)) return 0;
+  if (lgl->level >= lgl->opts->prunelevel.val) return 0;
+  lglstart (lgl, &lgl->times->prune);
+  lgl->stats->prune.decs++;
+  if (!lgl->level) decision = lglprunedecidefirst (lgl);
+  else decision = lglprunedecidelater (lgl);
+  LOG (2, "prune decision %d", decision);
+  lglstop (lgl);
+  return decision;
+}
+
+static void lglprunecopytrail (LGL * parent, int * map, LGL * child) {
+#ifndef NLGLOG
+  LGL * lgl = parent;
+#endif
+  const int * p;
+  int size = 0;
+  for (p = parent->trail.start; p < parent->trail.top; p++) {
+    int plit = *p, level = lglevel (parent, plit), pidx, cidx;
+    assert (lglval (parent, plit) > 0);
+    if (level && !lgldecision (parent, plit)) continue;
+    pidx = abs (plit);
+    cidx = map[pidx];
+    if (cidx) {
+      int clit = plit < 0 ? -cidx : cidx;
+      if (level) {
+	LOG (3,
+	  "adding parent decision %d negated as child external literal %d",
+	  plit, -clit);
+	lgladd (child, -clit);
+	size++;
+      } else {
+	LOG (3,
+	  "adding parent unit %d as external child unit %d",
+	  plit, clit);
+	lgladd (child, clit);
+	lgladd (child, 0);
+      }
+    } else LOG (2, "ignoring unused parent literal %d", plit);
+  }
+  lgladd (child, 0);
+  LOG (2, "added %d negated decisions", size);
+  assert (size <= parent->level);
+}
+
+static LGL * lglprunechild (LGL * parent,
+                            int level, PruneState * state) {
+  LGL * child;
+  assert (0 < level);
+  assert (parent->level - parent->alevel == level);
+  assert (level <= parent->opts->prunelevel.val);
+  child = lglminit (parent->mem->state,
+                    parent->mem->alloc,
+                    parent->mem->realloc,
+                    parent->mem->dealloc);
+  lglcopyclonenfork (child, parent);
+  lglsetpruneprefix (child, parent, level);
+  child->opts->prune.val = 0;
+  child->opts->clim.val = parent->opts->pruneclim.val;
+  child->opts->trep.val = 0;
+  child->opts->druplig.val = 0;
+  child->opts->drupligcheck.val = 0;
+  child->opts->drupligtrace.val = 0;
+  child->opts->drupligtraceorig.val = 0;
+  if (child->opts->verbose.val > -1 && parent->opts->log.val < 0)
+    child->opts->verbose.val--;
+  if (!child->opts->plain.val) lglsetplain (child, 1);
+  CLR (*state);
+  state->parent = parent;
+  state->child = child;
+  state->map = lglnew (parent, parent->nvars * sizeof *state->map);
+  lglictrav (parent, 1, 1, state, lglpruneadd);
+  lglrelstk (parent, &state->clause);
+  lglprt (parent, 2,
+    "[prune-%lld-%lld-%d] "
+    "copied %d variables in %d irredundant and %d redundant clauses",
+    (LGLL) parent->stats->prune.decs, (LGLL) parent->stats->prune.calls,
+    level, state->nvars, state->irr, state->red);
+  lglprunecopytrail (parent, state->map, child);
+  return child;
+}
+
+static int lglprunesat (LGL * parent, int level) {
+  PruneState state;
+  LGL * child = lglprunechild (parent, level, &state);
+  int res = lglsat (child);
+  parent->stats->prune.child.confs += child->stats->confs;
+  parent->stats->prune.child.decs += child->stats->decisions;
+  parent->stats->prune.child.props += child->stats->props.search;
+  parent->stats->prune.child.props += child->stats->props.simp;
+  lglprt (parent, 2,
+    "[prune-%lld-%lld-%d] result %d in %lld conflicts and %lld decisions",
+    (LGLL) parent->stats->prune.decs, (LGLL) parent->stats->prune.calls,
+    level, res, (LGLL) child->stats->confs, (LGLL) child->stats->decisions);
+  if (res == 10) lglpruneana (&state);
+  lgldel (parent, state.map, parent->nvars * sizeof *state.map);
+  lglrelease (child);
+  return res;
+}
+
+static void lglprune (LGL * lgl) {
+  int res, level = lgl->level - lgl->alevel;
+  const char * reason;
+  assert (!lgl->mt);
+  assert (lgl->unassigned);
+  assert (lgl->opts->prune.val);
+  assert (level <= lgl->opts->prunelevel.val);
+  lglstart (lgl, &lgl->times->prune);
+  lgl->stats->prune.calls++;
+  lgl->stats->prune.levels += level;
+  lglprt (lgl, 2,
+    "[prune-%lld-%lld-%d] starting pruning after %lld decisions", 
+    (LGLL) lgl->stats->prune.decs, (LGLL) lgl->stats->prune.calls,
+    level, lgl->stats->decisions);
+  res = lglprunesat (lgl, level);
+  if (res == 10) {
+    reason = "satisfiable";
+    lgl->stats->prune.sat++;
+  } else if (res == 20) {
+    reason = "unsatisfiable";
+    lgl->stats->prune.uns++;
+  } else {
+    reason = "limit reached";
+    lgl->stats->prune.lim++;
+  }
+  lglprt (lgl, 2,
+    "[prune-%lld-%lld-%d] pruning result '%s' (%s)", 
+    (LGLL) lgl->stats->prune.decs, (LGLL) lgl->stats->prune.calls,
+    level, reason, res == 10 ? "successful" : "unsuccessful");
+  lglupdprunelim (lgl, res == 10);
+  lglstop (lgl);
+  lglrep (lgl, 2, 'P');
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglquatresolving (LGL * lgl) { 
+  if (lgldelaying (lgl, "quatres", &lgl->limits->quatres.del.rem)) return 0;
+  if (lglwaiting (lgl, "quatres", lgl->opts->quatreswait.val)) return 0;
+  return lgl->opts->quatres.val;
+}
+
+static int lglternresolving (LGL * lgl) { 
+  if (lgldelaying (lgl, "ternres", &lgl->limits->ternres.del.rem)) return 0;
+  if (lglwaiting (lgl, "ternres", lgl->opts->ternreswait.val)) return 0;
+  return lgl->opts->ternres.val;
+}
+
+static int lglgaussing (LGL * lgl) { 
+  if (lgldelaying (lgl, "gauss", &lgl->limits->gauss.del.rem)) return 0;
+  if (lglwaiting (lgl, "gauss", lgl->opts->gausswait.val)) return 0;
+  if (!lglsmallirr (lgl)) return 0;
+  return lgl->opts->gauss.val;
+}
+
+static int lglprobing (LGL * lgl) {
+  if (!lgl->opts->probe.val) return 0;
+  if (lgl->opts->prbasic.val) return 1;
+  if (!lglsmallirr (lgl)) return 0;
+  if (lgl->opts->prbsimple.val) return 1;
+  if (lgl->opts->treelook.val) return 1;
+  return 0;
+}
+
+static int lglcarding (LGL * lgl) {
+  if (!lgl->opts->card.val) return 0;
+  if (lgldelaying (lgl, "card", &lgl->limits->card.del.rem)) return 0;
+  if (lglwaiting (lgl, "card", lgl->opts->cardwait.val)) return 0;
+  return 1;
+}
+
+static int lglcceing (LGL * lgl) {
+  if (!lgl->opts->cce.val) return 0;
+  if (lgl->allfrozen) return 0;
+  if (lgldelaying (lgl, "cce", &lgl->limits->cce.del.rem)) return 0;
+  if (lglwaiting (lgl, "cce", lgl->opts->ccewait.val)) return 0;
+  if (!lglsmallirr (lgl)) return 0;
+  return 1;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void lglupdlocslim (LGL * lgl, int updconflimtoo) {
+  int rem = lglrem (lgl), varslimit, vardelta;
+  vardelta = (rem * lgl->opts->locsvared.val + 999)/1000;
+  if (vardelta > rem) vardelta = rem;
+  varslimit = rem - vardelta;
+  lgl->limits->locs.vars = varslimit;
+  lglprt (lgl, 1 + !lgl->opts->locs.val,
+    "[locs-lim] next local search variable limit %d = %d - %d",
+    varslimit, rem, vardelta);
+  if (!updconflimtoo) return;
+  lgl->limits->locs.inc += lgl->opts->locscint.val;
+  assert (lgl->limits->locs.confs <= LLMAX - lgl->limits->locs.inc);
+  lgl->limits->locs.confs = lgl->stats->confs + lgl->limits->locs.inc;
+  lglprt (lgl, 1 + !lgl->opts->locs.val,
+    "[locs-lim] next local search conflict limit increased by %d to %lld",
+    lgl->limits->locs.inc, lgl->limits->locs.confs);
+}
+
+static int lglocsing (LGL * lgl) {
+#ifndef NLGLYALSAT
+  int rem;
+  if (!lgl->opts->locs.val) return 0;
+  if (lgl->limits->locs.confs > lgl->stats->confs) return 0;
+  if (lgl->stats->irr.clauses.cur > lgl->opts->locsclim.val) {
+    lglprt (lgl, 2, "[locs] skipped due to too many clauses");
+    return 0;
+  }
+  rem = lglrem (lgl);
+  if (rem < lgl->limits->locs.vars) {
+    lglprt (lgl, 2,
+      "[locs-limit] local search skipped (remaining %d < limit %d)",
+      rem, lgl->limits->locs.vars);
+    lglupdlocslim (lgl, 1);
+    return 0;
+  }
+  if (lglwaiting (lgl, "locs", lgl->opts->locswait.val)) return 0;
+  if (lgl->opts->locs.val < 0) return 1;
+  return (lgl->stats->locs.count < lgl->opts->locs.val);
+#else
+  (void) lgl;
+  return 0;
+#endif
+}
+
+#ifndef NLGLYALSAT
+
+static void lglocscopy (LGL * lgl, Yals * yals) {
+  int idx, sign, lit, blit, tag, red, other, other2;
+  int count, redcount, units, tmp;
+  const int * p, * w, * eow, * c;
+  HTS * hts;
+  Stk * s;
+  assert (!lgl->level);
+  if (!lgl->mt && !lglbcp (lgl)) lglmt (lgl);
+  if (!lgl->mt) lglgc (lgl);
+  if (lgl->mt) return;
+  count = redcount = units = 0;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      assert (!lglval (lgl, lit));
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	red = blit & REDCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (red && tag == BINCS && lgl->opts->locsred.val < 2) continue;
+	if (red && tag == TRNCS && lgl->opts->locsred.val < 3) continue;
+	if (tag != BINCS && tag != TRNCS) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	assert (!lglval (lgl, other));
+	if (tag == TRNCS) {
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	  assert (!lglval (lgl, other2));
+	} else other2 = 0;
+	yals_add (yals, lit);
+	yals_add (yals, other);
+	if (other2) yals_add (yals, other2);
+	yals_add (yals, 0);
+	if (red) redcount++;
+	count++;
+      }
+    }
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    tmp = lglifixed (lgl, idx);
+    if (!tmp) continue;
+    lit = (tmp < 0) ? -idx : idx;
+    yals_add (yals, lit);
+    yals_add (yals, 0);
+    units++;
+  }
+  for (red = -1; red < MAXGLUE; red++) {
+    s = red < 0 ? &lgl->irr : lgl->red + red;
+    if (red >= 0 && lgl->opts->locsred.val < 4) break;
+    for (c = s->start; c < s->top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      while ((other = *p)) {
+	assert (!lglval (lgl, other));
+	yals_add (yals, other);
+	p++;
+      }
+      yals_add (yals, 0);
+      if (red >= 0) redcount++;
+      count++;
+    }
+  }
+
+  lglprt (lgl, 1,
+    "[locs-%d] copied %d irredundant clauses",
+    lgl->stats->locs.count, count - redcount);
+  if (redcount)
+    lglprt (lgl, 1,
+      "[locs-%d] copied %d redundant clauses",
+      lgl->stats->locs.count, redcount);
+  if (units)
+    lglprt (lgl, 1,
+      "[locs-%d] copied %d units",
+      lgl->stats->locs.count, units);
+
+  for (count = 0; count < lglcntstk (&lgl->assume); count++) {
+    lit = lglpeek (&lgl->assume, count);
+    if (abs (lit) <= 0) continue;
+    yals_add (yals, lit);
+    yals_add (yals, 0);
+  }
+  if (count)
+    lglprt (lgl, 1,
+      "[locs-%d] copied %d assumptions as %d unit clauses",
+      lgl->stats->locs.count, count, count);
+  else
+    lglprt (lgl, 2,
+      "[locs-%d] no assumptions copied",
+      lgl->stats->locs.count);
+}
+
+static int64_t lglsetlocslim (LGL * lgl) {
+  int pen, boost;
+  int64_t limit;
+  if (lgl->opts->locsrtc.val) {
+    limit = LLMAX;
+    lglprt (lgl, 1,
+      "[locs-%d] really no limit (run to completion)",
+      lgl->stats->locs.count);
+  } else {
+    limit = (lgl->opts->locsreleff.val*lglvisearch (lgl))/100;
+    if (limit < lgl->opts->locsmineff.val) 
+      limit = lgl->opts->locsmineff.val;
+    if (lgl->opts->locsmaxeff.val >= 0 &&
+        limit > lgl->opts->locsmaxeff.val)
+      limit = lgl->opts->locsmaxeff.val;
+    if (lgl->stats->locs.count <= 1 &&
+        lgl->opts->boost.val &&
+        lgl->opts->locsboost.val > 1) {
+      boost = lgl->opts->locsboost.val;
+      lglprt (lgl, 1,
+	"[locs-%d] intially boosting limit by factor of %d",
+	lgl->stats->locs.count, boost);
+    } else boost = 1;
+    limit *= boost;
+    pen = lglitszpen (lgl);
+    limit >>= pen;
+    lglprt (lgl, 1,
+      "[locs-%d] limit %lld literal penalty %d",
+      lgl->stats->locs.count, (LGLL) limit, pen);
+  }
+  return limit;
+}
+
+#endif
+
+static int lglocsaux (LGL * lgl, int hitlim) {
+  int lkhd = 0;
+#ifndef NLGLYALSAT
+  int save = lgl->opts->locsexport.val && lgl->opts->phasesave.val;
+  int res, min, pos, neg, idx, lit, old_val, len;
+  const int set = lgl->opts->locset.val;
+  unsigned long long seed;
+  char * prefix;
+  int64_t limit;
+  AVar * av;
+  Val val;
+  Yals * yals;
+  lglstart (lgl, &lgl->times->locs);
+  if (lgl->level) lglbacktrack (lgl, 0);
+  if (!lgl->stats->locs.count++) {
+    const char * yals_version ();
+    if (lgl->opts->verbose.val > 0)
+      lglprt (lgl, 1,
+	"[locs-%d] YalSAT Version %s",
+	lgl->stats->locs.count, yals_version ());
+    else if (lgl->opts->locsbanner.val) {
+      char * prefix = lgl->prefix;
+      lgl->prefix = "c ";
+      lglprt (lgl, 0, "YalSAT Version %s", yals_version ());
+      lgl->prefix = prefix;
+    }
+  }
+  yals = yals_new_with_mem_mgr ( lgl,
+	   (YalsMalloc) lglnew, (YalsRealloc) lglrsz, (YalsFree) lgldel);
+  yals_setout (yals, lgl->out);
+  len = strlen (lgl->prefix) + 80;
+  NEW (prefix, len);
+  if (lgl->tid >= 0)
+    sprintf (prefix, "%s%d [locs-%d] ",
+      lgl->prefix, lgl->tid, lgl->stats->locs.count);
+  else
+    sprintf (prefix, "%s[locs-%d] ", lgl->prefix, lgl->stats->locs.count);
+  yals_setprefix (yals, prefix);
+  DEL (prefix, len);
+  old_val = yals_getopt (yals, "verbose");
+  if (old_val < lgl->opts->verbose.val)
+    yals_setopt (yals, "verbose", lgl->opts->verbose.val);
+  seed = lglrand (lgl);
+  if (lgl->tid >= 0) seed *= lgl->tid + 1;
+  seed += 1237 * (unsigned) lgl->stats->locs.count;
+  yals_srand (yals, seed);
+  if (hitlim > 0) yals_setopt (yals, "hitlim", hitlim);
+  lglocscopy (lgl, yals);
+  if (lgl->mt) goto DONE;
+  limit = lglsetlocslim (lgl);
+  pos = neg = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    av = lglavar (lgl, idx);
+         if (set == 2 && av->phase > 0) lit = idx;
+    else if (set == 2 && av->phase < 0) lit = -idx;
+    else if (set == 1 && av->locsval > 0) lit = idx;
+    else if (set == 1 && av->locsval < 0) lit = -idx;
+    else continue;
+    assert (lit);
+    if (lit < 0) neg++; else pos++;
+    yals_setphase (yals, lit);
+  }
+  lglprt (lgl, 1,
+    "[locs-%d] importing %d positive %.0f%% and %d negative %.0f%% phases",
+    lgl->stats->locs.count,
+    pos, lglpcnt (pos, pos + neg),
+    neg, lglpcnt (neg, pos + neg));
+  if (limit < LLMAX/1000) limit *= 1000; else limit = LLMAX;
+  yals_setmemslimit (yals, limit);
+  if (lgl->cbs && lgl->cbs->term.fun)
+    yals_seterm (yals, lgl->cbs->term.fun, lgl->cbs->term.state);
+  if (lgl->cbs && lgl->cbs->getime)
+    yals_setime (yals, lgl->cbs->getime);
+  if (lgl->cbs && lgl->cbs->msglock.lock)
+    yals_setmsglock (yals,
+      lgl->cbs->msglock.lock,
+      lgl->cbs->msglock.unlock,
+      lgl->cbs->msglock.state);
+  res = yals_sat (yals);
+  min = yals_minimum (yals);
+  lglprt (lgl, 1,
+    "[locs-%d] local search returns %d with minimum %d",
+    lgl->stats->locs.count, res, min);
+  if (min < lgl->stats->locs.min) lgl->stats->locs.min = min;
+  lgl->stats->locs.flips += yals_flips (yals);
+  lgl->stats->locs.mems += yals_mems (yals);
+  if (res == 10) save = 1;
+  pos = neg = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    val = yals_deref (yals, idx);
+    assert (abs (val) == 1);
+    av = lglavar (lgl, idx);
+    if (val < 0) neg++, av->locsval = -1;
+    else if (val > 0) pos++, av->locsval = 1;
+    if (save) av->phase = val;
+  }
+  lglprt (lgl, 1,
+    "[locs-%d] %s %d positive %.0f%% and %d negative %.0f%% phases",
+    lgl->stats->locs.count,
+    save ? "exported" : "found",
+    pos, lglpcnt (pos, pos + neg),
+    neg, lglpcnt (neg, pos + neg));
+DONE:
+  if (lgl->opts->verbose.val >= 1) yals_stats (yals);
+  yals_del (yals);
+  lglstop (lgl);
+#endif
+  return lkhd;
+}
+
+static void lglocs (LGL * lgl) {
+  (void) lglocsaux (lgl, 0);
+  lglupdlocslim (lgl, 1);
+}
+
+static int lglocslook (LGL * lgl) {
+  int res = lglocsaux (lgl, 100000), elit;
+  Ext * ext;
+  if (res) {
+    elit = lglexport (lgl, res);
+    ext = lglelit2ext (lgl, elit);
+    if (!ext->eliminated && !ext->blocking) {
+      lglprt (lgl, 1, "[locslook] best local search look-ahead %d", res);
+      if (ext->melted) {
+	ext->melted = 0;
+	LOG (2, "look-ahead winner external %d not melted anymore", elit);
+      } else
+	LOG (2, "look-ahead winner external %d was not melted anyhow", elit);
+    } else {
+      lglprt (lgl, 1, "[locslook] no valid local search look-ahead");
+      lglprt (lgl, 1, "[locslook] falling back to JWH");
+      res = lgljwhlook (lgl);
+    }
+  } else LOG (1, "no proper local search look-ahead literal found");
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglforklit (int ilit) {
+  int idx = abs (ilit), res;
+  assert (idx > 1);
+  res = idx - 1;
+  if (ilit < 0) res = -res;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglsweeping (LGL * lgl) {
+  if (!lglsmallirr (lgl)) return 0;
+  if (!lgl->opts->sweep.val) return 0;
+  if (lgldelaying (lgl, "sweep", &lgl->limits->sweep.del.rem)) return 0;
+  if (lglwaiting (lgl, "sweep", lgl->opts->sweepwait.val)) return 0;
+  return 1;
+}
+
+static void lglinitsweep (LGL * lgl) {
+  int idx, lit, pos, neg, rem = 0, ret = 0;
+  AVar * av;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    if (lglavar (lgl, idx)->donotsweep) ret++; else rem++;
+  }
+  if (!rem) {
+    ret = 0;
+    for (idx = 2; idx < lgl->nvars; idx++) {
+      if (!lglisfree (lgl, idx)) continue;
+      lglavar (lgl, idx)->donotsweep = 0;
+      rem++;
+    }
+  }
+  pos = neg = 0;
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    av = lglavar (lgl, idx);
+    if (av->donotsweep) continue;
+    if (av->phase <= 0) lit = -idx, neg++;
+    else lit = idx, pos++;
+    lglpushstk (lgl, &lgl->swp->partition, lit);
+  }
+  assert (pos + neg == rem);
+  if (rem > 1) {
+    lglpushstk (lgl, &lgl->swp->partition, 0);
+    lgl->swp->partitions++;
+  } else if (rem) {
+    assert (rem == 1);
+    lglclnstk (&lgl->swp->partition);
+  } else assert (lglmtstk (&lgl->swp->partition));
+  lglprt (lgl, 1,
+    "[sweep-%d-%d] %d pos %.1f%% + %d neg %.1f%% = %d sched %.1f%% ret %d",
+    lgl->stats->sweep.count, lgl->swp->round,
+    pos, lglpcnt (pos, rem),
+    neg, lglpcnt (neg, rem),
+    rem, lglpcnt (rem, lgl->nvars - 2), ret);
+}
+
+static double lglsweepavgpartitionsize (LGL * lgl) {
+  int count, n;
+  double res;
+  assert (lgl->swp);
+  if (lglmtstk (&lgl->swp->partition)) return 0;
+  count = lglcntstk (&lgl->swp->partition);
+  n = lgl->swp->partitions;
+  assert (0 < n), assert (n < count);
+  res = count - n;
+  res /= n;
+  return res;
+}
+
+static void lgladdsweepbincls (LGL * lgl, int a, int b) {
+  assert (lgl->swp);
+  assert (lglmtstk (&lgl->clause));
+  lglpushstk (lgl, &lgl->clause, a);
+  lglpushstk (lgl, &lgl->clause, b);
+  lglpushstk (lgl, &lgl->clause, 0);
+  LOG (2, "sweeping detected binary clause", a, b);
+  lgldrupligaddcls (lgl, REDCS);
+  lgladdcls (lgl, REDCS, 0, 1);
+  lglclnstk (&lgl->clause);
+}
+
+static void lglsweepsatinitlit (LGL * lgl, int lit, int a, int b) {
+  int idx = abs (lit), decision;
+  AVar * av;
+  assert (a > 0), assert (b > 0);
+  if (a == idx) return;
+  if (b == idx) return;
+  av = lglavar (lgl, idx);
+  if (av->mark) return;
+  av->mark = 1;
+  if (lgldefphase (lgl, idx) <= 0) decision = -idx;
+  else decision = idx;
+  LOG (2, "sweep SAT adding decision %d", decision);
+  lglpushstk (lgl, &lgl->swp->decision.stk, decision);
+}
+
+#define LGLCMPSWPDEC(A,B) lgldcmp (lgl, *(B), *(A))
+
+static void lglsweepsatinit (LGL * lgl, int a, int b) {
+  int i, idx, sign, lit, blit, tag, red, other, other2, lidx, old, count;
+  const int sweepred = lgl->opts->sweepred.val;
+  const int sweepirr = lgl->opts->sweepirr.val;
+  const int * w, * eow, * p, * c, * l;
+  HTS * hts;
+  a = abs (a), b = abs (b);
+  if (b > a) SWAP (int, a, b);
+  if (a == lgl->swp->decision.cached.a &&
+      b == lgl->swp->decision.cached.b) {
+    LOG (2, "sweep SAT using cached environment of %d and %d", a, b);
+    lgl->stats->sweep.cached++;
+    count = lglcntstk (&lgl->swp->decision.stk);
+    goto DONE;
+  }
+  lglclnstk (&lgl->swp->decision.stk);
+  for (i = 0; i <= 1; i++) {
+    idx = i ? b : a;
+    old = lglcntstk (&lgl->swp->decision.stk);
+    LOG (2, "sweep SAT initializing environment of %d", idx);
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	red = blit & REDCS;
+	if (tag == BINCS) {
+	  if (!red && sweepirr < 1) continue;
+	  if (red && sweepred < 1) continue;
+	  other = blit >> RMSHFT;
+	  lglsweepsatinitlit (lgl, other, a, b);
+	} else if (tag == TRNCS) {
+	  if (!red && sweepirr < 2) continue;
+	  if (red && sweepred < 2) continue;
+	  other = blit >> RMSHFT;
+	  lglsweepsatinitlit (lgl, other, a, b);
+	  other2 = *p;
+	  lglsweepsatinitlit (lgl, other2, a, b);
+	} else {
+	  assert (tag == LRGCS);
+	  if (!red && sweepirr < 3) continue;
+	  if (red && sweepred < 3) continue;
+	  lidx = *p;
+	  c = lglidx2lits (lgl, red, lidx);
+	  for (l = c; (other = *l); l++)
+	    lglsweepsatinitlit (lgl, other, a, b);
+	}
+      }
+    }
+    count = lglcntstk (&lgl->swp->decision.stk) - old;
+    LOG (2, "sweep SAT environment of %d contains %d decisions", idx, count);
+    (void) count;
+  }
+  for (p = lgl->swp->decision.stk.start; p < lgl->swp->decision.stk.top; p++)
+    lglavar (lgl, *p)->mark = 0;
+  lgl->swp->decision.cached.a = a;
+  lgl->swp->decision.cached.b = b;
+  count = lglcntstk (&lgl->swp->decision.stk);
+  SORT (int, lgl->swp->decision.stk.start, count, LGLCMPSWPDEC);
+DONE:
+  LOG (2,
+    "sweep SAT environment of %d and %d, contains %d decisions",
+    a, b, count);
+  lgl->swp->sumsize.envs += count;
+  lgl->stats->sweep.sumsize.envs += count;
+}
+
+static int lglsweepdec (LGL * lgl) {
+  int i, lit = 0;
+  for (i = 0; i < lglcntstk (&lgl->swp->decision.stk); i++) {
+    lit = lglpeek (&lgl->swp->decision.stk, i);
+    if (!lglval (lgl, lit)) break;
+  }
+  if (i == lglcntstk (&lgl->swp->decision.stk)) {
+    LOG (2, "no sweep implication decision left");
+    return 0;
+  }
+  LOG (2,
+    "sweep typed %d implication check decision %d score %s",
+    lgl->swp->type, lit, lglscr2str (lgl, lglqvar (lgl, lit)->score));
+  lgliassume (lgl, lit);
+  lgl->swp->decision.count++;
+  lgl->stats->sweep.decs++;
+  return 1;
+}
+
+static int lglsweepsat (LGL * lgl, int lim, int a, int b) {
+  int n = 0, aval, bval;
+  assert (lgl->level == 2);
+  lgl->stats->sweep.sat++;
+  lgl->swp->sat++;
+  LOG (2,
+    "deep sweep implication SAT check %d/%d decision limit %d",
+    lgl->swp->sat, lgl->stats->sweep.sat, lim);
+  for (;;) {
+    if (lglbcp (lgl)) {
+      if (lgl->mt) return 0;
+      if ((aval = lglval (lgl, a)) < 0) return 0;
+      if ((bval = lglval (lgl, b)) > 0) return 0;
+      if (!aval) {
+	assert (!lgl->level);
+	lgliassume (lgl, a);
+	lgl->swp->decision.count++;
+	lgl->stats->sweep.decs++;
+	continue;
+      }
+      LOG (2, 
+	"sweep typed %d assumption %d score %s",
+	lgl->swp->type, a, lglscr2str (lgl, lglqvar (lgl, a)->score));
+      if (!bval) {
+	assert (lgl->level <= 1);
+	lgliassume (lgl, -b);
+	lgl->swp->decision.count++;
+	lgl->stats->sweep.decs++;
+	continue;
+      }
+      LOG (2, 
+	"sweep typed %d assumption %d score %s",
+	lgl->swp->type, b, lglscr2str (lgl, lglqvar (lgl, b)->score));
+      assert (lglval (lgl, a) > 0), assert (lglval (lgl, b) < 0);
+      if (++n > lim) {
+	LOG (2, "deep sweep SAT checking decision limit %d reached", lim);
+	return 1;
+      }
+      if (!lglsweepdec (lgl)) return 1;
+    } else if (!lglana (lgl)) return 0;
+  }
+}
+
+static int lglsweepliesaux (LGL * lgl, int a, int b) {
+  int ok, val, res, dec;
+  assert (!lgl->level);
+  if (lgl->mt) return 0;
+  if (lglifixed (lgl, a)) return 0;
+  if (lglifixed (lgl, b)) return 0;
+  lgliassume (lgl, a);
+  ok = lglbcp (lgl);
+  if (ok) {
+    assert (lgl->level == 1);
+    val = lglval (lgl, b);
+    if (val > 0) {
+      lglbacktrack (lgl, 0);
+      LOG (1, "sweep implication check %d -> %d subsumed by BCP", a, b);
+      res = 1;
+    } else if (val < 0) {
+      LOG (1, "sweep implication check %d -> %d incompatible with BCP", a, b);
+      res = 0;
+    } else {
+      lgliassume (lgl, -b);
+      ok = lglbcp (lgl);
+      if (ok) {
+	dec = lgl->stats->sweep.count - 1;
+	dec *= lgl->opts->sweepfacdec.val;
+	if (dec < lgl->opts->sweepmindec.val)
+	  dec = lgl->opts->sweepmindec.val;
+	if (dec > lgl->opts->sweepmaxdec.val)
+	  dec = lgl->opts->sweepmaxdec.val;
+	if (dec) {
+	  lglsweepsatinit (lgl, a, b);
+	  ok = lglsweepsat (lgl, dec, a, b);
+	  if (ok) {
+	    LOG (1, "deep sweep implication check %d -> %d failed", a, b);
+	    res = 0;
+	  } else {
+	    lgl->stats->sweep.unsat++;
+	    LOG (1, "deep sweep implication check %d -> %d succeeded", a, b);
+	    if (lgl->level) lglbacktrack (lgl, 0);
+	    res = 1;
+	  }
+	} else {
+	  LOG (2, "skipping sweep implication SAT check");
+	  res = 0;
+	}
+      } else {
+	LOG (1, "shallow sweep implication check %d -> %d succeeded", a, b);
+	lglbacktrack (lgl, 0);
+	lgladdsweepbincls (lgl, -a, b);
+	lgl->stats->sweep.impls++;
+	res = 1;
+      }
+    }
+  } else {
+    lglbacktrack (lgl, 0);
+    LOG (1, "failed literal %d during sweep implication check", a);
+    lgl->stats->sweep.failed++;
+    lglunit (lgl, -a);
+    if (!lglbcp (lgl)) {
+      LOG (1, "empty clause propagating unit in sweep implication check");
+      lglmt (lgl);
+    }
+    res = 0;
+  }
+  return res;
+}
+
+static int lglsweeplies (LGL * lgl, int a, int b) {
+  int res = lglsweepliesaux (lgl, a, b);
+  if (!res) lgl->stats->sweep.queries.type[lgl->swp->type].sat++;
+  else lgl->stats->sweep.queries.type[lgl->swp->type].unsat++;
+  lglprt (lgl, 2,
+    "[sweep-%d-%d-%d] implication check %s",
+    lgl->stats->sweep.count, lgl->swp->round, lgl->swp->query,
+    res ? "succeeded" : "failed");
+  return res;
+}
+
+static void lglsweepquery (LGL * lgl) {
+  int count = lglcntstk (&lgl->swp->partition), l, r, size;
+  int p, q, a, b, i, c, newpartitions, newsize, newtotal;
+  int total = count - lgl->swp->partitions, remove, val;
+  int * partition = lgl->swp->partition.start;
+  int minsize, best, start, bestscore;
+  Stk newpartition;
+  switch (lgl->swp->query % 5) {
+    case 1: lgl->swp->type = 2; break;	// score
+    case 2: lgl->swp->type = 1; break;	// size
+    case 3: lgl->swp->type = 2; break;	// score
+    case 4: lgl->swp->type = 1; break;	// size
+    case 0: lgl->swp->type = 0; break;	// random
+  }
+  lgl->stats->sweep.queries.total++;
+  lgl->stats->sweep.queries.type[lgl->swp->type].count++;
+  assert (count > 0);
+  lglprt (lgl, 2,
+    "[sweep-%d-%d-%d] %d classes with %d vars of avg size %.1f",
+    lgl->stats->sweep.count, lgl->swp->round, lgl->swp->query,
+    lgl->swp->partitions, total, lglsweepavgpartitionsize (lgl));
+
+  l = lglrand (lgl) % count;
+  if (!partition[l]) { assert (l > 0); l--; }
+  while (l > 0 && partition[l-1])
+    l--;
+  if (lgl->swp->type == 1) {		// min size partition
+    INCSTEPS (sweep.steps);
+    best = start = l;
+    minsize = INT_MAX;
+    do {
+      assert (l < count);
+      INCSTEPS (sweep.steps);
+      size = 0;
+      for (r = l; (a = partition[r]); r++) {
+	COVER (lglifixed (lgl, a));
+	if (lglifixed (lgl, a)) continue;
+	size++;
+      }
+      if (size < minsize) best = l, minsize = size;
+      if ((l = r + 1) == count) l = 0;
+    } while (l != start);
+    l = best;
+  } else if (lgl->swp->type == 2) {	// best score partition
+    INCSTEPS (sweep.steps);
+    best = start = l;
+    bestscore = 0;
+    do {
+      assert (l < count);
+      INCSTEPS (sweep.steps);
+      for (r = l; (a = partition[r]); r++) {
+	if (lglifixed (lgl, a)) continue;
+	if (bestscore && lgldcmp (lgl, a, bestscore) < 0) continue;
+	best = l, bestscore = a;
+      }
+      if ((l = r + 1) == count) l = 0;
+    } while (l != start);
+    l = best;
+  } else assert (lgl->swp->type == 0);	// random partition
+  INCSTEPS (sweep.steps);
+  for (r = l; partition[r]; r++)
+    ;
+  size = r - l;
+  assert (1 < size), assert (size < count);
+  lgl->swp->sumsize.classes += size;
+  lgl->stats->sweep.sumsize.classes += size;
+  lglprt (lgl, 2,
+    "[sweep-%d-%d-%d] "
+    "type %d picked size %d class [%d:%d] %.1f%%",
+    lgl->stats->sweep.count, lgl->swp->round, lgl->swp->query,
+    lgl->swp->type, size, l, r-1, lglpcnt (size, total));
+  assert (size >= 2);
+  p = lglrand (lgl) % size;
+  q = lglrand (lgl) % size;
+  if (p == q) q = !p;
+  if (p + q >= size) q = p + q - size;
+  p += l, assert (l <= p), assert (p < r);
+  q += l, assert (l <= p), assert (q < r);
+  assert (p != q);
+  a = partition [p];
+  b = partition [q];
+  for (i = l; i < r; i++) {
+    if (i == p) continue;
+    if (i == q) continue;
+    c = partition[i];
+    if (lgldcmp (lgl, c, a) > 0) a = c, p = i;
+  }
+  for (i = l; i < r; i++) {
+    if (i == p) continue;
+    if (i == q) continue;
+    c = partition[i];
+    if (lgldcmp (lgl, c, b) > 0) b = c, q = i;
+  }
+  assert (a), assert (b);
+  assert (abs (a) != abs (b));
+  LOG (2,
+    "picked literal pair %d and %d at position %d and %d",
+    a, b, p, q);
+  assert (!lgl->level);
+  if (lglsweeplies (lgl, a, b) && lglsweeplies (lgl, b, a)) {
+    assert (!lgl->level);
+    lgl->stats->sweep.equivs++;
+    remove = b;
+    LOG (2,
+      "found equivalence between %d and %d and will remove %d",
+      a, b, b);
+  } else remove = 0;
+  CLR (newpartition);
+  newsize = newpartitions = 0;
+  if (!lgl->mt) {
+    for (val = -1; val <= 1; val++) {
+      for (i = 0; i < count; i++) {
+	if ((c = partition[i])) {
+	  if (c == remove) continue;
+	  if (lglifixed (lgl, c)) continue;
+	  if (lglval (lgl, c) != val) continue;
+	  lglpushstk (lgl, &newpartition, c);
+	  newsize++;
+	} else if (newsize > 1) {
+	  lglpushstk (lgl, &newpartition, 0);
+	  newpartitions++;
+	  newsize = 0;
+	} else if (newsize) {
+	  assert (newsize == 1);
+	  (void) lglpopstk (&newpartition);
+	  newsize = 0;
+	}
+      }
+    }
+    ADDSTEPS (sweep.steps, (count >> 3));
+  }
+  assert (!newsize);
+  assert (!newpartitions || !newpartition.top[-1]);
+  newtotal = lglcntstk (&newpartition) - newpartitions;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  if (lgl->swp->partitions >= newpartitions)
+    lglprt (lgl, 2,
+      "[sweep-%d-%d-%d] removed %d literals and removed %d classes",
+      lgl->stats->sweep.count, lgl->swp->round, lgl->swp->query,
+      total - newtotal, lgl->swp->partitions - newpartitions);
+  else
+    lglprt (lgl, 2,
+      "[sweep-%d-%d-%d] removed %d literals and added %d classes",
+      lgl->stats->sweep.count, lgl->swp->round, lgl->swp->query,
+      total - newtotal, newpartitions - lgl->swp->partitions);
+  lgl->swp->partitions = newpartitions;
+  lglfitstk (lgl, &newpartition);
+  lglrelstk (lgl, &lgl->swp->partition);
+  lgl->swp->partition = newpartition;
+}
+
+static void lglsetsweeplim (LGL * lgl) {
+  int count = lgl->stats->sweep.count - lgl->opts->sweepboostdel.val;
+  int64_t limit, irrlim;
+  int pen, szpen;
+  if (lgl->opts->sweeprtc.val > 1) {
+    lgl->limits->sweep.steps = LLMAX;
+    lglprt (lgl, 1,
+      "[sweep-%d] really no limit (run to completion)", 
+      lgl->stats->sweep.count);
+  } else if (lgl->opts->sweeprtc.val ||
+	     lgl->opts->prbrtc.val ||
+	     (count > 0 &&
+	      lglrem (lgl) < lgl->opts->sweeprtcintvlim.val &&
+	      !(count % lgl->opts->sweeprtcint.val))) {
+    limit = 4000000000ll;
+    lgl->limits->sweep.steps = lgl->stats->sweep.steps + limit;
+    lglprt (lgl, 1,
+      "[sweep-%d] almost no limit of %lld steps", 
+      lgl->stats->sweep.count, (LGLL) limit);
+  } else {
+    limit = (lgl->opts->sweepreleff.val*lglvisearch (lgl))/1000;
+    if (limit < lgl->opts->sweepmineff.val)
+      limit = lgl->opts->sweepmineff.val;
+    if (lgl->opts->sweepmaxeff.val >= 0 &&
+	limit > lgl->opts->sweepmaxeff.val)
+      limit = lgl->opts->sweepmaxeff.val;
+    if (count > 0 &&
+        (count <= 1 || !(count % lgl->opts->sweepboostint.val)) &&
+	lglrem (lgl) < lgl->opts->sweepboostvlim.val &&
+        lgl->opts->boost.val &&
+        lgl->opts->sweepboost.val > 1) {
+      lglprt (lgl, 1,
+	"[sweep-%d] boosting sweeping limit by %d",
+	lgl->stats->sweep.count, lgl->opts->sweepboost.val);
+      limit *= lgl->opts->sweepboost.val;
+    }
+    limit >>= (pen = lgl->limits->sweep.pen + (szpen = lglszpen (lgl)));
+    irrlim = (2*lgl->stats->irr.clauses.cur) >> szpen;
+    if (lgl->opts->irrlim.val && limit < irrlim) {
+      limit = irrlim;
+      lglprt (lgl, 1,
+	"[sweep-%d] limit %lld based on %d irredundant clauses penalty %d",
+	lgl->stats->sweep.count,
+	(LGLL) limit, lgl->stats->irr.clauses.cur, szpen);
+    } else
+      lglprt (lgl, 1,
+        "[sweep-%d] limit %lld penalty %d = %d + %d",
+	lgl->stats->sweep.count, (LGLL) limit,
+	pen, lgl->limits->sweep.pen, szpen);
+    lgl->limits->sweep.steps = lgl->stats->sweep.steps + limit;
+  }
+}
+
+static void lglsweepretain (LGL * lgl) {
+  int idx, ret = 0, rem = 0, sum;
+  const int * p;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    lglavar (lgl, idx)->donotsweep = 1;
+  for (p = lgl->swp->partition.start;
+       p < lgl->swp->partition.top;
+       p++) {
+    if(!(idx = *p)) continue;
+    lglavar (lgl, idx)->donotsweep = 0;
+  }
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    if (lglavar (lgl, idx)->donotsweep) ret++; else rem++;
+  }
+  if (rem) {
+    sum = rem + ret;
+    lglprt (lgl, 1,
+      "[sweep-%d-%d] %d variables remain %.0f%% (%d retained %.0f%%)",
+      lgl->stats->sweep.count, lgl->swp->round,
+      rem, lglpcnt (rem, sum),
+      ret, lglpcnt (ret, sum));
+  } else {
+    lglprt (lgl, 1,
+      "[sweep-%d-%d] fully completed sweeping round",
+      lgl->stats->sweep.count, lgl->swp->round);
+    for (idx = 2; idx < lgl->nvars; idx++)
+      lglavar (lgl, idx)->donotsweep = 0;
+    lgl->sweeprtc = 1;
+  }
+}
+
+static int lglsweep (LGL * lgl) {
+  int deltarem, deltafailed, deltaimpls, deltaequivs, deltaorigrem;
+  int round, origrem, oldrem, oldfailed, oldimpls, oldequivs;
+  int64_t oldsteps, deltasteps, origqueries, deltaqueries;
+  int success, forgive;
+  lglstart (lgl, &lgl->times->sweep);
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  assert (!lgl->simp), assert (!lgl->sweeping);
+  lgl->simp = lgl->sweeping = 1;
+  if (!lglbcp (lgl)) goto DONE;
+  lglgc (lgl);
+  if (lgl->mt) goto DONE;
+  lgl->stats->sweep.count++;
+  lglsetsweeplim (lgl);
+  origrem = lglrem (lgl);
+  origqueries = lgl->stats->sweep.queries.total;
+  round = 0;
+  forgive = lgl->opts->sweepforgive.val;
+RESTART:
+  round++; 
+  lgl->stats->sweep.rounds++;
+  oldrem = lglrem (lgl);
+  oldfailed = lgl->stats->sweep.failed;
+  oldimpls = lgl->stats->sweep.impls;
+  oldequivs = lgl->stats->sweep.equivs;
+  oldsteps = lgl->stats->sweep.steps;
+  assert (!lgl->swp);
+  NEW (lgl->swp, 1);
+  lgl->swp->round = round;
+  lglinitsweep (lgl);
+  for (lgl->swp->query = 1;
+    !lgl->mt &&
+      !lglmtstk (&lgl->swp->partition) &&
+      lgl->stats->sweep.steps <= lgl->limits->sweep.steps;
+    lgl->swp->query++)
+    lglsweepquery (lgl);
+  deltasteps = lgl->stats->sweep.steps - oldsteps;
+  lglprt (lgl, 1,
+    "[sweep-%d-%d] %lld steps %d queries %.2f avg class size",
+    lgl->stats->sweep.count, round,
+    (LGLL) deltasteps, lgl->swp->query,
+      lglavg (lgl->swp->sumsize.classes, lgl->swp->query));
+  lglprt (lgl, 1,
+    "[sweep-%d-%d] %d decisions %d SAT calls %.2f avg env size",
+    lgl->stats->sweep.count, round,
+    lgl->swp->decision.count, lgl->swp->sat,
+      lglavg (lgl->swp->sumsize.envs, lgl->swp->sat));
+  lglrelstk (lgl, &lgl->swp->decision.stk);
+  lglsweepretain (lgl);
+  lglrelstk (lgl, &lgl->swp->partition);
+  if (!lgl->mt) lgldecomp (lgl);
+  assert (lgl->swp->round == round);
+  DEL (lgl->swp, 1);
+  lgl->swp = 0;
+  deltarem = oldrem - lglrem (lgl);
+  deltafailed = lgl->stats->sweep.failed - oldfailed;
+  deltaimpls = lgl->stats->sweep.impls - oldimpls;
+  deltaequivs = lgl->stats->sweep.equivs - oldequivs;
+  lglprt (lgl, 1,
+    "[sweep-%d-%d] removed %d vars (%d failed, %d eqs, %d impls)",
+    lgl->stats->sweep.count, round,
+    deltarem, deltafailed, deltaequivs, deltaimpls);
+  if ((deltarem || forgive > 0) &&
+      !lgl->mt &&
+      (lgl->opts->sweepmaxround.val < 0 ||
+       round < lgl->opts->sweepmaxround.val) &&
+      lgl->stats->sweep.steps <= lgl->limits->sweep.steps) {
+    if (deltarem) forgive = lgl->opts->sweepforgive.val; else forgive--;
+    goto RESTART;
+  }
+  deltaorigrem = origrem - lglrem (lgl);
+  if (!lgl->sweeprtc &&
+      lgl->stats->sweep.count <= lgl->opts->sweepsuccessmaxwortc.val) {
+    success = 1;
+    lglprt (lgl, 1,
+      "[sweep-%d] considered successful since not run to completion yet",
+      lgl->stats->sweep.count);
+  } else if (deltaorigrem) {
+    success = (origrem/lgl->opts->sweepsuccessrat.val <= deltaorigrem);
+    if (!success)
+      lglprt (lgl, 1,
+	"[sweep-%d] %d < 1/%d * %d = %d considered unsuccessful",
+	lgl->stats->sweep.count, deltaorigrem, lgl->opts->sweepsuccessrat.val,
+	origrem, origrem/lgl->opts->sweepsuccessrat.val);
+  } else success = 0;
+  LGLUPDPEN (sweep, success);
+  deltaqueries = lgl->stats->sweep.queries.total - origqueries;
+  lglprt (lgl, 1,
+    "[sweep-%d] removed %d vars in TOTAL (%d rounds, %lld queries)",
+    lgl->stats->sweep.count, deltaorigrem, round, (LGLL) deltaqueries);
+DONE:
+  assert (lgl->simp), assert (lgl->sweeping);
+  lgl->simp = lgl->sweeping = 0;
+  lglstop (lgl);
+  return !lgl->mt;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglqcmp (LGL * lgl, int a, int b) {
+  Flt ascore, bscore, pos, neg;
+  QVar * p = lglqvar (lgl, a);
+  QVar * q = lglqvar (lgl, b);
+  if (!p->important && q->important) return -1;
+  if (p->important && !q->important) return 1;
+  pos = lgl->jwh[lglulit (a)];
+  neg = lgl->jwh[lglulit (-a)];
+  ascore = lglmulflt (pos, neg);
+  pos = lgl->jwh[lglulit (b)];
+  neg = lgl->jwh[lglulit (-b)];
+  bscore = lglmulflt (pos, neg);
+  if (ascore < bscore) return -1;
+  if (ascore > bscore) return 1;
+  return a - b;
+}
+
+#define LGLQCMP(A,B) lglqcmp (lgl, *(A), *(B))
+
+static void lglqueuesort (LGL * lgl) {
+  int count, i, lit;
+  QVar * qv;
+  lglstart (lgl, &lgl->times->queuesort);
+  if (lgl->queue.mt) lglqueueflush (lgl);
+  lgl->stats->queue.sorted++;
+  assert (!lgl->queue.mt);
+  count = lglcntstk (&lgl->queue.stk);
+  assert (count > 0);
+  SORT (int, lgl->queue.stk.start, count, LGLQCMP);
+  for (i = 0; i < count; i++) {
+    lit = lglpeek (&lgl->queue.stk, i);
+    qv = lglqvar (lgl, lit);
+    assert (qv->enqueued);
+    assert (qv->pos >= 0);
+    qv->pos = i;
+  }
+  lglprt (lgl, 2,
+    "[sort-queue-%d] sorted %d after %lld conflicts and %lld flushed queues",
+    (LGLL) lgl->stats->queue.sorted, count,
+    (LGLL) lgl->stats->confs, (LGLL) lgl->stats->queue.flushed);
+  lgl->queue.next = count - 1;
+  lglstop (lgl);
+}
+
+static int lglqueuesorting (LGL * lgl) {
+  int count = lglcntstk (&lgl->queue.stk);
+  assert (lgl->queue.mt <= count);
+  if (lgl->queue.mt >= count) return 0;
+  return lgl->opts->queuesort.val;
+}
+
+/*------------------------------------------------------------------------*/
+
+#define LGLCMPSCR(A,B) lglscrcmp (lgl, *(A), *(B))
+
+static void lglshowscoredist (LGL * lgl) {
+  int idx, pos = 0, zero = 0, min = 0, sum = 0, diff;
+  Flt * scores;
+  QVar * q;
+  lglstart (lgl, &lgl->times->showscoredist);
+  NEW (scores, lgl->nvars);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (!lglisfree (lgl, idx)) continue;
+    q = lglqvar (lgl, idx);
+    if (q->score == FLTMIN) zero++;
+    else if (q->score <= lgl->minscore) min++;
+    else pos++;
+    scores[sum++] = q->score;
+  }
+  lglprt (lgl, 1, 
+    "[score-distribution-%d] "
+    "%d pos %.2f%%, %d min %.2f%%, %d zero %.2f%%",
+    lgl->stats->simp.count,
+    pos, lglpcnt (pos, sum),
+    min, lglpcnt (min, sum),
+    zero, lglpcnt (zero, sum));
+  SORT (Flt, scores, sum, LGLCMPSCR);
+  diff = 0;
+  for (idx = 0; idx < sum; idx++)
+    if (!idx || lglscrcmp (lgl, scores[idx-1], scores[idx])) diff++;
+  DEL (scores, lgl->nvars);
+  lglprt (lgl, 1, 
+    "[score-distribution-%d] "
+    "%d different %.2f%% out of total %d variables",
+    lgl->stats->simp.count,
+    diff, lglpcnt (diff, sum),
+    sum);
+  lglstop (lgl);
+}
+
+static Features lglfeatures (LGL * lgl) {
+  int idx, sign, lit, blit, tag, red, other, other1, len, lrg;
+  const int * p, * w, * eow, * c;
+  HTS * hts;
+  Features res;
+  CLR (res);
+  res.n = lgl->stats->features;
+  res.s = lglsec (lgl);
+  res.vo = lgl->limits->inc.vars.start;
+  res.vc = lglrem (lgl);
+  res.co = lgl->limits->inc.clauses.start;
+  res.cc = lgl->stats->irr.clauses.cur;
+  res.x = lgl->stats->gauss.extracted.last;
+  res.a1 = lgl->stats->card.found.am1.last.cnt;
+  res.a2 = lgl->stats->card.found.am2.last.cnt;
+  res.c = lgl->stats->confs / 1000;
+  res.o = lgl->stats->otfs.total / 1000;
+  res.g = lgl->stats->glue.slow.val >> 32;
+  res.j = lgl->stats->jlevel.slow.val >> 32;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	red = blit & REDCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (red || tag == LRGCS) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	if (tag == BINCS) {
+	  res.b++;
+	} else {
+	  assert (tag == TRNCS);
+	  other1 = *p;
+	  if (abs (other1) < idx) continue;
+	  res.t++;
+	}
+      }
+    }
+  lrg = 0;
+  for (c = lgl->irr.start; c < lgl->irr.top; c = p + 1) {
+    if (*(p = c) >= REMOVED) continue;
+    while (*++p)
+      ;
+    len = p - c;
+    if (len <= 4) res.q++;
+    else if (len <= 10) res.c1++;
+    else if (len <= 100) res.c2++;
+    else if (len <= 1000) res.c3++;
+    else if (len <= 10000) res.c4++;
+    else lrg++;
+  }
+  assert (res.b + res.t + res.q + 
+          res.c1 + res.c2 + res.c3 + res.c4 + lrg == res.cc);
+  return res;
+}
+
+static int lglintstrlen (int i) {
+  assert (i >= 0);
+  if (i < 10) return 1;
+  if (i < 100) return 2;
+  if (i < 1000) return 3;
+  if (i < 10000) return 4;
+  if (i < 100000) return 5;
+  if (i < 1000000) return 6;
+  if (i < 10000000) return 7;
+  if (i < 100000000) return 8;
+  if (i < 1000000000) return 9;
+  return 10;
+}
+
+#ifdef LGLSC14CLASSIFY
+#include "sc14classify/sc14classify.h"
+static int lglsetoptif (
+  LGL * lgl, const char * a, const char * b,
+  const char * opt, int val) {
+  if (strcmp (a, b)) return 0;
+  lglprt (lgl, 1,
+    "[classify-%d] setting '--%s=%d' since assuming '%s' bucket",
+    lgl->stats->features, opt, val, a);
+  lglsetopt (lgl, opt, val);
+  return 1;
+}
+#endif
+
+static void lglshowfeatures (LGL * lgl) {
+  int size[NFEATURES], i;
+  const int * p;
+  char fmt[20];
+  Features f;
+  if (!lgl->opts->features.val) return;
+  if (lgl->opts->verbose.val <= 0) return;
+  if (lgl->stats->features >= lgl->opts->features.val) return;
+  lglstart (lgl, &lgl->times->showfeatures);
+  f = lglfeatures (lgl);
+  p = (int*) &f;
+  for (i = 0; i < NFEATURES; i++)
+    size[i] = lglmax (strlen (featurenames[i]), lglintstrlen (p[i]));
+
+  lglmsgstart (lgl, 0);
+  fprintf (lgl->out, "[heatures-%d]", f.n);
+  for (i = 0; i < NFEATURES; i++) {
+    sprintf (fmt, " %%%ds",  size[i]);
+    fprintf (lgl->out, fmt, featurenames[i]);
+  }
+  lglmsgend (lgl);
+
+  lglmsgstart (lgl, 0);
+  fprintf (lgl->out, "[features-%d]", f.n);
+  for (i = 0; i < NFEATURES; i++) {
+    sprintf (fmt, " %%%dd",  size[i]);
+    fprintf (lgl->out, fmt, p[i]);
+  }
+  lglmsgend (lgl);
+
+#ifdef LGLSC14CLASSIFY
+  if (lgl->opts->classify.val && lgl->stats->features == 1) {
+    const char * bucket =
+      sc14classify (
+	f.vo, f.vc, f.co, f.cc, f.b, f.t, f.q,
+	f.c1, f.c2, f.c3, f.c4, f.x, f.a1, f.a2, f.g, f.j, f.c, f.o);
+    lglprt (lgl, 1,
+      "[classify-%d] classified as SAT Competition 2014 bucket '%s'",
+      f.n, bucket);
+    lglsetoptif (lgl, bucket, "2d-strip-packing", "block", 0),
+      lglsetoptif (lgl, bucket, "2d-strip-packing", "cce", 0);
+    lglsetoptif (lgl, bucket, "argumentation", "sweeprtc", 1);
+    lglsetoptif (lgl, bucket, "crypto-aes", "restartint", 1000);
+    lglsetoptif (lgl, bucket, "crypto-sha", "restartint", 100);
+    lglsetoptif (lgl, bucket, "crypto-vpmc", "restartint", 4);
+    lglsetoptif (lgl, bucket, "hardware-cec", "sweeprtc", 1);
+    lglsetoptif (lgl, bucket, "hardware-velev", "block", 0),
+      lglsetoptif (lgl, bucket, "hardware-velev", "cce", 0);
+    lglsetoptif (lgl, bucket, "scheduling", "restartint", 1000);
+    if (lgl->opts->classify.val < 2) goto DO_NOT_COMBINE_OPTIONS;
+    lglsetoptif (lgl, bucket, "2d-strip-packing", "restartint", 1000);
+    lglsetoptif (lgl, bucket, "2d-strip-packing", "scincinc", 50);
+    lglsetoptif (lgl, bucket, "2d-strip-packing", "sweeprtc", 1);
+    lglsetoptif (lgl, bucket, "bio", "restartint", 1000);
+    lglsetoptif (lgl, bucket, "crypto-des", "restartint", 100);
+    lglsetoptif (lgl, bucket, "crypto-md5", "restartint", 1000);
+    lglsetoptif (lgl, bucket, "crypto-vmpc", "sweeprtc", 1);
+    lglsetoptif (lgl, bucket, "hardware-cec", "restartint", 4);
+    lglsetoptif (lgl, bucket, "hardware-cec", "scincincmin", 250);
+    lglsetoptif (lgl, bucket, "software-bmc", "elmresched", 7);
+    lglsetoptif (lgl, bucket, "software-bmc", "phase", -1);
+    if (lgl->opts->classify.val < 3) goto DO_NOT_COMBINE_OPTIONS;
+    lglsetoptif (lgl, bucket, "crypto-sha", "sweeprtc", 1);
+    lglsetoptif (lgl, bucket, "diagnosis", "elmresched", 7);
+    lglsetoptif (lgl, bucket, "planning", "reducefixed", 1),
+      lglsetoptif (lgl, bucket, "planning", "reduceinit", 10000);
+    lglsetoptif (lgl, bucket, "scheduling", "block", 0),
+      lglsetoptif (lgl, bucket, "scheduling", "cce", 0);
+    lglsetoptif (lgl, bucket, "scheduling", "elmresched", 7);
+    lglsetoptif (lgl, bucket, "scheduling", "scincinc", 50);
+DO_NOT_COMBINE_OPTIONS:
+    ;
+  }
+#endif
+  lgl->stats->features++;
+  lglstop (lgl);
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglisimp (LGL * lgl) {
+  if (!lgl->opts->simplify.val) return 1;
+
+  if (lglquatresolving (lgl)) lglquatres (lgl);
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglternresolving (lgl) && !lglternres (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglcarding (lgl) && !lglcard (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglgaussing (lgl) && !lglgauss (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lgldecomposing (lgl) && !lgldecomp (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglprobing (lgl) && !lglprobe (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglunhiding (lgl) && !lglunhide (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lgltreducing (lgl) && !lgltrd (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglblocking (lgl)) lglblock (lgl);
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglcceing (lgl) && !lglcce (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lgleliminating (lgl) && !lglelim (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (!lgltopgc (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglbcaing (lgl)) lglbca (lgl);
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglsweeping (lgl) && !lglsweep (lgl)) return 0;
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (!lgl->allphaseset) lglphase (lgl);
+  if (lglterminate (lgl)) return 1;
+  assert (!lgl->mt);
+
+  if (lglqueuesorting (lgl)) lglqueuesort (lgl);
+  if (lglterminate (lgl)) return 1;
+
+  lgldefrag (lgl);
+  if (lglterminate (lgl)) return 1;
+
+  lglshowscoredist (lgl);
+  lglshowfeatures (lgl);
+
+  return 1;
+}
+
+static void lglupdsimpcinc (LGL * lgl, int red, int success) {
+  const char * type = "no";
+  int inc = 0, div = 1, res;
+  assert (red >= 0);
+  if (red <= 100) {
+    if (red > 0) {
+      switch (lgl->opts->simpcintincdiv.val) {
+	case 3: 
+	  if (red >= 50) div = 4;
+	  else if (red >= 20) div = 3;
+	  else if (red >= 10) div = 2;
+	  break;
+	case 2: div = red/2 + 1; break;
+	case 1: div = red/1 + 1; break;
+	case 0:
+	default: 
+          assert (!lgl->opts->simpcintincdiv.val);
+	  break;
+      }
+    }
+    inc = lgl->opts->simpcintinc.val;
+    if (lgl->opts->simplify.val == 1) {
+      type = "arithmetic";
+    } else if (lgl->opts->simplify.val == 2) {
+      if (inc < lgl->limits->simp.cinc) inc = lgl->limits->simp.cinc;
+      type = "geometric";
+    } else inc = 0;
+  }
+  res = inc / div;
+  if (lgl->limits->simp.cinc - res <= INT_MAX)
+    lgl->limits->simp.cinc += res;
+  lglprt (lgl, 2,
+    "[simplification-%d] new lgl->limits->simp.cinc %d",
+    lgl->stats->simp.count, lgl->limits->simp.cinc);
+  if (div > 1)
+    lglprt (lgl, 1,
+      "[simplification-%d] %s conflict interval increment %d = %d / %d",
+      lgl->stats->simp.count, type, res, inc, div);
+  else
+    lglprt (lgl, 1,
+      "[simplification-%d] full %s conflict interval increment %d",
+      lgl->stats->simp.count, type, res);
+
+  if (success &&
+      lgl->opts->simpcintmaxsoft.val >= 0 &&
+      lgl->limits->simp.cinc >= lgl->opts->simpcintmaxsoft.val) {
+    lgl->limits->simp.cinc = lgl->opts->simpcintmaxsoft.val;
+    lglprt (lgl, 1,
+      "[simplification-%d] "
+      "conflict interval soft limit %d reached",
+      lgl->stats->simp.count, lgl->limits->simp.cinc);
+  } else if (lgl->opts->simpcintmaxhard.val >= 0 &&
+             lgl->limits->simp.cinc >= lgl->opts->simpcintmaxhard.val) {
+    lgl->limits->simp.cinc = lgl->opts->simpcintmaxhard.val;
+    lglprt (lgl, 1,
+      "[simplification-%d] "
+      "conflict interval hard limit %d reached",
+      lgl->stats->simp.count, lgl->limits->simp.cinc);
+  }
+}
+
+static void lglsethardsimplim (LGL * lgl) {
+  int64_t hard, delta;
+  delta = lgl->limits->simp.confs - lgl->stats->confs;
+  if (delta < 0) delta = 0;
+  delta *= lgl->opts->simpincdelmaxfact.val;
+  delta /= 100;
+  if (delta < lgl->opts->simpincdelmaxmin.val)
+    delta = lgl->opts->simpincdelmaxmin.val;
+  if (LLMAX - delta < lgl->limits->simp.confs) hard = LLMAX;
+  else hard = lgl->limits->simp.confs + delta;
+  lgl->limits->simp.hard = hard;
+  lglprt (lgl, 1,	// TODO set this to 2
+    "[simplification-%d] hard conflict limit %lld (soft %lld + delta %lld)",
+    lgl->stats->simp.count,
+    (LGLL) lgl->limits->simp.hard, (LGLL) lgl->limits->simp.confs, (LGLL) delta);
+}
+
+static void lglupdsimpint (LGL * lgl, int oldrem, int oldirr, int forced) {
+  int remvar, remirr, pcntred, simpcinc;
+  int64_t pcntremvar64, pcntremirr64;
+  int pcntremvar, pcntremirr;
+
+  remvar = oldrem - lglrem (lgl);
+  if (remvar < 0) remvar = 0;
+  pcntremvar64 = (remvar > 0) ? ((1000ll*remvar)/oldrem + 5)/10 : 0ll;
+  assert (pcntremvar64 <= 100);
+  pcntremvar = pcntremvar64;
+  lglprt (lgl, 1,
+    "[simplification-%d] removed %d variables %.1f%% "
+    "(%d remain %0.f%%)",
+    lgl->stats->simp.count, remvar, lglpcnt (remvar, oldrem),
+    lglrem (lgl), lglpcnt (lglrem (lgl), lgl->limits->inc.vars.start));
+
+  remirr = oldirr - lgl->stats->irr.clauses.cur;
+  if (remirr < 0) remirr = 0;
+  pcntremirr64 = (remirr > 0) ? ((1000ll*remirr)/oldirr + 5)/10 : 0ll;
+  assert (pcntremirr64 <= 100);
+  pcntremirr = pcntremirr64;
+  lglprt (lgl, 1,
+    "[simplification-%d] removed %d irredundant clauses %.1f%% "
+    "(%d remain %.0f%%)",
+    lgl->stats->simp.count, remirr, lglpcnt (remirr, oldirr),
+    lgl->stats->irr.clauses.cur,
+      lglpcnt (lgl->stats->irr.clauses.cur, lgl->limits->inc.clauses.start));
+
+  pcntred = lglmax (pcntremvar, pcntremirr);
+  lglprt (lgl, 1,
+    "[simplification-%d] maximum reduction of %d%% = max (%d%%, %d%%)",
+    lgl->stats->simp.count, pcntred, pcntremvar, pcntremirr);
+
+  if (forced) {
+    simpcinc = 0;
+    lglprt (lgl, 1,
+      "[simplification-%d] forced so keeping old conflict interval %d",
+      lgl->stats->simp.count, lgl->limits->simp.cinc);
+  } else if (lgl->stats->confs < lgl->limits->simp.confs &&
+             (simpcinc = lgl->limits->simp.cinc)) {
+    lglprt (lgl, 1,
+      "[simplification-%d] keeping old conflict interval %d "
+      "(non-conflict triggered simplification)",
+      lgl->stats->simp.count, lgl->limits->simp.cinc);
+  } else if (remvar > 0 && pcntred >= lgl->opts->simprtc.val) {
+    int64_t scaledcinc;
+    int factor;
+    lglprt (lgl, 1,
+      "[simplification-%d] large reduction %d%% >= %d%% limit",
+      lgl->stats->simp.count, pcntred, lgl->opts->simprtc.val);
+    factor = lgl->opts->simpidiv.val - lgl->stats->simp.count;
+    if (factor <= 0) factor = 1;
+    simpcinc = lgl->opts->simpcintdelay.val / factor;
+    scaledcinc = lgl->stats->confs/lgl->opts->simpiscale.val;
+    if (scaledcinc > lgl->limits->simp.cinc)
+      scaledcinc = lgl->limits->simp.cinc;
+    if (scaledcinc < simpcinc) {
+      lglprt (lgl, 1,
+	"[simplification-%d] next conflict interval %d = %d/%d",
+	lgl->stats->simp.count,
+	simpcinc, lgl->opts->simpcintdelay.val, factor);
+    } else {
+      assert (scaledcinc <= INT_MAX);
+      simpcinc = (int) scaledcinc;
+      lglprt (lgl, 1,
+	"[simplification-%d] next conflict interval %d = min (%lld/%d, %d)",
+	lgl->stats->simp.count,
+	simpcinc, (LGLL) lgl->stats->confs, lgl->opts->simpiscale.val,
+	lgl->limits->simp.cinc);
+    }
+  } else {
+    lglupdsimpcinc (lgl, pcntred, remvar || remirr);
+    simpcinc = lgl->limits->simp.cinc;
+    lglprt (lgl, 1,
+      "[simplification-%d] new conflict interval %d",
+      lgl->stats->simp.count, simpcinc);
+  }
+
+  if (forced) {
+    lglprt (lgl, 1,
+      "[simplification-%d] conflict limit remains at %lld (hard %lld)",
+      lgl->stats->simp.count,
+      (LGLL) lgl->limits->simp.confs, (LGLL) lgl->limits->simp.hard);
+  } else {
+    int penalty, pensimpcinc;
+         if (!lgl->opts->simpintsizepen.val ||
+	     lgl->stats->irr.clauses.cur <    1000000)    penalty = 1;
+    else if (lgl->stats->irr.clauses.cur <   10000000)    penalty = 2;
+    else /*  lgl->stats->irr.clauses.cur >=  10000000) */ penalty = 4;
+    if (INT_MAX/penalty < simpcinc) pensimpcinc = INT_MAX;
+    else pensimpcinc = penalty * simpcinc;
+    lglprt (lgl, 1,
+      "[simplification-%d] penalized conflict interval %d = %d * %d",
+      lgl->stats->simp.count, pensimpcinc, penalty, simpcinc);
+    assert (pensimpcinc >= 0);
+    lgl->limits->simp.confs = lgl->stats->confs + pensimpcinc;
+    assert (lgl->limits->simp.confs >= 0);
+    lglsethardsimplim (lgl);
+    lglprt (lgl, 1,
+      "[simplification-%d] new conflict limit %lld (hard %lld)",
+      lgl->stats->simp.count,
+      (LGLL) lgl->limits->simp.confs, (LGLL) lgl->limits->simp.hard);
+  }
+
+  if (lgl->stats->confs >= lgl->limits->simp.confs) {
+    lgl->limits->simp.confs = lgl->stats->confs + 1;
+    if (lgl->limits->simp.hard < lgl->limits->simp.confs)
+       lgl->limits->simp.hard = lgl->limits->simp.confs;
+    lglprt (lgl, 1,
+      "[simplification-%d] "
+      "fixed conflict limit %d (wait at least for one conflict)",
+      lgl->stats->simp.count, lgl->stats->confs);
+  }
+
+  if (forced == 1 &&
+      lgl->limits->simp.itinc < lgl->opts->simpitintinclim.val) {
+    if (lgl->limits->simp.itinc < INT_MAX/10) lgl->limits->simp.itinc *= 10;
+    else lgl->limits->simp.itinc = INT_MAX;
+    if (lgl->limits->simp.itinc > lgl->opts->simpitintinclim.val)
+      lgl->limits->simp.itinc = lgl->opts->simpitintinclim.val;
+    lglprt (lgl, 1,
+      "[simplification-%d] new iteration interval %d",
+      lgl->stats->simp.count, lgl->limits->simp.itinc);
+  }
+  lgl->limits->simp.its = lgl->stats->its.count + lgl->limits->simp.itinc;
+
+  if (forced == 2 &&
+      lgl->limits->simp.binc < lgl->opts->simpbintinclim.val) {
+    if (lgl->limits->simp.binc < INT_MAX/10) lgl->limits->simp.binc *= 10;
+    else lgl->limits->simp.binc = INT_MAX;
+    if (lgl->limits->simp.binc > lgl->opts->simpbintinclim.val)
+      lgl->limits->simp.binc = lgl->opts->simpbintinclim.val;
+    lglprt (lgl, 1,
+      "[simplification-%d] new binary interval %d",
+      lgl->stats->simp.count, lgl->limits->simp.binc);
+  }
+  lgl->limits->simp.bin = lgl->stats->bins + lgl->limits->simp.binc;
+
+  if (forced == 3 &&
+      lgl->limits->simp.tinc < lgl->opts->simptintinclim.val) {
+    if (lgl->limits->simp.tinc < INT_MAX/10) lgl->limits->simp.tinc *= 10;
+    else lgl->limits->simp.tinc = INT_MAX;
+    if (lgl->limits->simp.tinc > lgl->opts->simptintinclim.val)
+      lgl->limits->simp.tinc = lgl->opts->simptintinclim.val;
+    lglprt (lgl, 1,
+      "[simplification-%d] new ternary interval %d",
+      lgl->stats->simp.count, lgl->limits->simp.tinc);
+  }
+  lgl->limits->simp.trn = lgl->stats->trns + lgl->limits->simp.tinc;
+
+  lgl->limits->simp.vars = lglrem (lgl);
+  lgl->repforcehead = 1;
+  if (lgl->wait > 0) lgl->wait--;
+
+#ifndef NLGLFILES
+  {
+    static FILE * simpsfile = 0;
+    if (!simpsfile) simpsfile = fopen ("/tmp/simps", "w");
+    fprintf (simpsfile, "%lld\n", (LGLL) lgl->stats->confs);
+    fflush (simpsfile);
+  }
+#endif
+}
+
+static int lglpreprocessing (LGL * lgl, int forced) {
+  int res, oldrem, oldirr;
+  if (lgl->mt) return 0;
+  assert (!lgl->searching);
+  lgl->stats->simp.count++;
+  oldrem = lglrem (lgl);
+  oldirr = lgl->stats->irr.clauses.cur;
+  res = lglisimp (lgl);
+  lglupdsimpint (lgl, oldrem, oldirr, forced);
+  assert (res == !lgl->mt);
+  return res;
+}
+
+static int lglsimplimhit (LGL * lgl, int * forcedptr) {
+  int64_t n, o, d;
+  int a, r, res = 0;;
+  if (!lgl->opts->simplify.val) return 0;
+  if (!lgl->opts->inprocessing.val && lgl->stats->simp.count) return 0;
+  if (lgl->stats->confs < lgl->limits->simp.hard) {
+    if (lgl->opts->simpitintdecdelay.val &&
+        lgl->stats->its.avg.diff.smoothed.val < 0) return 0;
+    if (lgl->opts->simpjleveldecdelay.val &&
+        lgl->stats->jlevel.diff.smoothed.val < 0) return 0;
+  }
+  if (lgl->stats->confs >= lgl->limits->simp.confs) {
+    lglprt (lgl, 1, "");
+    lglprt (lgl, 1,
+      "[simplification-%d] "
+      "limit %lld conflicts (hard %lld) hit after %lld conflicts",
+      lgl->stats->simp.count + 1,
+      (LGLL) lgl->limits->simp.confs, (LGLL) lgl->limits->simp.hard,
+      (LGLL) lgl->stats->confs);
+    lgl->stats->simp.limhit.confs++;
+    *forcedptr = 0;
+    res = 1;
+  }
+  if (!res && lgl->stats->trns >= lgl->limits->simp.trn) {
+    lglprt (lgl, 1, "");
+    lglprt (lgl, 1,
+      "[simplification-%d] limit of %lld ternary hit after %lld ternaries",
+      lgl->stats->simp.count + 1,
+      (LGLL) lgl->limits->simp.trn, (LGLL) lgl->stats->trns);
+    lgl->stats->simp.limhit.trn++;
+    *forcedptr = 3;
+    res = 1;
+  }
+  if (!res && lgl->stats->bins >= lgl->limits->simp.bin) {
+    lglprt (lgl, 1, "");
+    lglprt (lgl, 1,
+      "[simplification-%d] limit of %lld binary hit after %lld binaries",
+      lgl->stats->simp.count + 1,
+      (LGLL) lgl->limits->simp.bin, (LGLL) lgl->stats->bins);
+    lgl->stats->simp.limhit.bin++;
+    *forcedptr = 2;
+    res = 1;
+  }
+  if (!res && lgl->stats->its.count >= lgl->limits->simp.its) {
+    lglprt (lgl, 1, "");
+    lglprt (lgl, 1,
+      "[simplification-%d] limit of %lld iterations hit after %d iterations",
+      lgl->stats->simp.count + 1,
+      (LGLL) lgl->limits->simp.its, lgl->stats->its.count);
+    lgl->stats->simp.limhit.its++;
+    *forcedptr = 1;
+    res = 1;
+  }
+  if (!res &&
+      (o = lgl->limits->simp.vars) &&
+      (n = lglrem (lgl)) >= lgl->opts->simpvarlim.val) {
+    d = n - o;
+    r = 100*d;
+    r /= o;
+    if (r <= INT_MIN || r > INT_MAX) a = INT_MAX;
+    else if (r < 0) a = -r;
+    else a = r;
+    if (a >= lgl->opts->simpvarchg.val) {
+      lglprt (lgl, 1, "");
+      lglprt (lgl, 1,
+	"[simplification-%d] limit hit: "
+	"remaining variables changed from %lld to %lld by %d%%",
+	lgl->stats->simp.count + 1, (LGLL) o, (LGLL) n, r);
+      lgl->stats->simp.limhit.vars++;
+      *forcedptr = -1;
+      res = 1;
+    }
+  }
+  return res;
+}
+
+static int lglinprocessing (LGL * lgl) {
+  int res, oldrem, oldirr, forced;
+  assert (lgl->searching);
+  if (!lglsimplimhit (lgl, &forced)) return !lgl->mt;
+  lgl->stats->simp.count++;
+  lglstart (lgl, &lgl->times->inprocessing);
+  oldrem = lglrem (lgl);
+  oldirr = lgl->stats->irr.clauses.cur;
+  res = lglisimp (lgl);
+  lglupdsimpint (lgl, oldrem, oldirr, forced);
+  lglstop (lgl);
+  assert (res == !lgl->mt);
+  return res;
+}
+
+static int lglbcptop (LGL * lgl) {
+  int res;
+  if (lglbcp (lgl)) res = 1;
+  else {
+#ifndef NDEBUG
+    int tmp =
+#endif
+    lglana (lgl);
+    assert (!tmp);
+    if (lgl->conf.lit) {
+      LOG (1, "top level propagation produces inconsistency");
+      lglmt (lgl);
+    } else assert (lgl->failed);
+    res = 0;
+  }
+  return res;
+}
+
+static int lglimhit (LGL * lgl, Lim * lim) {
+  if (!lim) return 0;
+  if (lim->decs >= 0 && lgl->stats->decisions >= lim->decs) {
+    lglprt (lgl, 1, "[limits] decision limit %lld hit at %lld decisions",
+      (LGLL) lim->decs, (LGLL) lgl->stats->decisions);
+    return 1;
+  }
+  if (lim->confs >= 0 && lgl->stats->confs >= lim->confs) {
+    lglprt (lgl, 1, "[limits] conflict limit %lld hit at %lld conflicts",
+      (LGLL) lim->confs, (LGLL) lgl->stats->confs);
+    return 1;
+  }
+  if (lim->props >= 0 && lgl->stats->props.search >= lim->props) {
+    lglprt (lgl, 1,
+      "[limits] propagation limit %lld hit at %lld propagations",
+      (LGLL) lim->props, (LGLL) lgl->stats->props.search);
+    return 1;
+  }
+  return 0;
+}
+
+static int lgloop (LGL * lgl, Lim * lim) {
+  unsigned confs = 0;
+  for (;;) {
+    if (lglbcpsearch (lgl) && lglinprocessing (lgl)) {
+      if (lglterminate (lgl)) return 0;
+      if (!lglsyncunits (lgl)) return 20;
+      if (!lglsyncls (lgl)) continue;
+      if (lglfailedass (lgl)) return 20;
+      if (lglreducing (lgl)) lglreduce (lgl, 0);
+      if (lgldefragmenting (lgl)) lgldefrag (lgl);
+      if (lglimhit (lgl, lim)) return 0;
+      if (lglocsing (lgl)) lglocs (lgl);
+      if (lglrestarting (lgl)) { lglrestart (lgl); continue; }
+      if (lglpruning (lgl)) { lglprune (lgl); continue; }
+      if (!lgldecide (lgl)) return 10;
+    } else if (!lglana (lgl)) return 20;
+    else if (!(++confs & 15) && lglterminate (lgl)) return 0;
+  }
+}
+
+static int lglsearch (LGL * lgl, Lim * lim) {
+  int res;
+  assert (!lgl->searching);
+  lgl->searching = 1;
+  lglstart (lgl, &lgl->times->search);
+  res = lgloop (lgl, lim);
+  assert (lgl->searching);
+  lgl->searching = 0;
+  lglstop (lgl);
+  return res;
+}
+
+static int lgltopsimp (LGL * lgl, int forcesimp) {
+  assert (lgl->state == READY);
+  if (lgl->mt) return 20;
+  if (lglfailedass (lgl)) return 20;
+  if (!lglbcptop (lgl)) return 20;
+  if (lgl->mt || lglfailedass (lgl)) return 20;
+  if (lglterminate (lgl)) return 0;
+  lglshowfeatures (lgl);
+  if ((forcesimp || lglsimplimhit (lgl, &forcesimp)) &&
+      !lglpreprocessing (lgl, forcesimp)) return 20;
+  if (lglfailedass (lgl)) return 20;
+  lglrep (lgl, 2, 's');
+  return 0;
+}
+
+static int lglsolve (LGL * lgl, Lim * lim, int forcesimp) {
+  int res;
+  lglstart (lgl, &lgl->times->preprocessing);
+  res = lgltopsimp (lgl, forcesimp);
+  lglstop (lgl);
+  if (res) { assert (res == 20); return res; }
+  return lglsearch (lgl, lim);
+}
+
+static void lglincsetup (LGL * lgl) {
+
+  if (lgl->opts->incsavevisits.val)
+    lgl->limits->inc.visits = lgl->stats->visits.search;
+
+  assert (lgl->limits->inc.clauses.add <= lgl->stats->irr.clauses.add);
+  if (lgl->limits->inc.clauses.add < lgl->stats->irr.clauses.add) {
+    lgl->limits->inc.clauses.add = lgl->stats->irr.clauses.add;
+    lgl->elmrtc = lgl->blkrtc = lgl->ccertc = 0;
+    lgl->wait = lgl->opts->waitmax.val;
+  }
+
+  lgl->limits->inc.clauses.start = lgl->stats->irr.clauses.cur;
+  lgl->limits->inc.vars.start = lglrem (lgl);
+
+  lgl->limits->prune.decisions =
+    lgl->stats->decisions + lgl->limits->prune.inc;
+
+  lglinitredl (lgl);
+
+  lgl->stats->locs.min = INT_MAX;
+  lglupdlocslim (lgl, 0);
+
+  CLR (lgl->limits->restart);
+  lgl->limits->restart.confs = lgl->stats->confs;
+
+  if (lgl->opts->incredcint.val > 1) {
+    lgl->limits->simp.cinc /= lgl->opts->incredcint.val;
+    lglprt (lgl, 1,
+       "[incremental-setup] conflict interval increment reduced to %d",
+       lgl->limits->simp.cinc);
+  }
+  if (lgl->opts->incredconfslim.val) {
+    lgl->limits->simp.confs =
+      ((100-lgl->opts->incredconfslim.val)*lgl->limits->simp.confs)/100;
+    lglsethardsimplim (lgl);
+    lglprt (lgl, 1,
+       "[incremental-setup] conflict limit reduced to %lld (hard %lld)",
+       (LGLL) lgl->limits->simp.confs, (LGLL) lgl->limits->simp.hard);
+  }
+
+  if (!lgl->limits->simp.itinc)
+    lgl->limits->simp.itinc = lgl->opts->simpitintinc.val;
+  lgl->limits->simp.its =
+    lgl->stats->its.count + lgl->opts->simpitintinc.val;
+
+  if (!lgl->limits->simp.binc)
+    lgl->limits->simp.binc = lgl->opts->simpbintinc.val;
+  lgl->limits->simp.bin = lgl->stats->bins + lgl->opts->simpbintinc.val;
+
+  if (!lgl->limits->simp.tinc)
+    lgl->limits->simp.tinc = lgl->opts->simptintinc.val;
+  lgl->limits->simp.trn = lgl->stats->trns + lgl->opts->simptintinc.val;
+
+  lglinitmacd (lgl, &lgl->stats->jlevel,
+    lgl->opts->jlevelmacdfast.val,
+    lgl->opts->jlevelmacdslow.val,
+    lgl->opts->jlevelmacdsmooth.val);
+
+  lglinitema (lgl, &lgl->stats->tlevel, lgl->opts->tlevelema.val);
+
+  lglinitmacd (lgl, &lgl->stats->glue,
+    lgl->opts->gluemacdfast.val,
+    lgl->opts->gluemacdslow.val,
+    lgl->opts->gluemacdsmooth.val);
+
+  lglinitavg (&lgl->stats->avglue);
+
+  lglinitmacd (lgl, &lgl->stats->its.avg,
+    lgl->opts->itsmacdfast.val,
+    lgl->opts->itsmacdslow.val,
+    lgl->opts->itsmacdsmooth.val);
+
+  lglinitema (lgl, &lgl->stats->stability.avg, lgl->opts->stabema.val);
+
+  CLR (lgl->limits->elm.del);
+  CLR (lgl->limits->blk.del);
+
+  CLR (lgl->limits->trd.del);
+  CLR (lgl->limits->unhd.del);
+  CLR (lgl->limits->ternres.del);
+  CLR (lgl->limits->cce.del);
+  CLR (lgl->limits->card.del);
+
+  CLR (lgl->limits->gauss.del);
+
+  CLR (lgl->limits->prb.simple.del);
+  CLR (lgl->limits->prb.basic.del);
+  CLR (lgl->limits->prb.treelook.del);
+
+  CLR (lgl->limits->bca.del);
+}
+
+static void lglsetup (LGL * lgl) {
+  if (lgl->setuponce) goto DONE;
+  lgl->limits->dfg = lgl->stats->pshwchs + lgl->opts->defragint.val;
+
+  lgl->limits->blk.irrprgss = -1;
+  lgl->limits->elm.irrprgss = -1;
+  lgl->limits->term.steps = -1;
+
+  lgl->limits->prune.inc = lgl->opts->pruneinit.val;
+
+  lgl->rng.w = (unsigned) lgl->opts->seed.val;
+  lgl->rng.z = ~lgl->rng.w;
+  lgl->rng.w <<= 1;
+  lgl->rng.z <<= 1;
+  lgl->rng.w += 1;
+  lgl->rng.z += 1;
+  lgl->rng.w *= 2019164533u, lgl->rng.z *= 1000632769u;
+
+  assert (!lgl->stats->decisions);
+  lgl->limits->randec += lgl->opts->randecint.val/2;
+  lgl->limits->randec += lglrand (lgl) % lgl->opts->randecint.val;
+
+  assert (!lgl->stats->decisions);
+  lgl->limits->randphase += lgl->opts->randphaseint.val/2;
+  lgl->limits->randphase += lglrand (lgl) % lgl->opts->randphaseint.val;
+
+  lgl->limits->simp.vars = lglrem (lgl);
+
+  lgl->setuponce = 1;
+  lglchkenv (lgl);
+DONE:
+  lglinitscores (lgl);
+  lglincsetup (lgl);
+  TRANS (READY);
+}
+
+static void lglinitsolve (LGL * lgl) {
+  if (lgl->state != READY) lglsetup (lgl);
+  lglredvars (lgl);
+  lglfitstk (lgl, &lgl->irr);
+#ifndef NCHKSOL
+  lglfitstk (lgl, &lgl->orig);
+#endif
+  lglrep (lgl, 1, '*');
+}
+
+static void lgleassign (LGL * lgl, int lit) {
+  Ext * ext;
+  ext = lglelit2ext (lgl, lit);
+  LOG (3, "external assign %d ", lit);
+  ext->val = lglsgn (lit);
+}
+
+static void lglcomputechanged (LGL * lgl) {
+  Ext * ext;
+  int eidx;
+  lgl->changed = 0;
+  for (eidx = 1; eidx <= lgl->maxext; eidx++) {
+    ext = lglelit2ext (lgl, eidx);
+    if (ext->oldval && ext->oldval != ext->val) lgl->changed++;
+    ext->oldval = ext->val;
+  }
+  LOG (1, "changed %d assignments in extension", lgl->changed);
+}
+
+static void lglextend (LGL * lgl) {
+  int * p, lit, eidx, ilit, next, satisfied, val, * start, erepr, equiv;
+  Ext * ext, * extrepr;
+  assert (lgl->state & SATISFIED);
+  assert (!(lgl->state & EXTENDED));
+  lgleunassignall (lgl);
+  for (equiv = 0; equiv <= 1; equiv++) {
+    if (equiv)
+      LOG (1, "initializing assignment of non-representative externals");
+    else
+      LOG (1, "initializing assignment of external representatives");
+    for (eidx = 1; eidx <= lgl->maxext; eidx++) {
+      ext = lglelit2ext (lgl, eidx);
+      if (!ext->imported) continue;
+      if (equiv != ext->equiv) continue;
+      assert (!ext->val);
+      if (ext->equiv) {
+	erepr = lglerepr (lgl, eidx);
+LOG (3, "initializing external %d assignment from external representative %d",
+	 eidx, erepr);
+	assert (erepr != eidx);
+	extrepr = lglelit2ext (lgl, erepr);
+	if (!(val = extrepr->val)) {
+	  ilit = extrepr->repr;
+	  if (ilit) {
+	    LOG (3, "using external %d to internal %d mapping",
+		 abs (erepr), ilit);
+	    val = lglcval (lgl, ilit);
+	  } else
+LOG (3, "external %d without internal representative", abs (erepr));
+	}
+	if (erepr < 0) val = -val;
+      } else
+      if ((ilit = ext->repr)) {
+	LOG (3, "using external %d to internal %d mapping", eidx, ilit);
+	val = lglcval (lgl, ilit);
+      } else {
+	LOG (3, "external %d without internal representative", eidx);
+	val = 0;
+      }
+      lit = (val > 0) ? eidx : -eidx;
+      lgleassign (lgl, lit);
+    }
+  }
+  start = lgl->extend.start;
+  p = lgl->extend.top;
+  if (p == start) goto SKIP;
+  assert (p > start);
+  p--;
+  assert (!*p);
+  while (p > start) {
+#ifndef NLGLOG
+    if (lgl->opts->log.val >= 4) {
+      int * q;
+      for (q = p; q > start && q[-1]; q--)
+	;
+      LOGCLS (4, q, "next sigma clause to consider");
+    }
+#endif
+    satisfied = 0;
+    next = 0;
+    do {
+      lit = next;
+      if (p == start) next = 0; else next = *--p;
+      if (!lit || satisfied) continue;
+      val = lglederef (lgl, lit);
+      assert (!next || val);
+      if (val > 0) {
+	LOG (4, "sigma clause satisfied by %d", lit);
+	satisfied = 1;
+      }
+    } while (next);
+    assert (lit);
+    if (satisfied) continue;
+    lgleassign (lgl, lit);
+  }
+SKIP:
+  lglcomputechanged (lgl);
+  TRANS (EXTENDED);
+}
+
+void lglsetphases (LGL * lgl) {
+  int elit, phase;
+  REQINITNOTFORKED ();
+  TRAPI ("setphases");
+  REQUIRE (SATISFIED | EXTENDED);
+  if (!(lgl->state & EXTENDED)) lglextend (lgl);
+  for (elit = 1; elit <= lgl->maxext; elit++) {
+    phase = lglederef (lgl, elit);
+    assert (abs (phase) <= 1);
+    lglesetphase (lgl, elit, phase);
+  }
+  if (lgl->clone) lglsetphases (lgl->clone);
+}
+
+#ifndef NCHKSOL
+#include <signal.h>
+#include <unistd.h>
+static void lglchksol (LGL * lgl) {
+  int * p, * c, * eoo = lgl->orig.top, lit, satisfied, sign, idx;
+  unsigned bit;
+  Ext * ext;
+  assert (lglmtstk (&lgl->orig) || !eoo[-1]);
+  assert (lgl->state == EXTENDED);
+  for (c = lgl->orig.start; c < eoo; c = p + 1) {
+    satisfied = 0;
+    for (p = c; (lit = *p); p++)
+      if (!satisfied && lglederef (lgl, lit) > 0)
+	satisfied = 1;
+    if (satisfied) continue;
+    fflush (stderr);
+    lglmsgstart (lgl, 0);
+    fprintf (lgl->out, "unsatisfied original external clause");
+    for (p = c; (lit = *p); p++) fprintf (lgl->out, " %d", lit);
+    lglmsgend (lgl);
+    ASSERT (satisfied);
+    usleep (1000);
+    abort ();	// NOTE: not 'lglabort' on purpose !!
+  }
+  for (idx = 1; idx <= lgl->maxext; idx++) {
+    ext = lglelit2ext (lgl, idx);
+    if (!ext->assumed) continue;
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      bit = 1u << (lit < 0);
+      if (!(ext->assumed & bit)) continue;
+      if (lglederef (lgl, lit) > 0) continue;
+      lglprt (lgl, 0, "unsatisfied assumption %d", lit);
+      assert (lglederef (lgl, lit) > 0);
+      usleep (1000);
+      abort ();	// DITO: not 'lglabort' on purpose !!
+    }
+  }
+}
+#endif
+
+static void lglclass (LGL * lgl, LGL * from) {
+  Ext * extfrom, * extlgl;
+  int eidx, cloned;
+  REQINITNOTFORKED ();
+  ABORTIF (lgl->mt, "can not clone assignment into inconsistent manager");
+  ABORTIF (!from, "uninitialized 'from' solver");
+  ABORTIF (!(from->state & (SATISFIED | EXTENDED)),
+    "require 'from' state to be (SATISFIED | EXTENDED)"); 
+  ABORTIF (from->maxext != lgl->maxext,
+    "can not clone assignments for different sets of variables");
+  if (!(from->state & EXTENDED)) lglextend (from);
+  lglreset (lgl);
+  lgleunassignall (lgl);
+  cloned = lgl->changed = 0;
+  for (eidx = 1; eidx <= lgl->maxext; eidx++) {
+    extlgl = lglelit2ext (lgl, eidx);
+    if (!extlgl->imported) continue;
+    extfrom = lglelit2ext (from, eidx);
+    ABORTIF (!extfrom->imported, 
+      "can not clone assignment of literal imported only by 'to'");
+    assert (extfrom->val == 1 || extfrom->val == -1);
+    lgleassign (lgl, extfrom->val*eidx);
+    cloned++;
+  }
+  lglcomputechanged (lgl);
+  lglprt (lgl, 1, "[class] cloned %d assignments (%d changed)",
+          cloned, lgl->changed);
+  TRANS (EXTENDED);
+#ifndef NCHKSOL
+  lglchksol (lgl);
+#endif
+}
+
+static void lglnegass (LGL * lgl) {
+  const int  * p;
+  Stk eassume;
+  REQINITNOTFORKED ();
+  TRAPI ("negass");
+  if (lgl->mt) return;
+  CLR (eassume);
+  for (p = lgl->eassume.start; p < lgl->eassume.top; p++)
+    lglpushstk (lgl, &eassume, *p);
+  for (p = eassume.start; p < eassume.top; p++)
+    lgleadd (lgl, -*p);
+  lgleadd (lgl, 0);
+  assert (lglmtstk (&lgl->eassume));
+  for (p = eassume.start; p < eassume.top; p++)
+    lglassume (lgl, *p);
+  lglrelstk (lgl, &eassume);
+  lgluse (lgl);
+  if (lgl->clone) lglnegass (lgl->clone);
+}
+
+static int lglcompactify (LGL * lgl, int res) {
+  if (!lgl->opts->compact.val) return 0;
+  if (!res) return 1;
+  if (res == 20) return 1;
+  assert (res == 10);
+  return lgl->opts->compact.val >= 2;
+}
+
+static int lglisat (LGL * lgl, Lim * lim, int simpits) {
+  int res, count, reported = lgl->stats->reported;
+  lglreset (lgl);
+  lglinitsolve (lgl);
+  res = lglsolve (lgl, lim, 0);
+  for (count = 0; !res && count < simpits; count++) {
+    lglprt (lgl, 1,
+      "[simplification-%d] next forced simplification iteration %d",
+      lgl->stats->simp.count + 1, count + 1);
+    res = lglsolve (lgl, lim, 1);
+  }
+  if (lglcompactify (lgl, res)) lglcompact (lgl);
+  if (!res) {
+    TRANS (UNKNOWN);
+    lglrep (lgl, 1, '?');
+  }
+  if (res == 10) {
+    TRANS (SATISFIED);
+    lglrep (lgl, 1, '1');
+  }
+  if (res == 20) {
+    TRANS (UNSATISFIED);
+    if (!lgl->level && !lgl->mt) assert (lgl->failed);
+    lglrep (lgl, 1, '0');
+  }
+  if (reported != lgl->stats->reported) lglflshrep (lgl);
+  if (res == 10) lglextend (lgl);
+#ifndef NCHKSOL
+  if (res == 10) lglchksol (lgl);
+#endif
+  return res;
+}
+
+int lglunclone (LGL * lgl, LGL * from) {
+  int res;
+  REQINITNOTFORKED ();
+  if (lgl->mt) return 20;
+  ABORTIF (!from, "uninitialized 'from' solver");
+  if (from->mt || (from->state & UNSATISFIED)) {
+    lglprt (lgl, 1, "[unclone] unsatisfied state");
+    lglnegass (lgl);
+    res = lglisat (lgl, 0, 0);
+  } else if (from->state & (SATISFIED | EXTENDED)) {
+    lglprt (lgl, 1, "[unclone] satisfied state");
+    lglclass (lgl, from);
+    res = 10;
+  } else {
+    lglprt (lgl, 1, "[unclone] unknown state");
+    lglreset (lgl);
+    TRANS (UNKNOWN);
+    res = 0;
+  }
+  return res;
+}
+
+#define CHKCLONESTATS(STATS) \
+do { \
+  assert (clone->stats->STATS == orig->stats->STATS); \
+} while (0)
+
+static void lglchkclonesamestats (LGL * orig) {
+#ifndef NDEBUG
+  LGL * clone = orig->clone;
+  assert (clone);
+  assert (clone->state == orig->state);
+  CHKCLONESTATS (confs);
+  CHKCLONESTATS (decisions);
+  CHKCLONESTATS (bytes.current);
+  CHKCLONESTATS (bytes.max);
+  CHKCLONESTATS (props.search);
+  CHKCLONESTATS (props.simp);
+  CHKCLONESTATS (props.lkhd);
+  CHKCLONESTATS (visits.search);
+  CHKCLONESTATS (visits.simp);
+  CHKCLONESTATS (visits.lkhd);
+#endif
+}
+
+#define CHKCLONE() \
+do { \
+  if (!lgl->clone) break; \
+  lglchkclonesamestats (lgl); \
+} while (0)
+
+#define CHKCLONENORES(FUN) \
+do { \
+  if (!lgl->clone) break; \
+  FUN (lgl->clone); \
+  CHKCLONE (); \
+} while (0)
+
+#define CHKCLONERES(FUN,RES) \
+do { \
+  int CLONERES; \
+  if (!lgl->clone) break; \
+  CLONERES = FUN (lgl->clone); \
+  ABORTIF (CLONERES != (RES), \
+           "%s (lgl->clone) = %d differs from %s (lgl) = %d", \
+	   __FUNCTION__, CLONERES, __FUNCTION__, (RES)); \
+  CHKCLONE (); \
+} while (0)
+
+#define RETURN(FUN,RES) \
+do { \
+  TRAPI ("return %d", (RES)); \
+  CHKCLONERES (FUN, (RES)); \
+} while (0)
+
+#define CHKCLONEARGRES(FUN,ARG,RES) \
+do { \
+  int CLONERES; \
+  if (!lgl->clone) break; \
+  CLONERES = FUN (lgl->clone, (ARG)); \
+  ABORTIF (CLONERES != (RES), \
+           "%s (lgl->clone, %d) = %d differs from %s (lgl, %d) = %d", \
+	   __FUNCTION__, (ARG), CLONERES, __FUNCTION__, (ARG), (RES)); \
+  CHKCLONE (); \
+} while (0)
+
+#define RETURNARG(FUN,ARG,RES) \
+do { \
+  TRAPI ("return %d", (RES)); \
+  CHKCLONEARGRES (FUN, (ARG), (RES)); \
+} while (0)
+
+static void lglsetlim (LGL * lgl, Lim * lim) {
+  int64_t clim, dlim, plim, confs, decs, props, delay, delayed;
+  if ((dlim = lgl->opts->dlim.val) < 0) {
+    lim->decs = -1;
+    lglprt (lgl, 1, "[limits] no decision limit");
+  } else {
+    decs = lgl->stats->decisions;
+    lim->decs = (decs >= LLMAX - dlim) ? LLMAX : decs + dlim;
+    lglprt (lgl, 1, "[limits] decision limit %lld after %lld decisions", 
+            (LGLL) lim->decs, (LGLL) decs);
+  }
+  if ((clim = lgl->opts->clim.val) < 0) {
+    lim->confs = -1;
+    lglprt (lgl, 1, "[limits] no conflict limit");
+  } else {
+    confs = lgl->stats->confs;
+    lim->confs = (confs >= LLMAX - clim) ? LLMAX : confs + clim;
+    lglprt (lgl, 1, "[limits] conflict limit %lld after %lld conflicts", 
+            (LGLL) lim->confs, (LGLL) confs);
+  }
+  if ((plim = lgl->opts->plim.val) < 0) {
+    lim->props = -1;
+    lglprt (lgl, 1, "[limits] no propagation limit");
+  } else {
+    plim *= 1000;
+    props = lgl->stats->props.search;
+    lim->props = (props >= LLMAX - plim) ? LLMAX : props + plim;
+    lglprt (lgl, 1,
+      "[limits] propagation limit %lld after %lld propagations", 
+      (LGLL) lim->props, (LGLL) props);
+  }
+  if ((delay = lgl->opts->simpinitdelay.val) > 0) {
+    delayed = lgl->stats->confs + delay;
+    if (delayed > lgl->limits->simp.confs) {
+      lgl->limits->simp.confs = delayed;
+      lglsethardsimplim (lgl);
+      lglprt (lgl, 1,
+	"[limits] simplification delayed by %lld to %lld conflicts (hard %lld)",
+	(LGLL) delay, (LGLL) lgl->limits->simp.confs, (LGLL) lgl->limits->simp.hard);
+    } else lglprt (lgl, 1, 
+             "[limits] simplification conflict limit already exceeds delay");
+  } else lglprt (lgl, 1, 
+           "[limits] simplification not delayed since 'simpdelay' zero");
+}
+
+int lglsat (LGL * lgl) {
+  int res;
+  Lim lim;
+  REQINITNOTFORKED ();
+  TRAPI ("sat");
+  lglstart (lgl, &lgl->times->all);
+  lgl->stats->calls.sat++;
+  ABORTIF (!lglmtstk (&lgl->clause), "clause terminating zero missing");
+  lglfreezer (lgl);
+  lglsetlim (lgl, &lim);
+  res = lglisat (lgl, &lim, 0);
+  lglstop (lgl);
+  RETURN (lglsat, res);
+  return res;
+}
+
+int lglookahead (LGL * lgl) {
+  int ilit, res;
+  REQINITNOTFORKED ();
+  TRAPI ("lkhd");
+  ABORTIF (!lglmtstk (&lgl->eassume), "imcompatible with 'lglassume'");
+  ABORTIF (!lglmtstk (&lgl->clause), "clause terminating zero missing");
+  ABORTIF (lgl->opts->druplig.val && lgl->opts->lkhd.val == 2,
+    "can not use tree based look ahead while Druplig is enabled");
+  lglstart (lgl, &lgl->times->all);
+  lglstart (lgl, &lgl->times->lookahead);
+  lgl->stats->calls.lkhd++;
+  lglreset (lgl);
+  assert (!lgl->lkhd);
+  lgl->lkhd = 1;
+  lglfreezer (lgl);
+  if (lgl->level) lglbacktrack (lgl, 0);
+  if (!lgl->mt && lglbcp (lgl)) {
+    ilit = 0;
+    if (lgl->opts->lkhd.val == 2 && !lglsmallirr (lgl))
+      ilit = lgljwhlook (lgl);
+    else switch (lgl->opts->lkhd.val) {
+      case -1: ilit = lglocslook (lgl); break;
+      case 0: ilit = lglislook (lgl); break;
+      case 1: ilit = lgljwhlook (lgl); break;
+      case 2:
+	if (!lgltreelookaux (lgl, &ilit)) assert (lgl->mt);
+	break;
+      case 3:
+      default:
+        assert (lgl->opts->lkhd.val == 3);
+	ilit = lglsumlenlook (lgl);
+	break;
+    }
+    res = (!lgl->mt && ilit) ? lglexport (lgl, ilit) : 0;
+    assert (!res || !lglelit2ext (lgl, res)->melted);
+  } else lglmt (lgl), res = 0;
+  assert (lgl->lkhd);
+  lgl->lkhd = 0;
+  lglstop (lgl);
+  lglstop (lgl);
+  TRANS (LOOKED);
+  RETURN (lglookahead, res);
+  return res;
+}
+
+int lglchanged (LGL * lgl) {
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("changed");
+  REQUIRE (EXTENDED);
+  res = lgl->changed;
+  RETURN (lglchanged, res);
+  return res;
+}
+
+int lglsimp (LGL * lgl, int iterations) {
+  Lim lim;
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("simp %d", iterations);
+  ABORTIF (iterations < 0, "negative number of simplification iterations");
+  ABORTIF (!lglmtstk (&lgl->clause), "clause terminating zero missing");
+  lglstart (lgl, &lgl->times->all);
+  lgl->stats->calls.simp++;
+  lglfreezer (lgl);
+  CLR (lim);
+  lim.decs = lgl->stats->decisions;
+  res = lglisat (lgl, &lim, iterations);
+  assert (!lgl->level);
+  lglstop (lgl);
+  RETURNARG (lglsimp, iterations, res);
+  return res;
+}
+
+int lglmaxvar (LGL * lgl) {
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("maxvar");
+  res = lgl->maxext;
+  RETURN (lglmaxvar, res);
+  return res;
+}
+
+int lglincvar (LGL  *lgl) {
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("incvar");
+  res = lgl->maxext + 1;
+  (void) lglimport (lgl, res);
+  RETURN (lglincvar, res);
+  return res;
+}
+
+int lglderef (LGL * lgl, int elit) {
+  int res;
+  REQINIT ();
+  TRAPI ("deref %d", elit);
+  lgl->stats->calls.deref++;
+  ABORTIF (!elit, "can not deref zero literal");
+  REQUIRE (SATISFIED | EXTENDED);
+  if (!(lgl->state & EXTENDED)) lglextend (lgl);
+  res = lglederef (lgl, elit);
+  RETURNARG (lglderef, elit, res);
+  return res;
+}
+
+int lglfailed (LGL * lgl, int elit) {
+  unsigned bit;
+  Ext * ext;
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("failed %d", elit);
+  lgl->stats->calls.failed++;
+  ABORTIF (!elit, "can not check zero failed literal");
+  REQUIRE (UNSATISFIED | FAILED);
+  ABORTIF (abs (elit) > lgl->maxext,
+	   "can not check unimported failed literal");
+  ext = lglelit2ext (lgl, elit);
+  bit = 1u << (elit < 0);
+  ABORTIF (!(ext->assumed & bit),
+	   "can not check unassumed failed literal");
+  if (!(lgl->state & FAILED)) {
+    lglstart (lgl, &lgl->times->all);
+    lglanafailed (lgl);
+    lglstop (lgl);
+  }
+  res = (ext->failed & bit) != 0;
+  RETURNARG (lglfailed, elit, res);
+  return res;
+}
+
+int lglinconsistent (LGL * lgl) {
+  int res;
+  TRAPI ("inconsistent");
+  res = (lgl->mt != 0);
+  RETURN (lglinconsistent, res);
+  return res;
+}
+
+static int lglefixed (LGL * lgl, int elit) {
+  int res, ilit;
+  assert (elit);
+  if (abs (elit) > lgl->maxext) return 0;
+  ilit = lglimport (lgl, elit);
+  if (!ilit) res = 0;
+  else if (abs (ilit) == 1) res = ilit;
+  else res = lglifixed (lgl , ilit);
+  return res;
+}
+
+int lglfixed (LGL * lgl, int elit) {
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("fixed %d", elit);
+  lgl->stats->calls.fixed++;
+  ABORTIF (!elit, "can not deref zero literal");
+  res = lglefixed (lgl, elit);
+  RETURNARG (lglfixed, elit, res);
+  return res;
+}
+
+int lglrepr (LGL * lgl, int elit) {
+  int res, eidx = abs (elit);
+  REQINITNOTFORKED ();
+  TRAPI ("repr %d", elit);
+  lgl->stats->calls.repr++;
+  if (eidx > lgl->maxext) res = elit;
+  else res = lglerepr (lgl, elit);
+  RETURNARG (lglrepr, elit, res);
+  return res;
+}
+
+void lglfreeze (LGL * lgl, int elit) {
+  Ext * ext;
+  REQINITNOTFORKED ();
+  TRAPI ("freeze %d", elit);
+  lgl->stats->calls.freeze++;
+  ABORTIF (!elit, "can not freeze zero literal");
+  REQUIRE (UNUSED|OPTSET|USED|RESET|SATISFIED|UNSATISFIED|FAILED|LOOKED|
+	   UNKNOWN|EXTENDED);
+  LOG (2, "freezing external literal %d", elit);
+  (void) lglimport (lgl, elit);
+  ext = lglelit2ext (lgl, elit);
+  ABORTIF (ext->melted, "freezing melted literal %d", elit);
+  assert (!ext->blocking && !ext->eliminated);
+  ABORTIF (ext->frozen == INT_MAX, "literal %d frozen too often", elit);
+  ext->frozen++;
+  if (!ext->frozen) {
+    lgl->stats->irrprgss++;
+    lglmelter (lgl);
+  }
+  if (lgl->clone) lglfreeze (lgl->clone, elit);
+}
+
+int lglfrozen (LGL * lgl, int elit) {
+  Ext * ext;
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("frozen %d", elit);
+  ABORTIF (!elit, "can not check zero literal for being frozen");
+  if (abs (elit) > lgl->maxext) res = INT_MAX;
+  else if (!(ext = lglelit2ext (lgl, elit))->imported) res = INT_MAX;
+  else res = ext->frozen;
+  RETURNARG (lglfrozen, elit, res);
+  return res;
+}
+
+int lglusable (LGL * lgl, int elit) {
+  Ext * ext;
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("usable %d", elit);
+  ABORTIF (!elit, "can not check zero literal for being usable");
+  if (abs (elit) > lgl->maxext) res = 1;
+  else if (!(ext = lglelit2ext (lgl, elit))->imported) res = 1;
+  else res = !ext->melted;
+  RETURNARG (lglusable, elit, res);
+  return res;
+}
+
+static int lglereusable (LGL * lgl, int elit) {
+  Ext * ext;
+  int res;
+  if (abs (elit) > lgl->maxext) res = 1;
+  else if (!(ext = lglelit2ext (lgl, elit))->imported) res = 1;
+  else if (ext->blocking) res = 0;
+  else if (ext->eliminated) res = 0;
+  else if (ext->equiv) res = 0;
+  else if (abs (ext->repr) == 1) res = 0;
+  else res = 1;
+  return res;
+}
+
+int lglreusable (LGL * lgl, int elit) {
+  int res;
+  REQINITNOTFORKED ();
+  TRAPI ("reusable %d", elit);
+  ABORTIF (!elit, "can not check zero literal for being reusable");
+  res = lglereusable (lgl, elit);
+  RETURNARG (lglreusable, elit, res);
+  return res;
+}
+
+void lglreuse (LGL * lgl, int elit) {
+  Ext * ext;
+  REQINITNOTFORKED ();
+  TRAPI ("reuse %d", elit);
+  ABORTIF (!elit, "can not reuse zero literal");
+  ABORTIF (!lglereusable (lgl, elit), "can not reuse non-reusable literal");
+  if (abs (elit) <= lgl->maxext) {
+    ext = lglelit2ext (lgl, elit);
+    if (ext->imported) {
+      assert (!ext->blocking);
+      assert (!ext->eliminated);
+      if (ext->melted) {
+	LOG (2,
+	  "forced permanently melted external %d to be reused",
+	  elit);
+	ext->melted = 0;
+	lglmelter (lgl);
+      }
+    }
+  }
+  if (lgl->clone) lglreuse (lgl->clone, elit);
+}
+
+void lglmeltall (LGL * lgl) {
+  int idx, melted;
+  Ext * ext;
+  REQINITNOTFORKED ();
+  TRAPI ("meltall");
+  melted = 0;
+  for (idx = 1; idx <= lgl->maxext; idx++) {
+    ext = lglelit2ext (lgl, idx);
+    ext->melted = 0;
+    if (!ext->frozen) continue;
+    lgl->stats->irrprgss++;
+    ext->frozen = 0;
+    melted++;
+  }
+  lglprt (lgl, 1, "[meltall] melted %d frozen literals", melted);
+  lglmelter (lgl);
+  if (lgl->clone) lglmeltall (lgl->clone);
+}
+
+void lglmelt (LGL * lgl, int elit) {
+  Ext * ext;
+  REQINITNOTFORKED ();
+  TRAPI ("melt %d", elit);
+  lgl->stats->calls.melt++;
+  ABORTIF (!elit, "can not melt zero literal");
+  REQUIRE (UNUSED|OPTSET|USED|RESET|
+	   SATISFIED|UNSATISFIED|FAILED|UNKNOWN|LOOKED|
+	   EXTENDED);
+  LOG (2, "melting external literal %d", elit);
+  (void) lglimport (lgl, elit);
+  ext = lglelit2ext (lgl, elit);
+  ABORTIF (!ext->frozen, "can not melt fully unfrozen literal %d", elit);
+  assert (!ext->blocking && !ext->eliminated);
+  ext->frozen--;
+  lglmelter (lgl);	// TODO guard  by !ext->frozen?
+  if (lgl->clone) lglmelt (lgl->clone, elit);
+}
+
+void lglreconstk (LGL * lgl, int ** startptr, int ** toptr) {
+  REQINITNOTFORKED ();
+  TRAPI ("reconstk");
+  lglfitstk (lgl, &lgl->extend);	// 'lglcompact' -> 'lglclone'!!
+  if (startptr) *startptr = lgl->extend.start;
+  if (toptr) *toptr = lgl->extend.top;
+  if (lgl->clone) lglreconstk (lgl->clone, 0, 0);
+}
+
+static void lglprstart (LGL * lgl) {
+  assert (lgl->prefix);
+  fputs (lgl->prefix, lgl->out);
+  if (lgl->tid >= 0) fprintf (lgl->out, "%d ", lgl->tid);
+}
+
+static void lglprs (LGL * lgl, const char * fmt, ...) {
+  va_list ap;
+  lglprstart (lgl);
+  va_start (ap, fmt);
+  vfprintf (lgl->out, fmt, ap);
+  va_end (ap);
+  fputc ('\n', lgl->out);
+}
+
+static void lglprsline (LGL * lgl) {
+  lglprstart (lgl);
+  fputc ('\n', lgl->out);
+}
+
+static double lglsqr (double a) { return a*a; }
+
+static void lglgluestats (LGL * lgl) {
+  int64_t added, reduced, retired, forcing, resolved, conflicts;
+  int64_t wadded, wreduced, wretired, wforcing, wresolved, wconflicts;
+  int64_t avgadded, avgreduced, avgretired, avgforcing, avgresolved, avgconflicts;
+  double madded, mreduced, mretired, mforcing, mresolved, mconflicts;
+  double vadded, vreduced, vretired, vforcing, vresolved, vconflicts;
+  double sadded, sreduced, sretired, sforcing, sresolved, sconflicts;
+  Stats * s = lgl->stats;
+  int glue, maxglue;
+  lglprs (lgl,
+    "scaled glue%11s %3s %9s %3s %9s %3s %9s %3s %9s %3s %9s %7s",
+    "added","", "reduced","", "retired","",
+    "forcing","", "resolved","", "conflicts", "maxmb");
+  added = reduced = retired = forcing = resolved = conflicts = 0;
+  wadded = wreduced = wretired = wforcing = wresolved = wconflicts = 0;
+  for (glue = 0; glue <= MAXGLUE; glue++) {
+    added += s->lir[glue].added;
+    reduced += s->lir[glue].reduced;
+    retired += s->lir[glue].retired;
+    forcing += s->lir[glue].forcing;
+    resolved += s->lir[glue].resolved;
+    conflicts += s->lir[glue].conflicts;
+    wadded += glue*s->lir[glue].added;
+    wreduced += glue*s->lir[glue].reduced;
+    wretired += glue*s->lir[glue].retired;
+    wforcing += glue*s->lir[glue].forcing;
+    wresolved += glue*s->lir[glue].resolved;
+    wconflicts += glue*s->lir[glue].conflicts;
+  }
+  avgadded = added ? (((10*wadded)/added+5)/10) : 0;
+  avgreduced = reduced ? (((10*wreduced)/reduced+5)/10) : 0;
+  avgretired = retired ? (((10*wretired)/retired+5)/10) : 0;
+  avgforcing = forcing ? (((10*wforcing)/forcing+5)/10) : 0;
+  avgresolved = resolved ? (((10*wresolved)/resolved+5)/10) : 0;
+  avgconflicts = conflicts ? (((10*wconflicts)/conflicts+5)/10) : 0;
+  lglprsline (lgl);
+  lglprs (lgl,
+    "all %14lld %13lld %13lld %13lld %13lld %13lld",
+     (LGLL) added,
+     (LGLL) reduced,
+     (LGLL) retired,
+     (LGLL) forcing,
+     (LGLL) resolved,
+     (LGLL) conflicts);
+  lglprsline (lgl);
+  if (lgl->opts->verbose.val < 2) {
+    for (maxglue = MAXGLUE; maxglue >= 1; maxglue--)
+      if (s->lir[maxglue].added) break;
+    if (maxglue + 1 == MAXGLUE) maxglue = MAXGLUE;
+  } else maxglue = MAXGLUE;
+  for (glue = 0; glue <= maxglue; glue++) {
+    lglprs (lgl,
+      "%2d %-5d %9lld %3.0f%c%9lld %3.0f%c%9lld %3.0f%c%9lld %3.0f%c%9lld %3.0f%c%9lld %3.0f%c %6.1f",
+      glue,
+      lglunscaleglue (lgl, glue),
+      (LGLL) s->lir[glue].added,
+	lglpcnt (s->lir[glue].added, added),
+	(glue == avgadded) ? '<' : ' ',
+      (LGLL) s->lir[glue].reduced,
+	lglpcnt (s->lir[glue].reduced, reduced),
+	(glue == avgreduced) ? '<' : ' ',
+      (LGLL) s->lir[glue].retired,
+	lglpcnt (s->lir[glue].retired, retired),
+	(glue == avgretired) ? '<' : ' ',
+      (LGLL) s->lir[glue].forcing,
+	lglpcnt (s->lir[glue].forcing, forcing),
+	(glue == avgforcing) ? '<' : ' ',
+      (LGLL) s->lir[glue].resolved,
+	lglpcnt (s->lir[glue].resolved, resolved),
+	(glue == avgresolved) ? '<' : ' ',
+      (LGLL) s->lir[glue].conflicts,
+	lglpcnt (s->lir[glue].conflicts, conflicts),
+	(glue == avgconflicts) ? '<' : ' ',
+	s->lir[glue].maxbytes/(double)(1<<20));
+  }
+  lglprsline (lgl);
+
+  madded = lglavg (wadded, added),
+  mreduced = lglavg (wreduced, reduced),
+  mretired = lglavg (wretired, retired),
+  mforcing = lglavg (wforcing, forcing),
+  mresolved = lglavg (wresolved, resolved),
+  mconflicts = lglavg (wconflicts, conflicts);
+
+  lglprs (lgl,
+    "avg  %19.1f%14.1f%14.1f%14.1f%14.1f%14.1f",
+     madded, mreduced, mretired, mforcing, mresolved, mconflicts);
+
+  vadded = vreduced = vretired = vforcing = vresolved = vconflicts = 0;
+  for (glue = 0; glue <= MAXGLUE; glue++) {
+    vadded += s->lir[glue].added * lglsqr (glue - madded);
+    vreduced += s->lir[glue].reduced * lglsqr (glue - mreduced);
+    vretired += s->lir[glue].retired * lglsqr (glue - mretired);
+    vforcing += s->lir[glue].forcing * lglsqr (glue - mforcing);
+    vresolved += s->lir[glue].resolved * lglsqr (glue - mresolved);
+    vconflicts += s->lir[glue].conflicts * lglsqr (glue - mconflicts);
+  }
+  sadded = sqrt (lglavg (vadded, added));
+  sreduced = sqrt (lglavg (vreduced, reduced));
+  sretired = sqrt (lglavg (vretired, retired));
+  sforcing = sqrt (lglavg (vforcing, forcing));
+  sresolved = sqrt (lglavg (vresolved, resolved));
+  sconflicts = sqrt (lglavg (vconflicts, conflicts));
+
+  lglprs (lgl,
+    "std  %19.1f%14.1f%14.1f%14.1f%14.1f%14.1f",
+     sadded, sreduced, sretired, sforcing, sresolved, sconflicts);
+}
+
+typedef struct TN { double t; const char * n; } TN;
+
+static int lglcmptn (const TN * a, const TN * b) {
+  if (a->t > b->t) return -1;
+  if (a->t < b->t) return 1;
+  return strcmp (a->n, b->n);
+}
+
+#define INSTN(NAME,FIELD) \
+do { \
+  TN * tn; \
+  if (lglignprofptr (lgl, &ts->FIELD)) break; \
+  tn = tns + ntns++; \
+  ASSERT (ntns <= sztns); \
+  tn->t = ts->FIELD; \
+  tn->n = #NAME; \
+} while (0)
+
+static void lglprofsort (LGL * lgl) {
+  int i, ntns, nimportant, nprint;
+  Times * ts = lgl->times;
+  const int sztns = 100;
+  TN tns[sztns];
+  double sum;
+
+  ntns = 0;
+
+  INSTN (analysis, analysis);
+  INSTN (backward, backward);
+  INSTN (bca, bca);
+  INSTN (block, block);
+  INSTN (bump, bump);
+  INSTN (card, card);
+  INSTN (cce, cce);
+  INSTN (decide, decide);
+  INSTN (decompose, decompose);
+  INSTN (defrag, defrag);
+  INSTN (druplig, druplig);
+  INSTN (elim, elim);
+  INSTN (gauss, gauss);
+  INSTN (gc, gc);
+  INSTN (heapdecision, heapdecision);
+  INSTN (locs, locs);
+  INSTN (mincls, mincls);
+  INSTN (phase, phase);
+  INSTN (probe, probe);
+  INSTN (prune, prune);
+  INSTN (quatres1, quatres1);
+  INSTN (quatres2, quatres2);
+  INSTN (quatres, quatres);
+  INSTN (queuedecision, queuedecision);
+  INSTN (queuesort, queuesort);
+  INSTN (redcls, redcls);
+  INSTN (reduce, reduce);
+  INSTN (restart, restart);
+  INSTN (showfeatures, showfeatures);
+  INSTN (showscoredist, showscoredist);
+  INSTN (subl, subl);
+  INSTN (sweep, sweep);
+  INSTN (ternres, ternres);
+  INSTN (transred, transred);
+  INSTN (unhide, unhide);
+
+  // Force insertion sort to avoid implicit memory allocation!
+  // Otherwise an already existing memory corruption will trigger
+  // another signal and thus might result in non-termination.
+
+  ISORT (TN, lglcmptn, tns, ntns);
+
+  sum = 0;
+  assert (ntns > 3);
+  for (nimportant = ntns-1; nimportant > 3; nimportant--) {
+    sum += tns[nimportant].t;
+    if (lglpcnt (sum, ts->all) >= 1.0) break;
+  }
+  if (nimportant == ntns - 1) nimportant++;
+
+  if (!lgl->opts->profilelong.val && lgl->opts->verbose.val < 2)
+    nprint = nimportant;
+  else nprint = ntns;
+
+  for (i = 0; i < nprint; i++) {
+    if (i == nimportant) {
+      if (i) lglprs (lgl, "");
+      lglprs (lgl, "%8.3f < 1%% rest (below)", sum);
+      if (i + 1 < nprint) lglprs (lgl, "");
+    }
+    lglprs (lgl, "%8.3f %3.0f%% %s",
+      tns[i].t, lglpcnt (tns[i].t, ts->all), tns[i].n);
+  }
+
+  if (nimportant == nprint && nprint < ntns) {
+    if (nprint) lglprs (lgl, "");
+    lglprs (lgl, "%8.3f < 1%% rest (not shown)", sum);
+  }
+}
+
+static void lglprof (LGL * lgl) {
+  Times * ts = lgl->times;
+  double t = ts->all, simp, search;
+
+  assert (lgl->opts->verbose.val >= 0);
+  simp = ts->preprocessing + ts->inprocessing;
+  if (!lgl->opts->verbose.val || !lgl->opts->profile.val) goto SHORT;
+
+  lglprofsort (lgl);
+
+  if (!lglignprofptr (lgl, &ts->prb.simple) &&
+      (lgl->opts->profilelong.val ||
+       lgl->opts->verbose.val >= 2 ||
+       ts->prb.simple || ts->prb.basic || ts->prb.treelook)) {
+    lglprs (lgl, "----------------------------------");
+    lglprs (lgl, "%8.3f %3.0f%% probe simple    %3.0f%%",
+      ts->prb.simple,
+      lglpcnt (ts->prb.simple, t),
+      lglpcnt (ts->prb.simple, ts->probe));
+    lglprs (lgl, "%8.3f %3.0f%% probe basic     %3.0f%%",
+      ts->prb.basic,
+      lglpcnt (ts->prb.basic, t),
+      lglpcnt (ts->prb.basic, ts->probe));
+    lglprs (lgl, "%8.3f %3.0f%% probe tree-look %3.0f%%",
+      ts->prb.treelook,
+      lglpcnt (ts->prb.treelook, t),
+      lglpcnt (ts->prb.treelook, ts->probe));
+  }
+  lglprs (lgl, "==================================");
+  lglprs (lgl, "%8.3f %3.0f%% preprocessing   %3.0f%%",
+    ts->preprocessing,
+    lglpcnt (ts->preprocessing, t),
+    lglpcnt (ts->preprocessing, simp));
+  lglprs (lgl, "%8.3f %3.0f%% inprocessing    %3.0f%%",
+    ts->inprocessing,
+    lglpcnt (ts->inprocessing, t),
+    lglpcnt (ts->inprocessing, simp));
+  lglprs (lgl, "==================================");
+SHORT:
+  lglprs (lgl, "%8.3f %3.0f%% simplifying", simp, lglpcnt (simp, t));
+  if (lgl->stats->calls.lkhd)
+    lglprs (lgl, "%8.3f %3.0f%% lookahead",
+      ts->lookahead, lglpcnt (ts->lookahead, t));
+  search = ts->search - ts->inprocessing;
+  lglprs (lgl, "%8.3f %3.0f%% search", search, lglpcnt (search, t));
+  lglprs (lgl, "==================================");
+  lglprs (lgl, "%8.3f %3.0f%% all", t, 100.0);
+}
+
+void lglstats (LGL * lgl) {
+  long long visits, min, p, steps, sum;
+  int remaining, removed;
+  Stats * s;
+  double t;
+  REQINITNOTFORKED ();
+  if (lgl->opts->verbose.val < 0) return;
+  lglflushtimers (lgl);
+  s = lgl->stats;
+  t = lgl->times->all;
+  p = s->props.search + s->props.simp + s->props.lkhd;
+  if (!lgl->opts->verbose.val) goto SHORT;
+
+  lglprs (lgl, "agil: %.2f%% agility",
+    100.0 * (s->agility / (double) (1ll << 32)));
+
+  sum = s->prb.basic.ate.trnr + s->prb.basic.ate.lrg;
+  lglprs (lgl, 
+    "bate: %lld basic ate = %d trn %.0f%% + %d lrg %.0f%% in %d updates",
+    sum, s->prb.basic.ate.trnr, lglpcnt (s->prb.basic.ate.trnr, sum),
+    s->prb.basic.ate.lrg, lglpcnt (s->prb.basic.ate.lrg, sum),
+    s->prb.basic.ate.count);
+
+  lglprs (lgl,
+    "bcas: %d count, %lld added (%lld skipped), %lld steps",
+    s->bca.count, (LGLL) s->bca.added, s->bca.skipped, (LGLL) s->bca.steps);
+
+  lglprs (lgl,
+    "bkwd: tried %lld clauses, %lld lits, %.2f lits/clause",
+    (LGLL) s->bkwd.tried.clauses, (LGLL) s->bkwd.tried.lits,
+    lglavg (s->bkwd.tried.lits, s->bkwd.tried.clauses));
+  lglprs (lgl,
+    "bkwd: checked %lld occs, %.2f occs/clause, %.2f occs/lit",
+    (LGLL) s->bkwd.tried.occs,
+    lglavg (s->bkwd.tried.occs, s->bkwd.tried.clauses),
+    lglavg (s->bkwd.tried.occs, s->bkwd.tried.lits));
+  lglprs (lgl,
+    "bkwd: subsumed %d binary, %d ternary, %d large",
+    s->bkwd.sub2, s->bkwd.sub3, s->bkwd.subl);
+  lglprs (lgl,
+    "bkwd: strengthened %d binary, "
+    "%d ternary (%.0f%% self), %d large (%.0f%% self)",
+    s->bkwd.str2,
+    s->bkwd.str3, lglpcnt (s->bkwd.str3self, s->bkwd.str3),
+    s->bkwd.strl, lglpcnt (s->bkwd.strlself, s->bkwd.strl));
+
+  lglprs (lgl,
+    "blkd: %d bces, %d removed, %lld resolutions, %lld steps",
+    s->blk.count, s->blk.clauses, (LGLL) s->blk.res, (LGLL) s->blk.steps);
+  lglprs (lgl,
+    "blkd: %d blocking literals %.0f%%, %d pure",
+    s->blk.lits, lglpcnt (s->blk.lits, 2*lgl->maxext), s->blk.pure);
+
+  lglprs (lgl,
+    "bump: %lld bumped seen, %lld lits %.1f on average",
+    s->bump.count,
+    (LGLL) s->bump.lits,
+    lglavg (s->bump.lits, s->bump.count));
+
+  lglprs (lgl,
+    "card: %d count, %d units, %d am1, %lld steps",
+    s->card.count, s->card.units, s->card.expam1, (LGLL) s->card.steps);
+  lglprs (lgl,
+    "card: %d rescheduled, %lld eliminated, %lld resolved, %lld subsumed",
+    s->card.resched, (LGLL) s->card.eliminated,
+    (LGLL) s->card.resolved, (LGLL) s->card.subsumed);
+  lglprs (lgl,
+    "card: %d at-most-one constraints found, average size %.2f",
+    s->card.found.am1.total.cnt,
+    lglavg (s->card.found.am1.total.sum, s->card.found.am1.total.cnt));
+  lglprs (lgl,
+    "card: %d at-most-one constraints used %.0f%%, average size %.2f",
+    s->card.used.am1.cnt,
+    lglpcnt (s->card.used.am1.cnt, s->card.found.am1.total.cnt),
+    lglavg (s->card.used.am1.sum, s->card.used.am1.cnt));
+  lglprs (lgl,
+    "card: %d at-most-two constraints found, average size %.2f",
+    s->card.found.am2.total.cnt,
+    lglavg (s->card.found.am2.total.sum, s->card.found.am2.total.cnt));
+  lglprs (lgl,
+    "card: %d at-most-two constraints used %.0f%%, average size %.2f",
+    s->card.used.am2.cnt,
+    lglpcnt (s->card.used.am2.cnt, s->card.found.am2.total.cnt),
+    lglavg (s->card.used.am2.sum, s->card.used.am2.cnt));
+
+  lglprs (lgl,
+    "cces: %d cces, %d eliminated, %d ate %.0f%%, %d abce %.0f%%",
+    s->cce.count, s->cce.eliminated,
+    s->cce.ate, lglpcnt (s->cce.ate, s->cce.eliminated),
+    s->cce.abce, lglpcnt (s->cce.abce, s->cce.eliminated));
+  lglprs (lgl,
+    "cces: %lld probed, %d lifted, %d failed",
+    (LGLL) s->cce.probed, s->cce.lifted, s->cce.failed);
+  lglprs (lgl,
+    "cces: %lld cached, %lld rsz, %lld cols %.0f%%, "
+    "%lld srch, %lld hits %.0f%%",
+    (LGLL) s->cce.cache.ins,
+    (LGLL) s->cce.cache.rsz,
+    (LGLL) s->cce.cache.cols,
+      lglpcnt (s->cce.cache.cols, s->cce.cache.ins),
+    (LGLL) s->cce.cache.search,
+    (LGLL) s->cce.cache.hits,
+      lglpcnt (s->cce.cache.hits, s->cce.cache.search));
+
+  lglprs (lgl,
+    "clls: %lld sat, %lld simp, %lld freeze, %lld melt",
+    (LGLL) s->calls.sat, (LGLL) s->calls.simp,
+    (LGLL) s->calls.freeze, (LGLL) s->calls.melt);
+  lglprs (lgl,
+    "clls: %lld add, %lld assume, %lld deref, %lld failed",
+    (LGLL) s->calls.add, (LGLL) s->calls.assume,
+    (LGLL) s->calls.deref, (LGLL) s->calls.failed);
+  lglprs (lgl,
+    "clls: %lld lkhd, %lld cassume, %lld mosat",
+    (LGLL) s->calls.lkhd, (LGLL) s->calls.cassume, (LGLL) s->calls.mosat);
+
+  lglprs (lgl,
+    "coll: %d gcs, %d rescored clauses, %d rescored vars",
+    s->gcs, s->rescored.clauses, s->rescored.vars);
+
+  lglprs (lgl,
+    "dcps: %d decompositions, %d equivalent %.0f%%",
+	  s->decomps, s->equiv.sum, lglpcnt (s->equiv.sum, lgl->maxext));
+
+  lglprs (lgl,
+    "deco: %lld decision-only clauses %.0f%%, %.0f%% reduction",
+    s->mincls.deco, lglpcnt (s->mincls.deco, s->clauses.learned),
+    lglpcnt (s->deco.sum.orig - s->deco.sum.red, s->deco.sum.orig)); 
+
+  lglprs (lgl,
+    "decs: %lld total, %lld rnd %.3f%%, %lld heap %.3f%, %lld queue %.3f%%",
+    (LGLL) s->decisions,
+    (LGLL) s->randecs, lglpcnt (s->randecs, s->decisions),
+    (LGLL) s->hdecs, lglpcnt (s->hdecs, s->decisions),
+    (LGLL) s->qdecs, lglpcnt (s->qdecs, s->decisions));
+
+  lglprs (lgl,
+    "elms: %d elims, %d eliminated %.0f%%, %d pure %.0f%%",
+     s->elm.count,
+     s->elm.elmd, lglpcnt (s->elm.elmd, lgl->maxext),
+     s->elm.pure, lglpcnt (s->elm.pure, s->elm.elmd));
+  lglprs (lgl,
+    "elms: %d rounds, %.1f rounds/bve",
+    s->elm.rounds, lglavg (s->elm.rounds, s->elm.count));
+  lglprs (lgl,
+    "elms: %d small %.0f%%, %d large %.0f%%",
+    s->elm.small.elm, lglpcnt (s->elm.small.elm, s->elm.elmd),
+    s->elm.large, lglpcnt (s->elm.large, s->elm.elmd));
+  lglprs (lgl,
+    "elms: %d tried small, %d succeeded %.0f%%, %d failed %.0f%%",
+    s->elm.small.tried, s->elm.small.tried - s->elm.small.failed,
+      lglpcnt (s->elm.small.tried - s->elm.small.failed, s->elm.small.tried),
+    s->elm.small.failed,
+      lglpcnt (s->elm.small.failed, s->elm.small.tried));
+  lglprs (lgl,
+    "elms: %d subsumed, %d strengthened, %d blocked",
+    s->elm.sub, s->elm.str, s->elm.blkd);
+  lglprs (lgl,
+    "elms: %lld copies, %lld resolutions, %lld ipos",
+    (LGLL) s->elm.copies, (LGLL) s->elm.resolutions, (LGLL) s->elm.ipos);
+  lglprs (lgl,
+    "elms: %lld subchks, %lld strchks",
+    (LGLL) s->elm.subchks, (LGLL) s->elm.strchks);
+
+  lglprs (lgl,
+    "gaus: %d extractions, %lld extracted, %.1f size, %d max",
+    s->gauss.count, s->gauss.extracted.total,
+    lglavg (s->gauss.arity.sum.total, s->gauss.extracted.total),
+    s->gauss.arity.max);
+  lglprs (lgl,
+    "gaus: %lld exactly-1 constraints of average arity %.1f",
+    s->gauss.extracted.exactly1,
+    lglavg (s->gauss.arity.sum.exactly1, s->gauss.extracted.exactly1));
+  lglprs (lgl,
+    "gaus: exported %d units, %d binary and %d ternary equations",
+    s->gauss.units, s->gauss.equivs, s->gauss.trneqs);
+  steps = s->gauss.steps.extr + s->gauss.steps.extr;
+  lglprs (lgl,
+    "gaus: %d gc, %lld steps, %lld extr %.0f%%, %lld elim %.0f%%",
+    s->gauss.gcs, (LGLL) steps,
+    s->gauss.steps.extr, lglpcnt (s->gauss.steps.extr, steps),
+    s->gauss.steps.elim, lglpcnt (s->gauss.steps.elim, steps));
+
+  lglprs (lgl,
+    "glue: %.1f orig avg, %.1f real avg, %.1f scaled avg",
+    lglavg (s->clauses.glue, s->clauses.learned),
+    lglavg (s->clauses.realglue, s->clauses.learned),
+    lglavg (s->clauses.scglue, s->clauses.learned));
+  lglprs (lgl,
+    "glue: %lld maxscaledglue=%d (%.0f%%), %lld kept %.0f%%",
+    (LGLL) s->clauses.maxglue.count, MAXGLUE,
+    lglpcnt (s->clauses.maxglue.count, s->clauses.learned),
+    (LGLL) s->clauses.maxglue.kept,
+    lglpcnt (s->clauses.maxglue.kept, s->clauses.learned));
+
+  lglprs (lgl,
+    "hbrs: %d = %d simple %.0f%% + %d trn %.0f%% + %d lrg %.0f%%, %d sub %.0f%%",
+    s->hbr.cnt,
+    s->hbr.simple, lglpcnt (s->hbr.simple, s->hbr.cnt),
+    s->hbr.trn, lglpcnt (s->hbr.trn, s->hbr.cnt),
+    s->hbr.lrg, lglpcnt (s->hbr.lrg, s->hbr.cnt),
+    s->hbr.sub, lglpcnt (s->hbr.sub, s->hbr.cnt));
+
+  lglprs (lgl,
+    "locs: %d count, %lld flips, %lld mems, %d minimun",
+    s->locs.count, (LGLL) s->locs.flips, (LGLL) s->locs.mems, s->locs.min);
+
+  assert (s->lits.nonmin >= s->lits.learned);
+  min = s->lits.nonmin - s->lits.learned;
+  lglprs (lgl,
+    "lrnd: %lld clauses, %.1f length",
+    (LGLL) s->clauses.learned,
+    lglavg (s->lits.learned, s->clauses.learned));
+  lglprs (lgl,
+    "lrnd: %lld lits = %lld orig - %lld removed %.0f%%",
+    (LGLL) s->lits.learned,
+    (LGLL) s->lits.nonmin,
+    (LGLL) min, lglpcnt (min, s->lits.nonmin));
+  lglprs (lgl,
+    "lrnd: %lld uips %.0f%%, %lld flips %.0f%%",
+    (LGLL) s->uips, lglpcnt (s->uips, s->clauses.learned),
+    (LGLL) s->decflipped, lglpcnt (s->decflipped, s->clauses.learned));
+
+  sum = s->mincls.min + s->mincls.bin + s->mincls.size + s->mincls.deco;
+  lglprs (lgl,
+    "mins: %lld mins %.0f%%, %lld bin %.0f%%, %lld size %.0f%%",
+    (LGLL) s->mincls.min, lglpcnt (s->mincls.min, sum),
+    (LGLL) s->mincls.bin, lglpcnt (s->mincls.bin, sum),
+    (LGLL) s->mincls.size, lglpcnt (s->mincls.size, sum),
+    (LGLL) s->mincls.deco, lglpcnt (s->mincls.deco, sum));
+  lglprs (lgl,
+    "mins: %lld poisoned searches, %lld hits, %.0f%% hit rate",
+    (LGLL) s->mincls.poison.search, (LGLL) s->mincls.poison.hits,
+    lglpcnt (s->mincls.poison.hits, s->mincls.poison.search));
+  lglprs (lgl,
+    "mins: %lld used twice searches, %lld hits, %.0f%% hit rate",
+    (LGLL) s->mincls.usedtwice.search, (LGLL) s->mincls.usedtwice.hits,
+    lglpcnt (s->mincls.usedtwice.hits, s->mincls.usedtwice.search));
+
+  sum = s->moved.bin + s->moved.trn;
+  lglprs (lgl,
+    "move: moved %lld, %lld bin %.0f%%, %lld trn %.0f%%",
+    sum,
+    (LGLL) s->moved.bin, lglpcnt (s->moved.bin, sum),
+    (LGLL) s->moved.trn, lglpcnt (s->moved.trn, sum));
+
+  sum = s->otfs.str.red + s->otfs.str.irr;
+  assert (sum == s->otfs.total);
+  assert (sum == s->otfs.str.bin + s->otfs.str.trn + s->otfs.str.lrg);
+  lglprs (lgl,
+    "otfs: %lld driving %.0f%%, %lld restarting %.0f%%",
+    (LGLL) s->otfs.driving, lglpcnt (s->otfs.driving, sum),
+    (LGLL) s->otfs.restarting, lglpcnt (s->otfs.restarting, sum));
+  lglprs (lgl,
+    "otfs: str %lld, %lld red %.0f%%, %lld irr %.0f%%",
+    sum,
+    (LGLL) s->otfs.str.red, lglpcnt (s->otfs.str.red, sum),
+    (LGLL) s->otfs.str.irr, lglpcnt (s->otfs.str.irr, sum));
+  lglprs (lgl,
+    "otfs: str %lld, %lld bin %.0f%%, %lld trn %.0f%%, %lld lrg %.0f%%",
+    sum,
+    (LGLL) s->otfs.str.bin, lglpcnt (s->otfs.str.bin, sum),
+    (LGLL) s->otfs.str.trn, lglpcnt (s->otfs.str.trn, sum),
+    (LGLL) s->otfs.str.lrg, lglpcnt (s->otfs.str.lrg, sum));
+
+  sum = s->otfs.sub.red + s->otfs.sub.irr;
+  assert (sum == s->otfs.sub.bin + s->otfs.sub.trn + s->otfs.sub.lrg);
+  lglprs (lgl,
+    "otfs: sub %lld, %lld red %.0f%%, %lld irr %.0f%%",
+    sum,
+    (LGLL) s->otfs.sub.red, lglpcnt (s->otfs.sub.red, sum),
+    (LGLL) s->otfs.sub.irr, lglpcnt (s->otfs.sub.irr, sum));
+  lglprs (lgl,
+    "otfs: sub %lld, %lld bin %.0f%%, %lld trn %.0f%%, %lld lrg %.0f%%",
+    sum,
+    (LGLL) s->otfs.sub.bin, lglpcnt (s->otfs.sub.bin, sum),
+    (LGLL) s->otfs.sub.trn, lglpcnt (s->otfs.sub.trn, sum),
+    (LGLL) s->otfs.sub.lrg, lglpcnt (s->otfs.sub.lrg, sum));
+
+  lglprs (lgl,
+    "phas: %lld computed, %lld set, %lld pos (%.0f%%), %lld neg (%.0f%%)",
+    (LGLL) s->phase.count, (LGLL) s->phase.set,
+    (LGLL) s->phase.pos, lglpcnt (s->phase.pos, s->phase.set),
+    (LGLL) s->phase.neg, lglpcnt (s->phase.neg, s->phase.set));
+  lglprs (lgl,
+    "phas: %lld flipped decision phases randomly %.0f%%",
+    (LGLL) s->randphases,
+    lglpcnt (s->randphases, s->decisions));
+
+  lglprs (lgl,
+    "prbs: %d basic, %lld probed, %d failed, %d lifted",
+    s->prb.basic.count, (LGLL) s->prb.basic.probed,
+    s->prb.basic.failed, s->prb.basic.lifted);
+  lglprs (lgl,
+    "prbs: %d simple, %lld probed, %d failed, %d eqs",
+    s->prb.simple.count, (LGLL) s->prb.simple.probed,
+    s->prb.simple.failed, s->prb.simple.eqs);
+  lglprs (lgl,
+    "prbs: %d treelook, %lld probed, %d failed, %d lifted",
+    s->prb.treelook.count, (LGLL) s->prb.treelook.probed,
+    s->prb.treelook.failed, s->prb.treelook.lifted);
+
+  lglprs (lgl,
+    "prom: %lld locked %.0f%% out of %lld tried",
+    (LGLL) s->promote.locked,
+    lglpcnt (s->promote.locked, s->promote.tried),
+    (LGLL) s->promote.tried);
+
+  lglprs (lgl,
+    "prps: %lld props, %.0f props/dec",
+    (LGLL) p, lglavg (s->props.search, s->decisions));
+  lglprs (lgl,
+    "prps: %.0f%% srch, %.0f%% simp, %.0f%% lkhd",
+    lglpcnt (s->props.search, p), lglpcnt (s->props.simp, p),
+    lglpcnt (s->props.lkhd, p));
+
+  lglprs (lgl,
+    "prun: %lld decisions, %lld pure %.2f%%",
+    (LGLL) s->prune.decs,
+    (LGLL) s->prune.pure, lglpcnt (s->prune.pure, s->prune.decs));
+  lglprs (lgl,
+    "prun: %lld calls, %.1f%% per decision on level %.3f",
+    (LGLL) s->prune.calls,
+    lglavg (s->prune.calls, s->prune.decs),
+    lglavg (s->prune.levels, s->prune.calls));
+  lglprs (lgl,
+    "prun: "
+    "%lld sat %.0f%%, %lld unsat %.0f%%, %lld lim %.0f%%",
+    (LGLL) s->prune.sat, lglpcnt (s->prune.sat, s->prune.calls),
+    (LGLL) s->prune.uns, lglpcnt (s->prune.uns, s->prune.calls),
+    (LGLL) s->prune.lim, lglpcnt (s->prune.lim, s->prune.calls));
+  lglprs (lgl,
+    "prun: %lld child conflicts, %lld decisions, %lld propagations",
+    (LGLL) s->prune.child.confs,
+    (LGLL) s->prune.child.decs,
+    (LGLL) s->prune.child.props);
+
+  lglprs (lgl,
+    "quat: %d count, %lld quat, %lld self1, %lld self2, %lld dup",
+    s->quatres.count,
+    (LGLL) s->quatres.quat,
+    (LGLL) s->quatres.self1,
+    (LGLL) s->quatres.self2,
+    (LGLL) s->quatres.dup);
+ 
+  lglprs (lgl,
+    "queu: %lld flushed, %lld sorted, %lld decisions %.3f%%",
+    (LGLL) s->queue.flushed, (LGLL) s->queue.sorted,
+    (LGLL) s->qdecs, lglpcnt (s->qdecs, s->decisions));
+
+  lglprs (lgl,
+    "redc: %lld clauses %.0f%%, %lld tried %.0f%%, %lld sat %.0f%%",
+    (LGLL) s->redcls.cls.red,
+      lglpcnt (s->redcls.cls.red, s->redcls.cls.tried),
+    (LGLL) s->redcls.cls.tried,
+      lglpcnt (s->redcls.cls.tried, s->confs),
+    (LGLL) s->redcls.cls.sat,
+      lglpcnt (s->redcls.cls.sat, s->redcls.cls.tried));
+  lglprs (lgl,
+    "redc: %lld lits %.0f%%, %lld tried %.0f%%, %lld sat %.0f%%",
+    (LGLL) s->redcls.lits.red,
+      lglpcnt (s->redcls.lits.red, s->redcls.lits.tried),
+    (LGLL) s->redcls.lits.tried,
+      lglpcnt (s->redcls.lits.tried, s->lits.nonmin),
+    (LGLL) s->redcls.lits.sat,
+      lglpcnt (s->redcls.lits.sat, s->redcls.lits.tried));
+  lglprs (lgl,
+    "redc: %lld times jump level reduced, %.1f levels on average",
+    (LGLL) s->redcls.jlevel.red,
+    lglavg (s->redcls.jlevel.sum, s->redcls.jlevel.red));
+
+  lglprs (lgl,
+    "reds: %d count, %.1f conflicts per reduce, %d reset",
+    s->reduced.count, lglavg (s->confs, s->reduced.count),
+    s->reduced.reset);
+  lglprs (lgl,
+    "reds: %d memlim %.0f%%, %d arith %.0f%%",
+    s->reduced.memlim, lglpcnt (s->reduced.memlim, s->reduced.count),
+    s->reduced.arith, lglpcnt (s->reduced.arith, s->reduced.count));
+  sum = s->reduced.collected + s->reduced.retired;
+  lglprs (lgl,
+    "reds: %lld collected %.0f%%, %lld retired %.0f%%",
+    s->reduced.collected, lglpcnt (s->reduced.collected, sum),
+    s->reduced.retired, lglpcnt (s->reduced.retired, sum));
+
+  lglprs (lgl,
+    "rmbd: %d removed, %d red %.0f%%",
+    s->bindup.removed, s->bindup.red,
+    lglpcnt (s->bindup.red, s->bindup.removed));
+
+  lglprs (lgl,
+    "rsts: %lld restarts %.0f%% of checked, %lld skipped %.0f%%",
+    (LGLL) s->restarts.count,
+      lglpcnt (s->restarts.count, s->restarts.checked),
+    (LGLL) s->restarts.skipped,
+      lglpcnt (s->restarts.skipped, s->restarts.checked));
+  lglprs (lgl,
+    "rsts: %lld checks %.0f%%, %lld forced %.0f%%",
+    (LGLL) s->restarts.checked,
+      lglpcnt (s->restarts.checked, s->confs),
+    (LGLL) s->restarts.forced,
+      lglpcnt (s->restarts.forced, s->restarts.checked));
+  lglprs (lgl,
+    "rsts: %lld not forced (%.0f%% of checked, %.0f%% of skipped)",
+    (LGLL) s->restarts.notforced,
+      lglpcnt (s->restarts.notforced, s->restarts.checked),
+      lglpcnt (s->restarts.notforced, s->restarts.skipped));
+  lglprs (lgl,
+    "rsts: %lld agile %.0f%% of skipped, %lld delayed %.0f%%",
+    (LGLL) s->restarts.agile,
+      lglpcnt (s->restarts.agile, s->restarts.skipped),
+    (LGLL) s->restarts.delayed,
+      lglpcnt (s->restarts.delayed, s->restarts.skipped));
+  lglprs (lgl,
+    "rsts: %lld blocked %.2f%% restart, %lld reused %.0f%%",
+    (LGLL) s->restarts.blocked,
+      lglpcnt (s->restarts.blocked, s->restarts.count),
+    (LGLL) s->restarts.reused,
+      lglpcnt (s->restarts.reused, s->restarts.skipped));
+  lglprs (lgl,
+    "rsts: %lld partial reuse %.1f%% of restarts, kept %.1f%%",
+    (LGLL) s->restarts.kept.count,
+    lglpcnt (s->restarts.kept.count, s->restarts.count),
+    lglavg (s->restarts.kept.sum, s->restarts.kept.count));
+  lglprs (lgl,
+    "rsts: %lld delta %.1f avg, %lld penalty %.1f avg",
+    (LGLL) s->restarts.delta.delta,
+      lglavg (s->restarts.delta.delta, s->restarts.delta.count),
+    (LGLL) s->restarts.delta.pen,
+      lglavg (s->restarts.delta.pen, s->restarts.delta.count));
+
+  lglprs (lgl,
+    "scic: %lld set, %.1f%% min, %.1f%% max",
+    (LGLL) s->setscincf.count,
+    s->setscincf.min/10.0, s->setscincf.max/10.0);
+
+  lglprs (lgl,
+    "simp: %d count, %d confs %0.f%%, %d vars %.0f%%",
+    s->simp.count,
+    s->simp.limhit.confs, lglpcnt (s->simp.limhit.confs, s->simp.count),
+    s->simp.limhit.vars, lglpcnt (s->simp.limhit.vars, s->simp.count));
+  lglprs (lgl,
+    "simp: %d its %0.f%%, %d bin %.0f%%, %d trns %.0f%%",
+    s->simp.limhit.its, lglpcnt (s->simp.limhit.its, s->simp.count),
+    s->simp.limhit.bin, lglpcnt (s->simp.limhit.bin, s->simp.count),
+    s->simp.limhit.trn, lglpcnt (s->simp.limhit.trn, s->simp.count));
+
+   lglprs (lgl,
+    "subl: %lld count (%lld tried %.1f), %lld sub out of %lld (%.1f%%)",
+    s->subl.count, s->subl.tried, lglavg (s->subl.tried, s->subl.count),
+    s->subl.sub, s->subl.cands, lglpcnt (s->subl.sub, s->subl.cands));
+
+  lglprs (lgl,
+    "swps: %d count, %lld rounds, %lld queries (%.1f/round)",
+    s->sweep.count, (LGLL) s->sweep.rounds, (LGLL) s->sweep.queries.total,
+    lglavg (s->sweep.queries.total, s->sweep.rounds));
+  lglprs (lgl,
+    "swps: %lld sat calls, %lld unsat (%.1f%% success rate)",
+    s->sweep.sat,
+    s->sweep.unsat, lglavg (s->sweep.confs, s->sweep.sat));
+  lglprs (lgl,
+    "swps: %lld decisions %.1f, %lld conflicts %.1f",
+    (LGLL) s->sweep.decs, lglavg (s->sweep.decs, s->sweep.sat),
+    (LGLL) s->sweep.confs, lglavg (s->sweep.confs, s->sweep.sat));
+  lglprs (lgl,
+    "swps; %.1f avg class size, %.1f avg environment size",
+    lglavg (s->sweep.sumsize.classes, s->sweep.queries.total),
+    lglavg (s->sweep.sumsize.envs, s->sweep.sat));
+  lglprs (lgl,
+    "swps: %d failed, %d impls, %d equivs",
+    s->sweep.failed, s->sweep.impls, s->sweep.equivs);
+
+  lglprs (lgl,
+    "swp0: %lld type 0 queries, %lld unsat (%.1f%%), %lld sat (%.1f%%)",
+    (LGLL) s->sweep.queries.type[0].count,
+    (LGLL) s->sweep.queries.type[0].unsat,
+    lglpcnt (s->sweep.queries.type[0].unsat, s->sweep.queries.type[0].count),
+    (LGLL) s->sweep.queries.type[0].sat,
+    lglpcnt (s->sweep.queries.type[0].sat, s->sweep.queries.type[0].count));
+  lglprs (lgl,
+    "swp1: %lld type 1 queries, %lld unsat (%.1f%%), %lld sat (%.1f%%)",
+    (LGLL) s->sweep.queries.type[1].count,
+    (LGLL) s->sweep.queries.type[1].unsat,
+    lglpcnt (s->sweep.queries.type[1].unsat, s->sweep.queries.type[1].count),
+    (LGLL) s->sweep.queries.type[1].sat,
+    lglpcnt (s->sweep.queries.type[1].sat, s->sweep.queries.type[1].count));
+  lglprs (lgl,
+    "swp2: %lld type 2 queries, %lld unsat (%.1f%%), %lld sat (%.1f%%)",
+    (LGLL) s->sweep.queries.type[2].count,
+    (LGLL) s->sweep.queries.type[2].unsat,
+    lglpcnt (s->sweep.queries.type[2].unsat, s->sweep.queries.type[2].count),
+    (LGLL) s->sweep.queries.type[2].sat,
+    lglpcnt (s->sweep.queries.type[2].sat, s->sweep.queries.type[2].count));
+
+  lglprs (lgl,
+    "sync: %lld produced units, %lld successful consumptions %.0f%%",
+    s->sync.units.produced, s->sync.units.consumed.actual,
+    lglpcnt (s->sync.units.consumed.actual, s->sync.units.produced));
+  lglprs (lgl,
+    "sync: %lld consume units calls, %lld tried %.0f%%, %lld success %.0f%%",
+    s->sync.units.consumed.calls,
+    s->sync.units.consumed.tried,
+    lglpcnt (s->sync.units.consumed.tried, s->sync.units.consumed.calls),
+    s->sync.units.consumed.actual,
+    lglpcnt (s->sync.units.consumed.actual, s->sync.units.consumed.calls));
+  lglprs (lgl,
+    "sync: %lld produced clauses, %lld successful consumptions %.0f%%",
+    s->sync.cls.produced, s->sync.cls.consumed.actual,
+    lglpcnt (s->sync.cls.consumed.actual, s->sync.cls.produced));
+  lglprs (lgl,
+    "sync: %lld consume clause calls, %lld tried %.0f%%, %lld success %.0f%%",
+    s->sync.cls.consumed.calls,
+    s->sync.cls.consumed.tried,
+    lglpcnt (s->sync.cls.consumed.tried, s->sync.cls.consumed.calls),
+    s->sync.cls.consumed.actual,
+    lglpcnt (s->sync.cls.consumed.actual, s->sync.cls.consumed.calls));
+
+  lglprs (lgl, "time: %lld calls to obtain time", (LGLL) s->times);
+
+  lglprs (lgl,
+    "tops: %d fixed %.0f%%, %d its, %.2f confs/it",
+    s->fixed.sum, lglpcnt (s->fixed.sum, lgl->maxext), 
+    s->its.count, lglavg (s->confs, s->its.count));
+
+  lglprs (lgl,
+    "trds: %d transitive reductions, %d removed, %d failed",
+    s->trd.count, s->trd.red, s->trd.failed);
+  lglprs (lgl,
+    "trds: %lld nodes, %lld edges, %lld steps",
+    (LGLL) s->trd.lits, (LGLL) s->trd.bins, (LGLL) s->trd.steps);
+
+  lglprs (lgl, "trim: %lld words, %.1f MB",
+    (LGLL) s->trims, (s->trims * sizeof (int)) / (double)(1<<20));
+
+  lglprs (lgl,
+    "trnr: %d count, %d bin, %d trn, %lld steps",
+    s->ternres.count, s->ternres.bin,
+    s->ternres.trn, (LGLL) s->ternres.steps);
+
+  lglprs (lgl,
+    "unhd: %d count, %d rounds, %lld steps",
+    s->unhd.count, s->unhd.rounds, (LGLL) s->unhd.steps);
+  lglprs (lgl,
+    "unhd: %d non-trivial sccs of average size %.1f",
+    s->unhd.stamp.sccs,
+    lglavg (s->unhd.stamp.sumsccsizes, s->unhd.stamp.sccs));
+  sum = lglunhdunits (lgl);
+  lglprs (lgl,
+    "unhd: %lld units, %d bin, %d trn, %d lrg",
+    sum, s->unhd.units.bin, s->unhd.units.trn, s->unhd.units.lrg);
+  sum = lglunhdfailed (lgl);
+  lglprs (lgl,
+    "unhd: %lld failed, %d stamp, %d lits, %d bin, %d trn, %d lrg",
+    sum, s->unhd.stamp.failed, s->unhd.failed.lits,
+    s->unhd.failed.bin, s->unhd.failed.trn, s->unhd.units.lrg);
+  sum = lglunhdtauts (lgl);
+  lglprs (lgl,
+    "unhd: %lld tauts, %d bin %.0f%%, %d trn %.0f%%, %d lrg %.0f%%",
+    sum,
+    s->unhd.tauts.bin, lglpcnt (s->unhd.tauts.bin, sum),
+    s->unhd.tauts.trn, lglpcnt (s->unhd.tauts.trn, sum),
+    s->unhd.tauts.lrg, lglpcnt (s->unhd.tauts.lrg, sum));
+  lglprs (lgl,
+    "unhd: %lld tauts, %d stamp %.0f%%, %d red %.0f%%",
+    sum,
+    s->unhd.stamp.trds, lglpcnt (s->unhd.stamp.trds, sum),
+    s->unhd.tauts.red, lglpcnt (s->unhd.tauts.red, sum));
+  sum = lglunhdhbrs (lgl);
+  lglprs (lgl,
+    "unhd: %lld hbrs, %d trn %.0f%%, %d lrg %.0f%%, %d red %.0f%%",
+    sum,
+    s->unhd.hbrs.trn, lglpcnt (s->unhd.hbrs.trn, sum),
+    s->unhd.hbrs.lrg, lglpcnt (s->unhd.hbrs.lrg, sum),
+    s->unhd.hbrs.red, lglpcnt (s->unhd.hbrs.red, sum));
+  sum = lglunhdstrd (lgl);
+  lglprs (lgl,
+    "unhd: %lld str, %d bin %.0f%%, %d trn %.0f%%, %d lrg %.0f%%, %d red %.0f%%",
+    sum,
+    s->unhd.units.bin, lglpcnt (s->unhd.units.bin, sum),
+    s->unhd.str.trn, lglpcnt (s->unhd.str.trn, sum),
+    s->unhd.str.lrg, lglpcnt (s->unhd.str.lrg, sum),
+    s->unhd.str.red, lglpcnt (s->unhd.str.red, sum));
+
+  removed = s->fixed.sum + s->elm.elmd + s->equiv.sum;
+  remaining = lgl->maxext - removed;
+  assert (remaining >= 0);
+  lglprs (lgl,
+    "vars: %d remaining %.0f%% and %d removed %.0f%% out of %d",
+    remaining, lglpcnt (remaining, lgl->maxext),
+    removed, lglpcnt (removed, lgl->maxext), lgl->maxext);
+  lglprs (lgl,
+    "vars: %d fixed %.0f%%, %d eliminated %.0f%%, %d equivalent %.0f%%",
+    s->fixed.sum, lglpcnt (s->fixed.sum, lgl->maxext),
+    s->elm.elmd, lglpcnt (s->elm.elmd, lgl->maxext),
+    s->equiv.sum, lglpcnt (s->equiv.sum, lgl->maxext));
+
+  visits = s->visits.search + s->visits.simp + s->visits.lkhd;
+  lglprs (lgl,
+    "vsts: %lld visits, %.0f%% srch, %.0f%% simp, %.0f%% lkhd",
+    (LGLL) visits, lglpcnt (s->visits.search, visits),
+    lglpcnt (s->visits.simp, visits), lglpcnt (s->visits.lkhd, visits));
+  lglprs (lgl,
+    "vsts: %.1f search visits per propagation, %.1f per conflict",
+    lglavg (s->visits.search, s->props.search),
+    lglavg (s->visits.search, s->confs));
+
+  lglprs (lgl,
+    "wchs: %lld pushed, %lld enlarged, %d defrags",
+    (LGLL) s->pshwchs, (LGLL) s->enlwchs, s->defrags);
+
+  lglprsline (lgl);
+  lglgluestats (lgl);
+  lglprsline (lgl);
+
+#ifndef NLGLDRUPLIG
+  if (lgl->druplig) {
+    druplig_stats (lgl->druplig, lgl->out);
+    lglprsline (lgl);
+  }
+#endif
+
+SHORT:
+  lglprof (lgl);
+  lglprsline (lgl);
+  lglprs (lgl,
+    "%13lld conflicts,    %10.1f confs/sec",
+    (LGLL) s->confs, lglavg (s->confs, t));
+  lglprs (lgl,
+    "%13lld ternaries,    %10.1f confs/ternary",
+    (LGLL) s->trns, lglavg (s->confs, s->trns));
+  lglprs (lgl,
+    "%13lld binaries,     %10.1f confs/binary",
+    (LGLL) s->bins, lglavg (s->confs, s->bins));
+  lglprs (lgl,
+    "%13lld iterations,   %10.1f confs/iteration",
+    (LGLL) s->its.count, lglavg (s->confs, s->its.count));
+  lglprsline (lgl);
+  lglprs (lgl,
+    "%13lld reductions,   %10.1f redus/sec, %8.1f confs/reduction",
+    (LGLL) s->reduced.count,
+    lglavg (s->reduced.count, t), lglavg (s->confs, s->reduced.count));
+  lglprs (lgl,
+    "%13lld restarts,     %10.1f rests/sec, %8.1f confs/restart",
+    (LGLL) s->restarts.count,
+    lglavg (s->restarts.count, t), lglavg (s->confs, s->restarts.count));
+  lglprs (lgl,
+    "%13lld decisions,    %10.1f decis/sec, %8.1f decis/conflict",
+    (LGLL) s->decisions,
+    lglavg (s->decisions, t), lglavg (s->decisions, s->confs));
+  lglprs (lgl,
+    "%13lld propagations, %10.1f props/sec, %8.1f props/decision",
+    (LGLL) p, lglavg (p, t), lglavg (p, s->decisions));
+  lglprsline (lgl);
+  lglprs (lgl, "%.1f seconds, %.1f MB", t, lglmaxmb (lgl));
+  fflush (lgl->out);
+}
+
+int64_t lglgetprops (LGL * lgl) {
+  REQINITNOTFORKED ();
+  return lgl->stats->props.search + lgl->stats->props.simp;
+}
+
+int64_t lglgetconfs (LGL * lgl) {
+  REQINITNOTFORKED ();
+  return lgl->stats->confs;
+}
+
+int64_t lglgetdecs (LGL * lgl) {
+  REQINITNOTFORKED ();
+  return lgl->stats->decisions;
+}
+
+void lglsizes (LGL * lgl) {
+  lglprt (lgl, 0, "sizeof (int) == %ld", (long) sizeof (int));
+  lglprt (lgl, 0, "sizeof (unsigned) == %ld", (long) sizeof (unsigned));
+  lglprt (lgl, 0, "sizeof (void*) == %ld", (long) sizeof (void*));
+  lglprt (lgl, 0, "sizeof (Stk) == %ld", (long) sizeof (Stk));
+  lglprt (lgl, 0, "sizeof (Fun) == %ld", (long) sizeof (Fun));
+  lglprt (lgl, 0, "sizeof (AVar) == %ld", (long) sizeof (AVar));
+  lglprt (lgl, 0, "sizeof (DVar) == %ld", (long) sizeof (DVar));
+  lglprt (lgl, 0, "sizeof (QVar) == %ld", (long) sizeof (QVar));
+  lglprt (lgl, 0, "sizeof (EVar) == %ld", (long) sizeof (EVar));
+  lglprt (lgl, 0, "sizeof (Stats.lir) == %ld", (long) sizeof ((Stats*)0)->lir);
+  lglprt (lgl, 0, "sizeof (Stats) == %ld", (long) sizeof (Stats));
+  lglprt (lgl, 0, "sizeof (LGL) == %ld", (long) sizeof (LGL));
+  lglprt (lgl, 0, "MAXVAR == %ld", (long) MAXVAR);
+  lglprt (lgl, 0, "MAXREDLIDX == %ld", (long) MAXREDLIDX);
+  lglprt (lgl, 0, "MAXIRRLIDX == %ld", (long) MAXIRRLIDX);
+}
+
+#define LGLRELSTK(MGR,STKPTR) \
+do { \
+  assert (lglmtstk (STKPTR)); \
+  lglrelstk ((MGR), (STKPTR)); \
+} while (0)
+
+void lglrelease (LGL * lgl) {
+  lgldealloc dealloc;
+  int i;
+
+  REQINIT ();
+  if (lgl->clone) lglrelease (lgl->clone), lgl->clone = 0;
+  TRAPI ("release");
+
+#ifndef NLGLDRUPLIG
+  if (lgl->druplig) druplig_reset (lgl->druplig), lgl->druplig = 0;
+#endif
+
+  // Heap state starts here:
+
+  DEL (lgl->avars, lgl->szvars);
+  DEL (lgl->doms, 2*lgl->szvars);
+  DEL (lgl->drail, lgl->szdrail);
+  DEL (lgl->dvars, lgl->szvars);
+  DEL (lgl->ext, lgl->szext);
+  DEL (lgl->i2e, lgl->szvars);
+  DEL (lgl->jwh, 2*lgl->szvars);
+  DEL (lgl->qvars, lgl->szvars);
+  DEL (lgl->vals, lgl->szvars);
+
+  lglrelctk (lgl, &lgl->control);
+
+  lglrelstk (lgl, &lgl->assume);
+#ifndef NDEBUG
+  lglrelstk (lgl, &lgl->prevclause);
+#endif
+  lglrelstk (lgl, &lgl->clause);
+  lglrelstk (lgl, &lgl->dsched);
+  lglrelstk (lgl, &lgl->queue.stk);
+  lglrelstk (lgl, &lgl->eassume);
+  lglrelstk (lgl, &lgl->eclause);
+  lglrelstk (lgl, &lgl->extend);
+  lglrelstk (lgl, &lgl->learned);
+  lglrelstk (lgl, &lgl->frames);
+  lglrelstk (lgl, &lgl->promote);
+  lglrelstk (lgl, &lgl->trail);
+  lglrelstk (lgl, &lgl->wchs->stk);
+
+#ifndef NCHKSOL
+  lglrelstk (lgl, &lgl->orig);
+#endif
+
+  lglrelstk (lgl, &lgl->irr);
+  for (i = 0; i <= MAXGLUE; i++) lglrelstk (lgl, &lgl->red[i]);
+
+  // The following heap allocated memory has no state:
+
+  LGLRELSTK (lgl, &lgl->lcaseen);
+  LGLRELSTK (lgl, &lgl->resolvent);
+  LGLRELSTK (lgl, &lgl->minstk);
+  LGLRELSTK (lgl, &lgl->poisoned);
+  LGLRELSTK (lgl, &lgl->seen);
+
+  lglrelstk (lgl, &lgl->saved.bin);
+  lglrelstk (lgl, &lgl->saved.trn);
+
+  DEL (lgl->limits, 1);
+  DEL (lgl->times, 1);
+  DEL (lgl->timers, 1);
+  DEL (lgl->red, MAXGLUE+1);
+  DEL (lgl->wchs, 1);
+
+  if (lgl->fltstr) DEL (lgl->fltstr, 1);
+  if (lgl->cbs) DEL (lgl->cbs, 1);		// next to last
+  lgldelstr (lgl, lgl->prefix);			// last
+
+  // adjust upfront the mem counters ...
+
+  lgldec (lgl, sizeof *lgl->stats);
+  lgldec (lgl, sizeof *lgl->opts);
+  lgldec (lgl, sizeof *lgl->mem);
+  lgldec (lgl, sizeof *lgl);
+
+  assert (getenv ("LGLEAK") || !lgl->stats->bytes.current);
+
+  if (lgl->closeapitrace == 1) fclose (lgl->apitrace);
+  if (lgl->closeapitrace == 2) pclose (lgl->apitrace);
+
+  if ((dealloc = lgl->mem->dealloc)) {
+     void * memstate = lgl->mem->state;
+     if (lgl->stats) dealloc (memstate, lgl->stats, sizeof *lgl->stats);
+     if (lgl->times) dealloc (memstate, lgl->times, sizeof *lgl->times);
+     if (lgl->opts) dealloc (memstate, lgl->opts, sizeof *lgl->opts);
+     assert (lgl->mem);
+     dealloc (memstate, lgl->mem, sizeof *lgl->mem);
+     dealloc (memstate, lgl, sizeof *lgl);
+  } else {
+    free (lgl->stats);
+    free (lgl->times);
+    free (lgl->opts);
+    free (lgl->mem);
+    free (lgl);
+  }
+}
+
+void lglutrav (LGL * lgl, void * state, void (*trav)(void *, int)) {
+  int elit, val;
+  REQINITNOTFORKED ();
+  if (!lgl->mt && !lglbcp (lgl)) lglmt (lgl);
+  if (!lgl->mt) lglgc (lgl);
+  if (lgl->mt) return;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  for (elit = 1; elit <= lgl->maxext; elit++) {
+    if (!(val = lglefixed (lgl, elit))) continue;
+    trav (state, (val < 0) ? -elit : elit);
+  }
+}
+
+void lgletrav (LGL * lgl, void * state, void (*trav)(void *, int, int)) {
+  int elit, erepr;
+  REQINITNOTFORKED ();
+  if (!lgl->mt && !lglbcp (lgl)) lglmt (lgl);
+  if (!lgl->mt) lglgc (lgl);
+  if (lgl->mt) return;
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  for (elit = 1; elit <= lgl->maxext; elit++) {
+    if (lglefixed (lgl, elit)) continue;
+    erepr = lglerepr (lgl, elit);
+    if (erepr == elit) continue;
+    trav (state, elit, erepr);
+  }
+}
+
+static void lglictrav (LGL * lgl,
+  int internal, int redtoo,
+  void * state, void (*trav)(void *, int red, int lit))
+{
+  int idx, sign, lit, blit, tag, red, other, other2;
+  const int * p, * w, * eow, * c;
+  int glue;
+  HTS * hts;
+  REQINITNOTFORKED ();
+  if (lgl->mt) { trav (state, 0, 0); return; }
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	red = blit & REDCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (!redtoo && red) continue;
+	if (tag != BINCS && tag != TRNCS) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	if (tag == TRNCS) {
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	} else other2 = 0;
+	trav (state, red, internal ? lit : lglexport (lgl, lit));
+	trav (state, red, internal ? other : lglexport (lgl, other));
+	if (other2) trav (state, red,
+	                  internal ? other2 : lglexport (lgl, other2));
+	trav (state, red, 0);
+      }
+    }
+  }
+  for (glue = -1; glue < MAXGLUE; glue++) {
+    const int * start = glue < 0 ? lgl->irr.start : lgl->red[glue].start;
+    const int * top = glue < 0 ? lgl->irr.top : lgl->red[glue].top;
+    const int red = (glue >= 0);
+    if (!redtoo && red) break;
+    for (c = start; c < top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      while ((other = *p)) {
+	trav (state, red, internal ? other : lglexport (lgl, other));
+	p++;
+      }
+      trav (state, red, 0);
+    }
+  }
+}
+
+struct IrrTrav {
+  void * state;
+  void (*trav) (void *, int);
+};
+
+typedef struct IrrTrav IrrTrav;
+
+static void lglirrtrav (void * state, int red, int lit) {
+  IrrTrav * irrtrav = state;
+  assert (!red), (void) red;
+  irrtrav->trav (irrtrav->state, lit);
+}
+
+void lglctrav (LGL * lgl, void * state, void (*trav)(void *, int)) {
+  IrrTrav irrtrav;
+  irrtrav.state = state;
+  irrtrav.trav = trav;
+  if (lgl->level) lglbacktrack (lgl, 0);
+  if (!lgl->mt && !lglbcp (lgl)) lglmt (lgl);
+  if (!lgl->mt) lglgc (lgl);
+  lglictrav (lgl, 0, 0, &irrtrav, lglirrtrav);
+}
+
+static void lgltravcounter (void * voidptr, int lit) {
+  int * cntptr = voidptr;
+  if (!lit) *cntptr += 1;
+}
+
+static void lgltravprinter (void * voidptr, int lit) {
+  FILE * out = voidptr;
+  if (lit) fprintf (out, "%d ", lit);
+  else fprintf (out, "0\n");
+}
+
+void lglprint (LGL * lgl, FILE * file) {
+  int count = 0;
+  lglctrav (lgl, &count, lgltravcounter);
+  fprintf (file, "p cnf %d %d\n", lglmaxvar (lgl), count);
+  lglctrav (lgl, file, lgltravprinter);
+}
+
+void lglprintall (LGL * lgl, FILE * file) {
+  int count = 0;
+  lgltravall (lgl, &count, lgltravcounter);
+  fprintf (file, "p cnf %d %d\n", lglmaxvar (lgl), count);
+  lgltravall (lgl, file, lgltravprinter);
+}
+
+void lglrtrav (LGL * lgl, void * state, void (*trav)(void *, int, int)) {
+  int idx, sign, lit, blit, tag, red, other, other2, glue;
+  const int * p, * c, * w, * eow;
+  Stk * lir;
+  HTS * hts;
+  REQINITNOTFORKED ();
+  if (lgl->mt) return;
+  lglgc (lgl);
+  if (lgl->level > 0) lglbacktrack (lgl, 0);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    if (lglval (lgl, idx)) continue;
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	red = blit & REDCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (!red) continue;
+	if (tag != BINCS && tag != TRNCS) continue;
+	other = blit >> RMSHFT;
+	if (abs (other) < idx) continue;
+	assert (!lglval (lgl, other));
+	if (tag == TRNCS) {
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	  assert (!lglval (lgl, other2));
+	} else other2 = 0;
+	trav (state, lglexport (lgl, lit), 0);
+	trav (state, lglexport (lgl, other), 0);
+	if (other2) trav (state, lglexport (lgl, other2), 0);
+	trav (state, 0, 0);
+      }
+    }
+  }
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    lir = lgl->red + glue;
+    for (c = lir->start; c < lir->top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      while ((other = *p)) {
+	assert (!lglval (lgl, other));
+	trav (state, lglexport (lgl, other), 0);
+	p++;
+      }
+      trav (state, 0, 0);
+    }
+  }
+}
+
+static void lgltravallu (void * voidptr, int unit) {
+  Trv * state = voidptr;
+  state->trav (state->state, unit);
+  state->trav (state->state, 0);
+}
+
+static void lgltravalle (void * voidptr, int lit, int repr) {
+  Trv * state = voidptr;
+  state->trav (state->state, -lit);
+  state->trav (state->state, repr);
+  state->trav (state->state, 0);
+  state->trav (state->state, lit);
+  state->trav (state->state, -repr);
+  state->trav (state->state, 0);
+}
+
+void lgltravall (LGL * lgl, void * state, void (*trav)(void *, int)) {
+  Trv travstate;
+  travstate.state = state;
+  travstate.trav = trav;
+  lglutrav (lgl, &travstate, lgltravallu);
+  lgletrav (lgl, &travstate, lgltravalle);
+  lglctrav (lgl, state, trav);
+}
+
+#ifndef NDEBUG
+
+void lgldump (LGL * lgl) {
+  int idx, sign, lit, blit, tag, red, other, other2, glue;
+  const int * p, * w, * eow, * c, * top;
+  Stk * lir;
+  HTS * hts;
+  for (idx = 2; idx < lgl->nvars; idx++)
+    for (sign = -1; sign <= 1; sign += 2) {
+      lit = sign * idx;
+      hts = lglhts (lgl, lit);
+      w = lglhts2wchs (lgl, hts);
+      eow = w + hts->count;
+      for (p = w; p < eow; p++) {
+	blit = *p;
+	tag = blit & MASKCS;
+	red = blit & REDCS;
+	if (tag == TRNCS || tag == LRGCS) p++;
+	if (tag == BINCS) {
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  other2 = 0;
+	} else if (tag == TRNCS) {
+	  other = blit >> RMSHFT;
+	  if (abs (other) < idx) continue;
+	  other2 = *p;
+	  if (abs (other2) < idx) continue;
+	} else continue;
+	fprintf (lgl->out, "%s %d %d", red ? "red" : "irr", lit, other);
+	if (tag == TRNCS) fprintf (lgl->out, " %d", other2);
+	fprintf (lgl->out, "\n");
+      }
+    }
+  top = lgl->irr.top;
+  for (c = lgl->irr.start; c < top; c = p + 1) {
+    p = c;
+    if (*p >= NOTALIT) continue;
+    fprintf (lgl->out, "irr");
+    while (*p) fprintf (lgl->out, " %d", *p++);
+    fprintf (lgl->out, "\n");
+  }
+  for (glue = 0; glue < MAXGLUE; glue++) {
+    lir = lgl->red + glue;
+    top = lir->top;
+    for (c = lir->start; c < top; c = p + 1) {
+      p = c;
+      if (*p >= NOTALIT) continue;
+      fprintf (lgl->out, "glue%d", glue);
+      while (*p) fprintf (lgl->out, " %d", *p++);
+      fprintf (lgl->out, "\n");
+    }
+  }
+}
+
+#endif
+
+static void lglforkadd (void * ptr, int red, int lit) {
+  assert (!red);
+  lgladd (ptr, lit ? lglforklit (lit) : 0);
+}
+
+LGL * lglfork (LGL * parent) {
+  LGL * child;
+  {
+    LGL * lgl = parent;
+    REQINIT ();
+    ABORTIF (!lglmtstk (&parent->eassume), "can not fork under assumptions");
+    ABORTIF (parent->forked == INT_MAX, "parent forked too often");
+  }
+  if (parent->level > 0) lglbacktrack (parent, 0);
+  (void) lglbcp (parent);
+  lglgc (parent);
+  child = lglminit (parent->mem->state,
+                    parent->mem->alloc,
+                    parent->mem->realloc,
+                    parent->mem->dealloc);
+  child->parent = parent;
+  lglcopyclonenfork (child, parent);
+  if (parent->level) lglbacktrack (parent, 0);
+  if (!parent->mt && !lglbcp (parent)) lglmt (parent);
+  if (!parent->mt) lglgc (parent);
+  lglictrav (parent, 1, 0, child, lglforkadd);
+  assert (parent->stats->irr.clauses.cur == child->stats->irr.clauses.cur);
+  parent->forked++;
+  assert (parent->forked > 0);
+  lglprt (parent, 1, "forked-%d", parent->forked);
+  return child;
+}
+
+static void lglflass (LGL * lgl, LGL * from) {
+  int idx, copied = 0;
+  assert (!lgl->level), assert (!lgl->mt);
+  assert ((from->state & (SATISFIED | EXTENDED)));
+  if (lgl->nvars) assert (lgl->nvars == from->maxext + 2);
+  else assert (!from->maxext);
+  lglreset (lgl);
+  for (idx = 2; idx < lgl->nvars; idx++) {
+    int val = lglderef (from, idx-1);
+    int lit = val < 0 ? -idx : idx;
+    lgldassume (lgl, lit);
+    copied++;
+  }
+  lglprt (lgl, 1, "[flass] copied %d internal assignments", copied);
+  TRANS (SATISFIED);
+  lglextend (lgl);
+#ifndef NCHKSOL
+  lglchksol (lgl);
+#endif
+}
+
+int lgljoin (LGL * parent, LGL * child) {
+  int res;
+  {
+    LGL * lgl = parent;
+    ABORTIF (!parent, "uninitialized parent manager");
+    ABORTIF (!child, "uninitialized child manager");
+    ABORTIF (!parent->forked, "parent manager not forked");
+    ABORTIF (!child->parent, "child manager has not parent");
+    ABORTIF (child->parent != parent, "child manager has different parent");
+    ABORTIF (!lglmtstk (&child->eassume),
+      "child manager with assumptions not supported yet");
+  }
+  if (child->mt || (child->state & UNSATISFIED)) {
+#ifndef NLGLOG
+    LGL * lgl = parent;
+#endif
+    assert (child->mt);				  // no assumptions yet ...
+    lglprt (parent, 1, "[join] unsatisfied state");
+    if (!parent->mt) {
+      LOG (1, "joining empty clause");
+      parent->mt = 1;
+    } else LOG (1, "no need to join empty clause since parent has one");
+    res = 20;
+  } else if (child->state & (SATISFIED | EXTENDED)) {
+    lglprt (parent, 1, "[join] satisfied state");
+    lglflass (parent, child);
+    res = 10;
+  } else {
+    lglprt (parent, 1, "[join] unknown state");
+    lglreset (parent);
+    {
+      LGL * lgl = parent;
+      TRANS (UNKNOWN);
+    }
+    res = 0;
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int lglnextch (FILE * in, int *linenoptr) {
+  int res = getc (in);
+  if (res == '\n') *linenoptr += 1;
+  return res;
+}
+
+static char isoptchartab[256];
+static int isoptchartabinitialized;
+
+static int isoptchar (unsigned char uch) { 
+  int i;
+  if (!isoptchartabinitialized) {
+    for (i = 'a'; i <= 'z'; i++) isoptchartab[i] = 1;
+    for (i = 'A'; i <= 'Z'; i++) isoptchartab[i] = 1;
+    for (i = '0'; i <= '9'; i++) isoptchartab[i] = 1;
+    isoptchartab['-'] = isoptchartab['_'] = 1;
+    isoptchartabinitialized = 1;
+  }
+  return isoptchartab[uch];
+}
+
+static void lglenlbuf (LGL * lgl, Buf * b) {
+  size_t new_size = b->size ? 2 * b->size : 2;
+  RSZ (b->start, b->size, new_size);
+  b->size = new_size;
+}
+
+static void lglpushbuf (LGL * lgl, Buf * buf, int ch) {
+  if (buf->count + 1 >= buf->size) lglenlbuf (lgl, buf);
+  assert (buf->count + 1 < buf->size);
+  buf->start[buf->count++] = ch;
+  buf->start[buf->count] = 0;
+}
+
+const char *
+lglparsefile (LGL * lgl, FILE * in, int force, int * lp, int * mp) {
+  int ch, prev, m, n, v, c, l, lit, sign, val, embedded = 0, header, section;
+  Buf buf;
+  CLR (buf);
+SKIP:
+  ch = lglnextch (in, lp);
+  if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') goto SKIP;
+  if (ch == 'c') {
+    ch  = lglnextch (in, lp);
+    while (ch != '\n') {
+      if (ch == EOF) return "end of file in comment";
+      prev = ch;
+      ch = lglnextch (in, lp);
+      if (prev != '-') continue;
+      if (ch != '-') continue;
+      assert (!buf.count);
+      ch = lglnextch (in, lp);
+      while (isoptchar (ch)) {
+	assert (ch != '\n');
+	lglpushbuf (lgl, &buf, ch);
+	ch = lglnextch (in, lp);
+      }
+      buf.count = 0;
+      if (ch != '=') continue;
+      ch = lglnextch (in, lp);
+      if (ch == '-') sign = -1, ch = lglnextch (in, lp); else sign = 1;
+      if (!isdigit (ch)) continue;
+      val = ch - '0';
+      while (isdigit (ch = lglnextch (in, lp)))
+	val = 10 * val + (ch - '0');
+
+      if (!lglhasopt (lgl, buf.start)) {
+	lglwrn (lgl, "parsed invalid embedded option '--%s'\n", buf.start);
+	continue;
+      }
+
+      val *= sign;
+
+      if (!embedded++)
+	lglprt (lgl, 1, ""),
+	lglprt (lgl, 1, "embedded options"),
+	lglprt (lgl, 1, "");
+      if (!strcmp (buf.start, "verbose")) lgl->opts->verbose.val = val;
+      lglprt (lgl, 1, "--%s=%d\n", buf.start, val);
+      lglsetopt (lgl, buf.start, val);
+    }
+    goto SKIP;
+  }
+  DEL (buf.start, buf.size);
+  if (lgl->opts->verbose.val >= 0) {
+     if (embedded) lglprt (lgl, 1, "");
+     else lglprt (lgl, 1,  "no embedded options");
+  }
+  header = section = m = n = v = l = c = 0;
+  if (force) {
+    if (ch == 'p')  {
+      lglprt (lgl, 1, "will not read header");
+      while ((ch = lglnextch (in, lp)) != '\n' && ch != EOF)
+	;
+    } else lglprt (lgl, 1, "skipping missing header");
+    goto BODY2;
+  }
+  if (ch != 'p') return "missing 'p ...' header";
+  if (lglnextch (in, lp) != ' ')
+    return "invalid header: expected ' ' after 'p'";
+  while ((ch = lglnextch (in, lp)) == ' ')
+    ;
+  if (ch != 'c') return "invalid header: expected 'c' after ' '";
+  if (lglnextch (in, lp) != 'n')
+    return "invalid header: expected 'n' after 'c'";
+  if (lglnextch (in, lp) != 'f')
+    return "invalid header: expected 'f' after 'n'";
+  if (lglnextch (in, lp) != ' ')
+    return "invalid header: expected ' ' after 'f'";
+  while ((ch = lglnextch (in, lp)) == ' ')
+    ;
+  if (!isdigit (ch)) return "invalid header: expected digit after 'p cnf '";
+  m = ch - '0';
+  while (isdigit (ch = lglnextch (in, lp)))
+    m = 10 * m + (ch - '0');
+  if (ch != ' ') return "invalid header: expected ' ' after 'p cnf <m>'"; 
+  while ((ch = lglnextch (in, lp)) == ' ')
+    ;
+  if (!isdigit (ch))
+    return "invalid header: expected digit after 'p cnf <m> '";
+  n = ch - '0';
+  while (isdigit (ch = lglnextch (in, lp)))
+    n = 10 * n + (ch - '0');
+  while (ch == ' ')
+    ch = lglnextch (in, lp);
+  if (ch == '\r') ch = lglnextch (in, lp);
+  if (ch != '\n') return "invalid header: expected new line after header";
+  lglprt (lgl, 1, "found 'p cnf %d %d' header", m, n);
+  *mp = m;
+  header = 1;
+BODY:
+  ch = lglnextch (in, lp);
+BODY2:
+  if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') goto BODY;
+  if (ch == 'c') {
+    while ((ch = lglnextch (in, lp)) != '\n' && ch != EOF)
+      ;
+    if (ch != EOF) goto BODY;
+  }
+  if (ch == 'o') {
+    if (section) return "two section headers in a row";
+    section = ch;
+    goto BODY;
+  }
+  if (ch == EOF) {
+    if (header && c + 1 == n) return "clause missing";
+    if (header && c < n) return "clauses missing";
+DONE:
+    lglprt (lgl, 1,
+      "read %d variables, %d clauses, %d literals in %.2f seconds", 
+      v, c, l, lglsec (lgl));
+    return 0;
+  }
+  if (ch == '-') {
+    ch = lglnextch (in, lp);
+    if (ch == '0') return "expected positive digit after '-'";
+    sign = -1;
+  } else sign = 1;
+  if (!isdigit (ch)) return "expected digit";
+  if (header && !section && c == n) return "too many clauses";
+  lit = ch - '0';
+  while (isdigit (ch = lglnextch (in, lp)))
+    lit = 10 * lit + (ch - '0');
+  if (header && lit > m) return "maxium variable index exceeded";
+  if (lit > v) v = lit;
+  if (lit) l++;
+  else c++;
+  lit *= sign;
+  if (section) {
+    assert (section == 'o');		// no other sections yet
+    lglsetimportant (lgl, lit);
+    section = 0;
+  } else {
+    lgladd (lgl, lit);
+    if (!lit && force && c == n) goto DONE;
+  }
+  goto BODY;
+}
+
+const char *
+lglparsepath (LGL * lgl, const char * path, int force, int * lp, int * mp)
+{
+  const char * res;
+  size_t len;
+  FILE * in;
+  int clin;
+  char * tmp;
+  lglprt (lgl, 1, "reading DIMACS file '%s'", path);
+  len = strlen (path);
+  if (len >= 3 && !strcmp (path + len - 3, ".gz")) {
+    lglprt (lgl, 1, "piping '%s' through 'gzip'", path);
+    tmp = malloc (len + 20);
+    sprintf (tmp, "gzip -c -d %s", path);
+    in = popen (tmp, "r");
+    if (in) clin = 2;
+    free (tmp);
+  } else if (len >= 3 && !strcmp (path + len - 3, ".xz")) {
+    lglprt (lgl, 1, "piping '%s' through 'xz'", path);
+    tmp = malloc (len + 20);
+    sprintf (tmp, "xz -c -d  %s", path);
+    in = popen (tmp, "r");
+    if (in) clin = 2;
+    free (tmp);
+  } else if (len >= 4 && !strcmp (path + len - 4, ".bz2")) {
+    lglprt (lgl, 1, "piping '%s' through 'bzip2'", path);
+    tmp = malloc (len + 20);
+    sprintf (tmp, "bzip2 -c -d %s", path);
+    in = popen (tmp, "r");
+    if (in) clin = 2;
+    free (tmp);
+  } else if (len >= 4 && !strcmp (path + len - 4, ".zip")) {
+    lglprt (lgl, 1, "piping '%s' through 'unzip'", path);
+    tmp = malloc (len + 20);
+    sprintf (tmp, "unzip -p %s", path);
+    in = popen (tmp, "r");
+    if (in) clin = 2;
+    free (tmp);
+  } else if (len >= 3 && !strcmp (path + len - 3, ".7z")) {
+    lglprt (lgl, 1, "piping '%s' through '7z'", path);
+    tmp = malloc (len + 40);
+    sprintf (tmp, "7z x -so %s 2>/dev/null", path);
+    in = popen (tmp, "r");
+    if (in) clin = 2;
+    free (tmp);
+  } else {
+    in = fopen (path, "r");
+    if (in) clin = 1;
+  }
+  *lp = 0;
+  if (!in) return "can not read";
+  res = lglparsefile (lgl, in, force, lp, mp);
+  if (clin == 1) fclose (in);
+  if (clin == 2) pclose (in);
+  return res;
+}
diff --git a/lglib.h b/lglib.h
new file mode 100644
index 0000000..c5c89cc
--- /dev/null
+++ b/lglib.h
@@ -0,0 +1,349 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#ifndef lglib_h_INCLUDED
+#define lglib_h_INCLUDED
+
+#include <stdio.h>				// for 'FILE'
+#include <stdlib.h>				// for 'int64_t'
+
+//--------------------------------------------------------------------------
+
+#define LGL_UNKNOWN 0
+#define LGL_SATISFIABLE 10
+#define LGL_UNSATISFIABLE 20
+
+//--------------------------------------------------------------------------
+
+typedef struct LGL LGL;
+
+//--------------------------------------------------------------------------
+
+LGL * lglinit (void);				// constructor
+void lglrelease (LGL *);			// destructor
+
+// externally provided memory manager ...
+
+typedef void * (*lglalloc) (void*mem, size_t);
+typedef void (*lgldealloc) (void*mem, void*, size_t);
+typedef void * (*lglrealloc) (void*mem, void *ptr, size_t old, size_t);
+
+LGL * lglminit (void *mem, lglalloc, lglrealloc, lgldealloc);
+
+// 'Cloning' produces identicaly behaving solvers.
+
+LGL * lglclone (LGL *);
+LGL * lglmclone (LGL *, void *mem, lglalloc, lglrealloc, lgldealloc);
+
+int lglunclone (LGL * dst, LGL * src);		// does not release 'src'
+
+// 'Forking' copies only irredundant clauses and also uses internal variable
+// indices of the parent as external variable indices.  Thus 'parent' and
+// the forked off 'child' do neither exactly work the same way, nor do they
+// use from the API point of view the same set of variables.  They are
+// satisfiability equivalent.  If the child becomes unsatisfiable the parent
+// can be assumed to be unsatisfiable too and thus 'lgljoin' would just add
+// the empty clause to the parent.  If the child produces a satisfying
+// assignment, this assignment is turned into an assignment of the parent by
+// 'lgljoin'.  Parents can be forked multiple times.  A child has exactly
+// one parent.  Parents and children can be released independently.  Between
+// 'lglfork' and 'lgljoin' no other operations but further 'lglfork' are
+// allowed.  The effect ot multiple 'lgljoin' with the same parent is
+// unclear at this point.  The same memory manager is use for the child and
+// the parent. Options, prefix, output file and the callbacks for 'getime'
+// and 'onabort' are copied too (if set).
+
+LGL * lglfork (LGL * parent);
+int lgljoin (LGL * parent, LGL * child);	// does not release 'child'
+
+// Both 'Cloning' and 'Forking' can be used to implement 'Push & Pop', but
+// the asymmetric forking is more similar to the classical way of
+// implementing it, needs less resources since for instance eliminated
+// variables do not occupy any memory in the children, but requires lifting
+// back satisfying assignments explicitly (through the whole parent chain).
+// If these full satisfying assignments are really needed actually cloning
+// could be more space efficient too.  Assume you want to split the solver
+// into two instances, one with a literal set to false, the other one to
+// true. Then cloning allows you to produce two independent branches, while
+// for forking you need three, since the root / top solver still has to be
+// kept for lifting back a potential assignment.
+
+//--------------------------------------------------------------------------
+
+const char * lglparsefile (LGL *, FILE *, int force,
+                           int * lineno_ptr, int * max_var_ptr);
+
+const char * lglparsepath (LGL *, const char * path, int force,
+                           int * lineno_ptr, int * max_var_ptr);
+
+//--------------------------------------------------------------------------
+
+const char * lglversion ();
+
+void lglbnr (const char * name,
+             const char * prefix,
+	     FILE * file);			// ... banner
+
+void lglusage (LGL *);				// print usage "-h"
+void lglopts (LGL *, const char * prefix, int);	// ... defaults "-d" | "-e"
+void lglrgopts (LGL *);				// ... option ranges "-r"
+void lglpcs (LGL *, int mixed);			// ... PCS file
+void lglsizes (LGL *);				// ... data structure sizes
+
+//--------------------------------------------------------------------------
+// setters and getters for options
+
+void lglsetout (LGL *, FILE*);			// output file for report
+void lglsetrace (LGL *, FILE*);			// set trace output file
+void lglsetprefix (LGL *, const char*);		// prefix for messages
+
+FILE * lglgetout (LGL *);
+const char * lglgetprefix (LGL *);
+
+void lglsetopt (LGL *, const char *, int);	// set option value
+int lglreadopts (LGL *, FILE *);		// read and set options
+int lglgetopt (LGL *, const char *);		// get option value
+int lgldefopt (LGL *, const char *);		// get default value
+int lglhasopt (LGL *, const char *);		// exists option?
+
+int lglgetoptminmax (LGL *, const char *, int * minptr, int * maxptr);
+
+void * lglfirstopt (LGL *);			// option iterator: first
+
+void * lglnextopt (LGL *, 			// option iterator: next
+                   void * iterator, 
+                   const char ** nameptr,
+		   int *valptr, int *minptr, int *maxptr);
+
+// individual ids for logging and statistics:
+
+void lglsetid (LGL *, int tid, int tids);
+
+// Set default phase of a literal.  Any decision on this literal will always
+// try this phase.  Note, that this function does not have any effect on
+// eliminated variables.  Further equivalent variables share the same forced 
+// phase and thus if they are set to different default phases, only the last
+// set operation will be kept.
+
+void lglsetphase (LGL *, int lit);
+void lglresetphase (LGL *, int lit);	// Stop forcing phase in decisions.
+
+// Prefer decisions on 'important' variables.
+
+void lglsetimportant (LGL *, int lit);
+
+// Assume the solver is in the SATISFIABLE state (after 'lglsat' or
+// 'lglsimp'), then calling 'lglsetphases' will copy the current assignment
+// as default phases.
+
+void lglsetphases (LGL *);
+
+//--------------------------------------------------------------------------
+// call back for abort
+
+void lglonabort (LGL *, void * state, void (*callback)(void* state));
+
+//--------------------------------------------------------------------------
+// write and read API trace
+
+void lglwtrapi (LGL *, FILE *);
+void lglrtrapi (LGL *, FILE *);
+
+//--------------------------------------------------------------------------
+// traverse units, equivalences, remaining clauses, or all clauses:
+
+void lglutrav (LGL *, void * state, void (*trav)(void *, int unit));
+void lgletrav (LGL *, void * state, void (*trav)(void *, int lit, int repr));
+void lglctrav (LGL *, void * state, void (*trav)(void *, int lit));
+void lgltravall (LGL *, void * state, void (*trav)(void *state, int lit));
+
+//--------------------------------------------------------------------------
+
+void lglprint (LGL *, FILE *);			// remaining in DIMACS format
+void lglprintall (LGL *, FILE *);		// including units & equivs
+
+//--------------------------------------------------------------------------
+// main interface as in PicoSAT (see 'picosat.h' for more information)
+
+int lglmaxvar (LGL *);
+int lglincvar (LGL *);
+
+void lgladd (LGL *, int lit);
+void lglassume (LGL *, int lit);		// assume single units
+
+void lglcassume (LGL *, int lit);		// assume clause
+						// (at most one)
+
+void lglfixate (LGL *);				// add assumptions as units
+
+int lglsat (LGL *);
+int lglsimp (LGL *, int iterations);
+
+int lglderef (LGL *, int lit);			// neg=false, pos=true
+int lglfixed (LGL *, int lit);			// ditto but toplevel
+
+int lglfailed (LGL *, int lit);			// ditto for assumptions
+int lglinconsistent (LGL *);			// contains empty clause?
+int lglchanged (LGL *);				// model changed
+
+void lglreducecache (LGL *);			// reset cache size
+void lglflushcache (LGL *);			// flush all learned clauses
+
+/*------------------------------------------------------------------------*/
+
+/* Return representative from equivalence class if literal is not top-level
+ * assigned nor eliminated.
+ */
+int lglrepr (LGL *, int lit);
+
+/* Set 'startptr' and 'toptr' to the 'start' and 'top' of the reconstruction
+ * stack, which is used in BCE, BVE and CCE for reconstructing a solution
+ * after eliminating variables or clauses.  These pointers are only valid
+ * until the next 'lglsat/lglsimp' call.
+ */
+void lglreconstk (LGL * lgl, int ** startptr, int ** toptr);
+
+//--------------------------------------------------------------------------
+// Incremental interface provides reference counting for indices, i.e.
+// unfrozen indices become invalid after next 'lglsat' (or 'lglsimp').
+// This is actually a reference counter for variable indices still in use
+// after the next 'lglsat' or 'lglsimp' call.  It is actually variable based
+// and only applies to literals in new clauses or used as assumptions,
+// e.g. in calls to 'lgladd' and 'lglassume'.
+//
+// The following example is actually compilable and used for explaining
+// all the details of this rather complicated incremental API contract:
+
+/***** start of incremental example ***************************************
+
+#include "lglib.h"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <assert.h>
+
+int main () {
+  LGL * lgl = lglinit ();
+  int res;
+  lgladd (lgl, -14); lgladd (lgl, 2); lgladd (lgl, 0);  // binary clause
+  lgladd (lgl, 14); lgladd (lgl, -1); lgladd (lgl, 0);  // binary clause
+  lglassume (lgl, 1);                                   // assume '1'
+  lglfreeze (lgl, 1);                                   // will use '1' below
+  lglfreeze (lgl, 14);                                  // will use '14 too
+  assert (lglfrozen (lgl, 1));
+  assert (lglfrozen (lgl, 14));
+  res = lglsat (lgl);
+  assert (res == 10);
+  (void) lglderef (lgl, 1);                             // fine
+  (void) lglderef (lgl, 2);                             // fine
+  (void) lglderef (lgl, 3);                             // fine !
+  (void) lglderef (lgl, 14);                            // fine
+  assert (!lglusable (lgl, 2));
+  // lgladd (lgl, 2);                                   // ILLEGAL
+  // lglassume (lgl, 2);                                // ILLEGAL
+  assert (lglusable (lgl, 15));				// '15' not used yet!
+  lgladd (lgl, -14); lgladd (lgl, 1); lgladd (lgl, 0);  // binary clause
+  lgladd (lgl, 15); lgladd (lgl, 0);                    // fine!
+  lglmelt (lgl, 14);                                    // '1' discarded
+  res = lglsat (lgl);
+  assert (res == 10);
+  assert (lglfrozen (lgl, 1));
+  (void) lglderef (lgl, 1);                             // fine
+  (void) lglderef (lgl, 2);                             // fine
+  (void) lglderef (lgl, 3);                             // fine
+  (void) lglderef (lgl, 14);                            // fine
+  (void) lglderef (lgl, 15);                            // fine
+  assert (!lglusable (lgl, 2));
+  assert (!lglusable (lgl, 14));
+  // lglassume (lgl, 2);                                // ILLEGAL
+  // lglassume (lgl, 14);                               // ILLEGAL
+  lgladd (lgl, 1);                                      // still frozen
+  lglmelt (lgl, 1);
+  lgladd (lgl, 0);
+  res = lglsat (lgl);
+  assert (res == 10);					// TODO right?
+  // none frozen
+  assert (!lglusable (lgl, 1));
+  // lgladd(lgl, 1);                                    // ILLEGAL
+  lglsetopt (lgl, "plain", 1);				// disable BCE ...
+  lgladd (lgl, 8); lgladd (lgl, -9); lgladd (lgl, 0);
+  res = lglsat (lgl);
+  assert (res == 10);
+  assert (!lglusable (lgl, 8));
+  assert (!lglusable (lgl, -9));
+  assert (lglreusable (lgl, 8));
+  assert (lglreusable (lgl, -9));
+  lglreuse (lgl, 8);
+  lgladd (lgl, -8); lgladd (lgl, 0);
+  lglsetopt (lgl, "plain", 0);				// enable BCE ...
+  res = lglsat (lgl);
+  assert (res);
+  return res;
+}
+
+****** end of incremental example ****************************************/
+
+void lglfreeze (LGL *, int lit);
+int lglfrozen (LGL *, int lit);
+
+void lglmelt (LGL *, int lit);
+void lglmeltall (LGL *);				// melt all literals
+
+// If a literal was not frozen at the last call to 'lglsat' (or 'lglsimp')
+// it becomes 'unusable' after the next call even though it might not
+// have been used as blocking literal etc.  This
+
+int lglusable (LGL *, int lit);
+int lglreusable (LGL *, int lit);
+void lglreuse (LGL *, int lit);
+
+//--------------------------------------------------------------------------
+// Returns a good look ahead literal or zero if all potential literals have
+// been eliminated or have been used as blocking literals in blocked clause
+// elimination.  Zero is also returned if the formula is already
+// inconsistent.  The lookahead literal is made usable again, for instance
+// if it was not frozen during a previous SAT call and thus implicitly
+// became melted.  Therefore it can be added in a unit clause.
+
+int lglookahead (LGL *);
+
+//--------------------------------------------------------------------------
+// stats:
+
+void lglflushtimers (LGL *lgl);			// after interrupt etc.
+
+void lglstats (LGL *);
+int64_t lglgetconfs (LGL *);
+int64_t lglgetdecs (LGL *);
+int64_t lglgetprops (LGL *);
+size_t lglbytes (LGL *);
+int lglnvars (LGL *);
+int lglnclauses (LGL *);
+double lglmb (LGL *);
+double lglmaxmb (LGL *);
+double lglsec (LGL *);
+double lglprocesstime (void);
+
+//--------------------------------------------------------------------------
+// low-level parallel support through call backs
+
+void lglseterm (LGL *, int (*term)(void*), void*);
+
+void lglsetproduceunit (LGL *, void (*produce)(void*, int), void*);
+void lglsetconsumeunits (LGL *, void (*consume)(void*,int**,int**), void*);
+void lglsetconsumedunits (LGL *, void (*consumed)(void*,int), void*);
+
+void lglsetproducecls (LGL*, void(*produce)(void*,int*,int glue),void*);
+void lglsetconsumecls (LGL*,void(*consume)(void*,int**,int *glueptr),void*);
+void lglsetconsumedcls (LGL *, void (*consumed)(void*,int), void*);
+
+void lglsetlockeq (LGL *, int * (*lock)(void*), void *);
+void lglsetunlockeq (LGL *, void (*unlock)(void*,int cons,int prod), void *);
+
+void lglsetmsglock (LGL *, void (*lock)(void*), void (*unlock)(void*), void*);
+void lglsetime (LGL *, double (*time)(void));
+
+#endif
diff --git a/lglmain.c b/lglmain.c
new file mode 100644
index 0000000..2dc2b67
--- /dev/null
+++ b/lglmain.c
@@ -0,0 +1,587 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include "lglib.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static LGL * lgl4sigh;
+static int catchedsig, verbose, force;
+
+static int * targets, sztargets, ntargets;
+
+static void (*sig_int_handler)(int);
+static void (*sig_segv_handler)(int);
+static void (*sig_abrt_handler)(int);
+static void (*sig_term_handler)(int);
+static void (*sig_bus_handler)(int);
+static void (*sig_alrm_handler)(int);
+
+static void resetsighandlers (void) {
+  (void) signal (SIGINT, sig_int_handler);
+  (void) signal (SIGSEGV, sig_segv_handler);
+  (void) signal (SIGABRT, sig_abrt_handler);
+  (void) signal (SIGTERM, sig_term_handler);
+  (void) signal (SIGBUS, sig_bus_handler);
+}
+
+static void caughtsigmsg (int sig) {
+  if (verbose < 0) return;
+  printf ("c\nc CAUGHT SIGNAL %d", sig);
+  switch (sig) {
+    case SIGINT: printf (" SIGINT"); break;
+    case SIGSEGV: printf (" SIGSEGV"); break;
+    case SIGABRT: printf (" SIGABRT"); break;
+    case SIGTERM: printf (" SIGTERM"); break;
+    case SIGBUS: printf (" SIGBUS"); break;
+    case SIGALRM: printf (" SIGALRM"); break;
+    default: break;
+  }
+  printf ("\nc\n");
+  fflush (stdout);
+}
+
+static void catchsig (int sig) {
+  if (!catchedsig) {
+    catchedsig = 1;
+    caughtsigmsg (sig);
+    fputs ("c s UNKNOWN\n", stdout);
+    fflush (stdout);
+    if (verbose >= 0) {
+      lglflushtimers (lgl4sigh);
+      lglstats (lgl4sigh);
+      caughtsigmsg (sig);
+    }
+  }
+  resetsighandlers ();
+  if (!getenv ("LGLNABORT")) raise (sig); else exit (1);
+}
+
+static void setsighandlers (void) {
+  sig_int_handler = signal (SIGINT, catchsig);
+  sig_segv_handler = signal (SIGSEGV, catchsig);
+  sig_abrt_handler = signal (SIGABRT, catchsig);
+  sig_term_handler = signal (SIGTERM, catchsig);
+  sig_bus_handler = signal (SIGBUS, catchsig);
+}
+
+static int timelimit = -1, caughtalarm = 0;
+
+static void catchalrm (int sig) {
+  assert (sig == SIGALRM);
+  if (!caughtalarm) {
+    caughtalarm = 1;
+    caughtsigmsg (sig);
+    if (timelimit >= 0) {
+      printf ("c time limit of %d reached after %.1f seconds\nc\n",
+              timelimit, lglsec (lgl4sigh));
+      fflush (stdout);
+    }
+  }
+}
+
+static int checkalarm (void * ptr) {
+  assert (ptr == (void*) &caughtalarm);
+  return caughtalarm;
+}
+
+typedef struct OBuf { char line[81]; int pos; } OBuf;
+
+static void flushobuf (OBuf * obuf, int simponly, FILE * file) {
+  assert (0 < obuf->pos);
+  assert (obuf->pos < 81);
+  obuf->line[obuf->pos++] = '\n';
+  assert (obuf->pos < 81);
+  obuf->line[obuf->pos++] = 0;
+  if (simponly) fputs ("c ", file);
+  fputc ('v', file);
+  fputs (obuf->line, file);
+  obuf->pos = 0;
+}
+
+static void print2obuf (OBuf * obuf, int i, int simponly, FILE * file) {
+  char str[20];
+  int len;
+  sprintf (str, " %d", i);
+  len = strlen (str);
+  assert (len > 1);
+  if (obuf->pos + len > 79) flushobuf (obuf, simponly, file);
+  strcpy (obuf->line + obuf->pos, str);
+  obuf->pos += len;
+  assert (obuf->pos <= 79);
+}
+
+static FILE * writefile (const char * name, int * clptr) {
+  int len = strlen (name);
+  char * tmp;
+  FILE * res;
+  if (len >= 3 && !strcmp (name + len - 3, ".gz")) {
+    tmp = malloc (len + 20);
+    unlink (name);
+    sprintf (tmp, "gzip -c > %s", name);
+    res = popen (tmp, "w");
+    if (res) *clptr = 2;
+    free (tmp);
+  } else {
+    res = fopen (name, "w");
+    if (res) *clptr = 1;
+  }
+  if (!res) fprintf (stderr, "*** lingeling error: can not write %s\n", name);
+  return res;
+}
+
+static void closefile (FILE * file, int type) {
+  if (type == 1) fclose (file);
+  if (type == 2) pclose (file);
+}
+
+static void lgltravcounter (void * voidptr, int lit) {
+  int * cntptr = voidptr;
+  if (!lit) *cntptr += 1;
+}
+
+static void lglpushtarget (int target) {
+  if (ntargets == sztargets)
+    targets = realloc (targets, sizeof *targets *
+               (sztargets = sztargets ? 2*sztargets : 1));
+  targets[ntargets++] = target;
+}
+
+static int primes[] = {
+  200000033, 200000039, 200000051, 200000069, 200000081,
+};
+
+static int nprimes = sizeof primes / sizeof *primes;
+
+int main (int argc, char ** argv) {
+  int res, i, j, clout, val, len, lineno, simponly, count, target;
+  const char * iname, * oname, * pname;
+  const char * match, * p, * err, * thanks;
+  FILE * out, * pfile;
+  int maxvar, lit, nopts, simplevel;
+  char * tmp;
+#ifndef NLGLDRUPLIG
+  const char * tname = 0;
+  FILE * tfile = 0;
+#endif
+  LGL * lgl;
+  OBuf obuf;
+  lineno = 1;
+  out = 0;
+  res = clout = simponly = simplevel = 0;
+  iname = oname = pname = thanks = 0;
+  lgl4sigh = lgl = lglinit ();
+  setsighandlers ();
+  for (i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h") || !strcmp (argv[i], "--help")) {
+      printf ("usage: lingeling [<option> ...][<file>[.<suffix>]]\n");
+      printf ("\n");
+      printf ("where <option> is one of the following:\n");
+      printf ("\n");
+      printf ("-q               be quiet (same as '--verbose=-1')\n");
+      printf ("-s               only simplify and print to output file\n");
+      printf ("-O<L>            set simplification level to <L>\n");
+      printf ("-o <output>      set output file (default 'stdout')\n");
+#ifndef NLGLDRUPLIG
+      printf ("-t <trace>       set proof trace output file (enable tracing)\n");
+#endif
+      printf ("-p <options>     read options from file\n");
+      printf ("\n");
+      printf ("-T <seconds>     set time limit\n");
+      printf ("\n");
+      printf ("-a <assumption>  use multiple assumptions\n");
+      printf ("\n");
+      printf ("-h|--help        print command line option summary\n");
+      printf ("-f|--force       force reading even without header\n");
+      printf ("-r|--ranges      print value ranges of options\n");
+      printf ("-d|--defaults    print default values of options\n");
+      printf ("-P|--pcs         print (full) PCS file\n");
+      printf ("--pcs-mixed      print mixed PCS file\n");
+      printf ("--pcs-reduced    print reduced PCS file\n");
+      printf ("-e|--embedded    ditto but in an embedded format print\n");
+      printf ("-n|--no-witness   do not print solution (see '--witness')\n");
+      printf ("\n");
+      printf ("-c               increase checking level\n");
+      printf ("-l               increase logging level\n");
+      printf ("-v               increase verbose level\n");
+      printf ("\n");
+#ifdef NLGLDRUPLIG
+      printf ("--verify         online forward check\n");
+      printf ("--proof          generate proof file\n");
+#endif
+      printf ("\n");
+      printf ("--thanks=<whom>  alternative way of specifying the seed\n");
+      printf ("                 (inspired by Vampire)\n");
+      printf ("\n");
+      printf (
+"The following options can also be used in the form '--<name>=<int>',\n"
+"just '--<name>' for increment and '--no-<name>' for zero.  They\n"
+"can be embedded into the CNF file, set through the API or capitalized\n"
+"with prefix 'LGL' instead of '--' through environment variables.\n"
+"Their default values are displayed in square brackets.\n");
+      printf ("\n");
+      printf (
+"The input <file> can be compressed.  This is detected by matching\n"
+"the <suffix> of the filename against 'gz', 'bz2, 'xz', 'zip', '7z'.\n"
+"However uncompressing a file is implemented by starting an external\n"
+"process running corresponding helper programs, e.g., 'gzip', 'bzip2'.\n"
+"Thus those have to be installed and in the current path if needed.\n");
+      printf ("\n");
+      lglusage (lgl);
+      goto DONE;
+    } else if (!strcmp (argv[i], "--version")) {
+      printf ("%s\n", lglversion ());
+      fflush (stdout);
+      goto DONE;
+    } else if (!strcmp (argv[i], "-s")) simponly = 1;
+    else if (argv[i][0] == '-' && argv[i][1] == 'O') {
+      if (simplevel > 0) {
+	fprintf (stderr, "*** lingeling error: multiple '-O..' options\n");
+	res = 1;
+	goto DONE;
+      }
+      if ((simplevel = atoi (argv[i] + 2)) <= 0) {
+	fprintf (stderr,
+	   "*** lingeling error: invalid '%s' option\n", argv[i]);
+	res = 1;
+	goto DONE;
+      }
+    } else if (!strcmp (argv[i], "-q")) lglsetopt (lgl, "verbose", -1);
+    else if (!strcmp (argv[i], "-o")) {
+      if (++i == argc) {
+	fprintf (stderr, "*** lingeling error: argument to '-o' missing\n");
+	res = 1;
+	goto DONE;
+      } 
+      if (oname) {
+	fprintf (stderr, 
+	         "*** lingeling error: "
+		 "multiple output files '%s' and '%s'\n",
+		 oname, argv[i]);
+	res = 1;
+	goto DONE;
+      }
+      oname = argv[i];
+    } else if (!strcmp (argv[i], "-p")) {
+      if (++i == argc) {
+	fprintf (stderr, "*** lingeling error: argument to '-p' missing\n");
+	res = 1;
+	goto DONE;
+      } 
+      if (pname) {
+	fprintf (stderr, 
+	         "*** lingeling error: "
+		 "multiple option files '%s' and '%s'\n",
+		 pname, argv[i]);
+	res = 1;
+	goto DONE;
+      }
+      pname = argv[i];
+#ifndef NLGLDRUPLIG
+    } else if (!strcmp (argv[i], "-t")) {
+      if (++i == argc) {
+	fprintf (stderr, "*** lingeling error: argument to '-t' missing\n");
+	res = 1;
+	goto DONE;
+      } 
+      if (tname) {
+	fprintf (stderr, 
+	         "*** lingeling error: "
+		 "multiple output files '%s' and '%s'\n",
+		 tname, argv[i]);
+	res = 1;
+	goto DONE;
+      }
+      tname = argv[i];
+#endif
+    } else if (!strcmp (argv[i], "-T")) {
+      if (++i == argc) {
+	fprintf (stderr, "*** lingeling error: argument to '-T' missing\n");
+	res = 1;
+	goto DONE;
+      }
+      if (timelimit >= 0) {
+	fprintf (stderr, "*** lingeling error: timit limit set twice\n");
+	res = 1;
+	goto DONE;
+      }
+      for (p = argv[i]; *p && isdigit ((int)*p); p++) 
+	;
+      if (p == argv[i] || *p || (timelimit = atoi (argv[i])) < 0) {
+	fprintf (stderr, 
+	  "*** lingeling error: invalid time limit '-T %s'\n", argv[i]);
+	res = 1;
+	goto DONE;
+      }
+    } else if (!strcmp (argv[i], "-a")) {
+      if (++i == argc) {
+	fprintf (stderr, "*** lingeling error: argument to '-a' missing\n");
+	res = 1;
+	goto DONE;
+      }
+      target = atoi (argv[i]);
+      if (!target) {
+	fprintf (stderr,
+	  "*** lingeling error: invalid literal in '-a %d'\n", target);
+	res = 1;
+	goto DONE;
+      }
+      lglpushtarget (target);
+    } else if (!strcmp (argv[i], "-d") || !strcmp (argv[i], "--defaults")) {
+      lglopts (lgl, "", 0);
+      goto DONE;
+    } else if (!strcmp (argv[i], "-e") || !strcmp (argv[i], "--embedded")) {
+      lglopts (lgl, "c ", 1);
+      goto DONE;
+    } else if (!strcmp (argv[i], "-r") || !strcmp (argv[i], "--ranges")) {
+      lglrgopts (lgl);
+      goto DONE;
+    } else if (!strcmp (argv[i], "-P") || !strcmp (argv[i], "--pcs")) {
+      printf ("# generated by 'lingeling --pcs'\n");
+      printf ("# version %s\n", lglversion ());
+      lglpcs (lgl, 0);
+      goto DONE;
+    } else if (!strcmp (argv[i], "--pcs-mixed")) {
+      printf ("# generated by 'lingeling --pcs-mixed'\n");
+      printf ("# version %s\n", lglversion ());
+      lglpcs (lgl, 1);
+      goto DONE;
+    } else if (!strcmp (argv[i], "--pcs-reduced")) {
+      printf ("# generated by 'lingeling --pcs-reduced'\n");
+      printf ("# version %s\n", lglversion ());
+      lglpcs (lgl, -1);
+      goto DONE;
+    } else if (!strcmp (argv[i], "-f") || !strcmp (argv[i], "--force")) {
+      force = 1;
+    } else if (!strcmp (argv[i], "-n") || !strcmp (argv[i], "no-witness")) {
+      lglsetopt (lgl, "witness", 0);
+    } else if (!strcmp (argv[i], "-c")) {
+      lglsetopt (lgl, "check", lglgetopt (lgl, "check") + 1);
+    } else if (!strcmp (argv[i], "-l")) {
+      lglsetopt (lgl, "log", lglgetopt (lgl, "log") + 1);
+    } else if (!strcmp (argv[i], "-v")) {
+      lglsetopt (lgl, "verbose", lglgetopt (lgl, "verbose") + 1);
+#ifndef NLGLDRUPLIG
+    } else if (!strcmp (argv[i], "--verify")) {
+      lglsetopt (lgl, "druplig", 1);
+      lglsetopt (lgl, "drupligcheck", 1);
+    } else if (!strcmp (argv[i], "--proof")) {
+      lglsetopt (lgl, "druplig", 1);
+      lglsetopt (lgl, "drupligtrace", 1);
+#endif
+    } else if (argv[i][0] == '-') {
+      if (argv[i][1] == '-') {
+	match = strchr (argv[i] + 2, '=');
+	if (match) {
+	  p = match + 1;
+	  if (*p == '-') p++;	// TODO for what is this useful again?
+	  len = p - argv[i];
+	  if (!strncmp (argv[i], "--write-api-trace=", len)) {
+	    // TODO not handled yet ...
+	    continue;
+	  } else if (!strncmp (argv[i], "--thanks=", len)) {
+	    thanks = match + 1;
+	    continue;
+	  } else if (!isdigit ((int)*p)) {
+ERR:
+            fprintf (stderr,
+	      "*** lingeling error: invalid command line option '%s'\n",
+	      argv[i]);
+	    res = 1;
+	    goto DONE;
+	  }
+	  while (*++p) if (!isdigit ((int)*p)) goto ERR;
+	  len = match - argv[i] - 2;
+	  tmp = malloc (len + 1);
+	  j = 0;
+	  for (p = argv[i] + 2; *p != '='; p++) tmp[j++] = *p;
+	  tmp[j] = 0;
+	  val = atoi (match + 1);
+	} else if (!strncmp (argv[i], "--no-", 5)) {
+	  tmp = strdup (argv[i] + 5);
+	  val = 0;
+	} else {
+	  tmp = strdup (argv[i] + 2);
+	  val = lglgetopt (lgl, tmp) + 1;
+	}
+	if (!lglhasopt (lgl, tmp)) { free (tmp); goto ERR; }
+	lglsetopt (lgl, tmp, val);
+	free (tmp);
+      } else {
+	if (argv[i][2]) goto ERR;
+	if (!lglhasopt (lgl, argv[i] + 1)) goto ERR;
+	val = lglgetopt (lgl, argv[i] + 1) + 1;
+	lglsetopt (lgl, argv[i] + 1, val);
+      }
+    } else if (iname) {
+      fprintf (stderr, "*** lingeling error: can not read '%s' and '%s'\n",
+               iname, argv[i]);
+      res = 1;
+      goto DONE;
+    } else iname = argv[i];
+  }
+  verbose = lglgetopt (lgl, "verbose");
+  if (verbose >= 0) {
+    lglbnr ("Lingeling SAT Solver", "c ", stdout);
+    if (simponly) printf ("c simplifying only\n");
+    if (oname) printf ("c output file %s\n", oname);
+    if (simponly || oname) fflush (stdout);
+    lglsetopt (lgl, "trep", 1);
+  }
+#ifndef NLGLDRUPLIG
+  if (tname) {
+    tfile = fopen (tname, "w");
+    if (!tfile) {
+      fprintf (stderr,
+         "*** lingeling error: can not write proof trace file %s\n", tname);
+      res = 1;
+      goto DONE;
+    }
+    if (verbose >= 0)
+      printf ("c proof trace file %s\n", tname), fflush (stdout);
+    lglsetrace (lgl, tfile);
+    lglsetopt (lgl, "druplig", 1);
+    lglsetopt (lgl, "drupligtrace", 2);
+  }
+#endif
+  if (thanks) {
+    unsigned seed = 0, i = 0, ch;
+    int iseed;
+    for (p = thanks; (ch = *p); p++) {
+      seed += primes[i++] * ch;
+      if (i == nprimes) i = 0;
+    }
+    if (seed >= (unsigned) INT_MAX) seed >>= 1;
+    assert (seed <= (unsigned) INT_MAX);
+    iseed = (int) seed;
+    assert (iseed >= 0);
+    if (verbose)
+      printf ("c will have to thank %s (--seed=%d)\nc\n",
+	thanks, iseed);
+    lglsetopt (lgl, "seed", iseed);
+  }
+  if (verbose >= 2) {
+   printf ("c\nc options after command line parsing:\nc\n");
+   lglopts (lgl, "c ", 0);
+   printf ("c\n");
+   lglsizes (lgl);
+   printf ("c\n");
+  }
+  if (pname) {
+    pfile = fopen (pname, "r");
+    if (!pfile) {
+      fprintf (stderr,
+        "*** lingeling error: can not read option file %s\n", pname);
+      res = 1;
+      goto DONE;
+    }
+    if (verbose >= 0) {
+      printf ("c reading options file %s\n", pname);
+      fflush (stdout);
+    }
+    nopts = lglreadopts (lgl, pfile);
+    if (verbose >= 0) 
+      printf ("c read and set %d options\nc\n", nopts), fflush (stdout);
+    fclose (pfile);
+  }
+  if (!iname) {
+    iname = "<stdin>";
+    err = lglparsefile (lgl, stdin, force, &lineno, &maxvar);
+  } else err = lglparsepath (lgl, iname, force, &lineno, &maxvar);
+  if (err) {
+    fprintf (stderr, "%s:%d: %s\n", iname, lineno, err);
+    res = 1;
+    goto DONE;
+  }
+  if (verbose >= 1) {
+    printf ("c\n");
+    if (verbose >= 2) printf ("c final options:\nc\n");
+    lglopts (lgl, "c ", 0);
+  }
+  if (timelimit >= 0) {
+    if (verbose >= 0) {
+      printf ("c\nc setting time limit of %d seconds\n", timelimit);
+      fflush (stdout);
+    }
+    lglseterm (lgl, checkalarm, &caughtalarm);
+    sig_alrm_handler = signal (SIGALRM, catchalrm);
+    alarm (timelimit);
+  }
+  for (i = 0; i < ntargets; i++) lglassume (lgl, targets[i]);
+  if (simplevel > 0) {
+    if (verbose >= 1) {
+      printf ("c simplifying with simplification level %d\n", simplevel);
+      fflush (stdout);
+    }
+    res = lglsimp (lgl, simplevel);
+    if (verbose >= 1) {
+      printf ("c simplifying result %d after %.2f seconds\n",
+	res, lglsec (lgl));
+      fflush (stdout);
+    }
+  }
+  res = lglsat (lgl);
+  if (timelimit >= 0) {
+    caughtalarm = 0;
+    (void) signal (SIGALRM, sig_alrm_handler);
+  }
+  if (oname) {
+    double start = lglsec (lgl), delta;
+    if (!strcmp (oname, "-")) out = stdout, oname = "<stdout>", clout = 0;
+    else if (!(out = writefile (oname, &clout))) { res = 1; goto DONE; }
+    if (verbose >= 0) {
+      count = 0;
+      lglctrav (lgl, &count, lgltravcounter);
+      printf ("c\nc writing 'p cnf %d %d' to '%s'\n",
+	      maxvar, count, oname);
+      fflush (stdout);
+    }
+    lglprint (lgl, out);
+    closefile (out, clout);
+    if (verbose >= 0) {
+      delta = lglsec (lgl) - start; if (delta < 0) delta = 0;
+      printf ("c collected garbage and wrote '%s' in %.1f seconds\n", 
+              oname, delta);
+      printf ("c\n"), fflush (stdout);
+    }
+  }
+  if (!simponly || verbose >= 0) {
+    if (simponly) fputs ("c ", stdout);
+    if (res == 10) fputs ("s SATISFIABLE\n", stdout);
+    else if (res == 20) fputs ("s UNSATISFIABLE\n", stdout);
+    else fputs ("c s UNKNOWN\n", stdout);
+    if (thanks) printf ("c\nc Thanks to %s!\nc\n", thanks);
+    fflush (stdout);
+    if (res == 10 && lglgetopt (lgl, "witness")) {
+      obuf.pos = 0;
+      for (i = 1; i <= maxvar; i++) {
+	lit = (lglderef (lgl, i) > 0) ? i : -i;
+	print2obuf (&obuf, lit, simponly, stdout);
+      }
+      print2obuf (&obuf, 0, simponly, stdout);
+      if (obuf.pos > 0) flushobuf (&obuf, simponly, stdout);
+      fflush (stdout);
+    }
+  }
+  if (verbose >= 0) fputs ("c\n", stdout), lglstats (lgl);
+DONE:
+#ifndef NLGLDRUPLIG
+  if (tfile) fclose (tfile);
+#endif
+  resetsighandlers ();
+  lgl4sigh = 0;
+  lglrelease (lgl);
+  free (targets);
+  if (verbose > 0) printf ("c exit %d\n", res);
+  fflush (stdout);
+  return res;
+}
diff --git a/lglmbt.c b/lglmbt.c
new file mode 100644
index 0000000..9fc30d1
--- /dev/null
+++ b/lglmbt.c
@@ -0,0 +1,768 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include "lglib.h"
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/times.h>
+#include <sys/wait.h>
+#include <ctype.h>
+#include <string.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/time.h>
+
+void lglchkclone (LGL *);
+
+typedef struct Data { 
+  LGL * lgl; 
+  FILE * trace;
+  int * available, navailable, * frozen, nfrozen;
+  int m, n, c, print, noptsfuzz;
+} Data;
+
+typedef void * (*State)(Data *, unsigned rand);
+
+typedef struct Event {
+  State state;
+  unsigned rand;
+  int remove;
+} Event;
+
+typedef struct RNG { unsigned z, w; } RNG;
+
+typedef struct Env { 
+  FILE * file;
+  const char * prefix;
+  int round, bugs, violations, print, quiet, first, nodd, noptsfuzz;
+  int alwaysfork, terminal, forked, nevents, timeout;
+  unsigned seed;
+  Event * events;
+  RNG rng;
+} Env;
+
+static void * init (Data *, unsigned);
+static void * opts (Data *, unsigned);
+static void * inc (Data *, unsigned);
+static void * cnf (Data *, unsigned);
+static void * unit (Data *, unsigned);
+static void * binary (Data *, unsigned);
+static void * ternary (Data *, unsigned);
+static void * rest (Data *, unsigned);
+static void * clause (Data *, unsigned);
+static void * lkhd (Data *, unsigned);
+static void * sat (Data *, unsigned);
+static void * release (Data *, unsigned);
+
+static RNG initrng (unsigned seed) {
+  RNG res;
+  res.z = seed * 1000632769u;
+  res.w = seed * 2019164533u;
+  return res;
+}
+
+static unsigned nextrand (RNG * rng) {
+  rng->z = 36969 * (rng->z & 65535) + (rng->z >> 16);
+  rng->w = 18000 * (rng->w & 65535) + (rng->w >> 16);
+  return (rng->z << 16) + rng->w;  /* 32-bit result */
+}
+
+static int pick (RNG * rng_ptr, unsigned from, unsigned to) {
+  unsigned tmp = nextrand (rng_ptr);
+  int res;
+  assert (from <= to && to <= INT_MAX);
+  tmp %= to - from + 1;
+  tmp += from;
+  res = (int) tmp;
+  // printf ("pick %u %u %d\n", from, to, res);
+  return res;
+}
+
+static void onabort (void * dummy) { (void) dummy; exit (42); }
+
+static void * init (Data * data, unsigned r) {
+  RNG rng = initrng (r);
+  int t, i;
+  data->m = pick (&rng, 10, 200);
+  t = pick (&rng, 390, 450);
+  data->n = (data->m * t) / 100;
+  if (data->print) {
+    printf ("cnf %d %d ", data->m, data->n);
+    fflush (stdout);
+  }
+  data->lgl = lglinit ();
+  lglonabort (data->lgl, 0, onabort);
+  if (data->trace) lglwtrapi (data->lgl, data->trace);
+  data->navailable = data->m;
+  data->available = malloc (data->navailable * sizeof *data->available);
+  for (i = 0; i < data->navailable; i++) data->available[i] = i + 1;
+  if (data->noptsfuzz) return cnf;
+  return  (pick (&rng, 0, 1)) ? opts : cnf;
+}
+
+static void * inc (Data * data, unsigned r) {
+  int i, oldavailable;
+  int newvars;
+  RNG rng;
+  rng = initrng (r);
+  if (pick (&rng, 0, 1)) lglmaxvar (data->lgl);
+  while (pick (&rng, 0, 4))
+    lglfixed (data->lgl, pick (&rng, 1, data->m));
+  while (pick (&rng, 0, 3))
+    lglrepr (data->lgl, pick (&rng, 1, data->m));
+  if ((newvars = pick (&rng, 0, 50))) {
+    if (pick (&rng, 0, 1)) lglincvar (data->lgl);
+    oldavailable = data->navailable;
+    data->navailable += newvars;
+    data->available = 
+      realloc (data->available, data->navailable * sizeof *data->available);
+    for (i = 0; i < newvars; i++)
+      data->available[oldavailable + i] = data->m + i + 1;
+    data->m += newvars;
+  }
+  return cnf;
+}
+
+static void * opts (Data * data, unsigned r) {
+  int n = 0, min, val, max, m;
+  void * it;
+  RNG rng = initrng (r);
+  const char * name;
+  if (!pick (&rng, 0, 10)) lglsetopt (data->lgl, "plain", 1);
+  else {
+    it = lglfirstopt (data->lgl); 
+    while ((it = lglnextopt (data->lgl, it, &name, &val, &min, &max)))
+      n++;
+    assert (n > 0);
+    m = pick (&rng, 1, 10);
+    it = lglfirstopt (data->lgl);
+    while ((it = lglnextopt (data->lgl, it, &name, &val, &min, &max))) {
+      if (pick (&rng, 1, m) != 1) continue;
+      if (!strcmp (name, "check")) continue;
+      if (!strcmp (name, "drupligtrace")) continue;
+      if (!strcmp (name, "log")) continue;
+      if (!strcmp (name, "sleeponabort")) continue;
+      if (!strcmp (name, "exitonabort")) continue;
+      if (!strcmp (name, "verbose")) continue;
+      if (!strcmp (name, "witness")) continue;
+      if (!strcmp (name, "prune")) continue;
+      if (pick (&rng, 0, 1)) {
+	if (!strcmp (name, "locsmaxeff")) max = 10*min;
+	if (!strcmp (name, "locsrtc")) max = 0;
+	while (pick (&rng, 0, 1) && val < max) {
+	  if (val > INT_MAX/2) break;
+	  if (val < 4) val++; else val *= 2;
+	}
+	if (val > max) val = max;
+      } else {
+	while (pick (&rng, 0, 1) && val > min) {
+	  if (val > 0) val /= 2;
+	  else if (val > -4) val--;
+	  else if (val < INT_MIN/2) break;
+	  else val *= 2;
+	}
+	if (val < min) val = min;
+      }
+      lglsetopt (data->lgl, name, val);
+    }
+  }
+#ifndef NLGLDRUPLIG
+  if (!pick (&rng, 0, 3)) {
+    lglsetopt (data->lgl, "druplig", 1);
+    lglsetopt (data->lgl, "drupligcheck", 1);
+  }
+#endif
+  return cnf;
+}
+
+static void * cnf (Data * data, unsigned r) {
+  (void) r;
+  return data->c < data->n ? unit : lkhd;
+}
+
+static int lit (Data * data, RNG * r) {
+  int pos = pick (r, 0, data->navailable - 1);
+  int res = data->available[pos];
+  assert (0 < res && res <= data->m);
+  if (pick (r, 0, 1)) res = -res;
+  return res;
+}
+
+static void * unit (Data * data, unsigned r) {
+  RNG rng = initrng (r);
+  lgladd (data->lgl, lit (data, &rng));
+  if (!pick (&rng, 0, 99)) return clause;
+  return binary;
+}
+
+static void * binary (Data * data, unsigned r) {
+  RNG rng = initrng (r);
+  lgladd (data->lgl, lit (data, &rng));
+  if (!pick (&rng, 0, 10)) return clause;
+  return ternary;
+}
+
+static void * ternary (Data * data, unsigned r) {
+  RNG rng = initrng (r);
+  lgladd (data->lgl, lit (data, &rng));
+  if (pick (&rng, 0, 2)) return clause;
+  return rest;
+}
+
+static void * rest (Data * data, unsigned r) {
+  RNG rng = initrng (r);
+  lgladd (data->lgl, lit (data, &rng));
+  if (pick (&rng, 0, 3)) return clause;
+  return rest;
+}
+
+static void * clause (Data * data, unsigned r) {
+  lgladd (data->lgl, 0);
+  data->c += 1;
+  return cnf;
+}
+
+static int gcd (int a, int b) {
+  int r;
+  assert (a > 0 && b > 0);
+  while (b > 0) {
+    r = a % b;
+    a = b;
+    b = r;
+  }
+  return a;
+}
+
+static void * lkhd (Data * data, unsigned r) {
+  RNG rng = initrng (r);
+  if (!pick (&rng, 0, 10)) (void) lglookahead (data->lgl);
+  return sat;
+}
+
+static void * sat (Data * data, unsigned r) {
+  int res, freeze, i, pos, delta, lit, * assumed, nassumed, szassumed;
+  LGL * lgl = data->lgl;
+  State next = release;
+  RNG rng;
+  rng = initrng (r);
+  if (!pick (&rng, 0, 500)) lglchkclone (lgl);
+  freeze = pick (&rng, 0, 10);
+  if (freeze) {
+    if (data->navailable > 1) {
+      data->nfrozen =
+        pick (&rng, (data->navailable+9)/10, 2*(data->navailable+2)/3);
+      data->frozen = malloc (data->nfrozen * sizeof *data->frozen);
+      delta = pick (&rng, 1, data->navailable-1);
+      while (gcd (data->navailable, delta) != 1)
+	if (++delta == data->navailable) delta = 1;
+      pos = pick (&rng, 0, data->navailable-1);
+      for (i = 0; i < data->nfrozen; i++) {
+	assert (0 <= pos && pos < data->navailable);
+	lit = data->available[pos];
+	data->frozen[i] = lit;
+	pos += delta;
+	if (pos >= data->navailable) pos -= data->navailable;
+      }
+      for (i = 0; i < data->nfrozen; i++)
+	lglfreeze (lgl, data->frozen[i]);
+    } else if (data->navailable == 1) {
+      data->nfrozen = 1;
+      data->frozen = malloc (sizeof *data->frozen);
+      data->frozen[0] = data->available[0];
+    } else {
+      data->nfrozen = 0;
+      data->frozen = 0;
+    }
+  }
+#if 0
+  if (data->navailable && !pick (&rng, 0, 10)) {
+    i = pick (&rng, 0, 20);
+    while (i-- > 0) {
+      pos = pick (&rng, 0, data->navailable - 1);
+      lit = data->available[pos];
+      if (pick (&rng, 0, 1)) lit = -lit;
+      lglcassume (lgl, lit);
+    }
+    lglcassume (lgl, 0);
+  }
+#endif
+  if (data->navailable && !pick (&rng, 0, 3)) {
+    nassumed = 0;
+    assumed = malloc ((szassumed = 1)*sizeof *assumed);
+    do {
+      if (nassumed == szassumed)
+	assumed = realloc (assumed, (szassumed *= 2)*sizeof *assumed);
+      pos = pick (&rng, 0, data->navailable - 1);
+      lit = data->available[pos];
+      if (pick (&rng, 0, 1)) lit = -lit;
+      lglassume (lgl, lit);
+      assert (nassumed < szassumed);
+      assumed[nassumed++] = lit;
+    } while (!pick (&rng, 0, 10));
+  } else assumed = 0, nassumed = szassumed = 0;
+  if (!pick (&rng, 0, 4)) {
+    pos = pick (&rng, 0, data->navailable - 1);
+    lit = data->available[pos];
+    if (pick (&rng, 0, 1)) lit = -lit;
+    if (!pick (&rng, 0, 3)) lglresetphase (lgl, lit);
+    else lglsetphase (lgl, lit);
+    if (!pick (&rng, 0, 11)) lglsetimportant (lgl, lit);
+  }
+  if (!pick (&rng, 0, 100)) lglchkclone (lgl);
+  if (!pick (&rng, 0, 66)) lglfixate (lgl);
+  if (pick (&rng, 0, 20)) res = lglsat (lgl);
+  else res = lglsimp (lgl, pick (&rng, 0, 10));
+  assert (!res || res == 10 || res == 20);
+  if (res == 10) {
+    if (data->print) printf ("sat ");
+    if (!pick (&rng, 0, 4)) lglinconsistent (lgl);
+    if (!pick (&rng, 0, 20)) lglsetphases (lgl);
+    i = pick (&rng, 0, data->m);
+    while (i--) {
+      lit = pick (&rng, 1, 2*data->m);
+      if (pick (&rng, 0, 1)) lit = -lit;
+      lglderef (lgl, lit);
+    }
+    if (!pick (&rng, 0, 30)) lglsetphases (lgl);
+    if (freeze) {
+      assert (data->nfrozen <= data->navailable);
+      data->navailable = 0;
+      for (i = 0; i < data->nfrozen; i++) {
+	lit = data->frozen[i];
+	switch (i % 5) {
+	  case 0:
+	    lglmelt (lgl, lit);
+	    /* FALL THROUGH */
+	  case 1:
+	    data->available[data->navailable] = lit;
+	    data->navailable++;
+	    break;
+	  case 2:
+	    data->available[data->navailable] = ++data->m;
+	    data->navailable++;
+	    break;
+	  case 3:
+	    lglmelt (lgl, lit);
+	    /* FALL THROUGH */
+	    break;
+	  default:
+	    break;
+	}
+      }
+      free (data->frozen);
+    }
+    if (freeze >= 2) {
+      data->n = (pick (&rng, 101, 130) * data->n + 99) / 100;
+      next = inc;
+    }
+    if (!pick (&rng, 0, 4)) lglchanged (lgl);
+    if (!pick (&rng, 0, 3)) {
+      int count = pick (&rng, 1, (data->m)/10), i;
+      for (i = 0; i < count; i++) {
+	int lit = pick (&rng, 1, data->m);
+	if (!lglusable (lgl, lit) && lglreusable (lgl, lit))
+	  lglreuse (lgl, lit);
+      }
+    }
+  } else if (res == 20) {
+    if (data->print) printf ("uns ");
+    if (nassumed > 0) {
+      i = pick (&rng, 0, 3*nassumed/2);
+      while (i-- > 0)
+	(void) lglfailed (data->lgl, assumed [ pick (&rng, 0, nassumed-1)]);
+    }
+    if (!pick (&rng, 0, 4)) lglinconsistent (lgl);
+  } else if (data->print) printf ("nil ");
+  if (data->print) fflush (stdout);
+  if (!pick (&rng, 0, 11)) lglreducecache (lgl);
+  else if (!pick (&rng, 0, 17)) lglflushcache (lgl);
+  if (!pick (&rng, 0, 1000)) lglchkclone (lgl);
+  free (assumed);
+  return next;
+}
+
+static void * release (Data * data, unsigned r) {
+  lglrelease (data->lgl);
+  return 0;
+}
+
+static void rantrav (Env * env) {
+  State state, next;
+  unsigned rand;
+  Data data;
+  memset (&data, 0, sizeof data);
+  data.print = env->print;
+  env->rng.z = env->rng.w = env->seed;
+  for (state = init; state; state = next) {
+    rand = nextrand (&env->rng);
+    if (env->file) { 
+      fprintf (env->file, "%p %x\n", state, rand);
+      fflush  (env->file);
+    }
+    next = state (&data, rand);
+  }
+}
+
+static void erase (void) {
+  int i;
+  fputc ('\r', stdout);
+  for (i = 0; i < 79; i++) fputc (' ', stdout);
+  fputc ('\r', stdout);
+}
+
+static int isnumstr (const char * str) {
+  const char * p;
+  for (p = str; *p; p++)
+    if (!isdigit ((int)*p)) return 0;
+  return 1;
+}
+
+static void die (const char * msg, ...) {
+  va_list ap;
+  fputs ("*** lglmbt: ", stderr);
+  va_start (ap, msg);
+  vfprintf (stderr, msg, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  exit (1);
+}
+
+static int run (Env * env, void(*process)(Env *)) {
+  int res, status, saved1, saved2, null, tmp;
+  pid_t id;
+  env->forked++;
+  fflush (stdout);
+  if ((id = fork ())) {
+#ifndef NDEBUG
+    pid_t wid =
+#endif
+    wait (&status);
+    assert (wid == id);
+  } else { 
+    saved1 = dup (1);
+    saved2 = dup (2);
+    null = open ("/dev/null", O_WRONLY);
+    close (1);
+    close (2);
+#ifndef NDEBUG
+    tmp = 
+#endif
+    dup (null);
+    assert (tmp == 1);
+#ifndef NDEBUG
+    tmp = 
+#endif
+    dup (null);
+    assert (tmp == 2);
+    if (env->timeout > 0) alarm (env->timeout);
+    process (env); 
+    close (null);
+    close (2);
+#ifndef NDEBUG
+    tmp = 
+#endif
+    dup (saved2);
+    assert (tmp == 2);
+    close (1);
+#ifndef NDEBUG
+    tmp = 
+#endif
+    dup (saved1);
+    assert (tmp == 1);
+    exit (0); 
+  }
+  if (WIFEXITED (status)) {
+    res = WEXITSTATUS (status);
+    if (res == 42) res = 0, env->violations++;
+    else if (env->print) printf ("exit %d ", res);
+  } else if (WIFSIGNALED (status)) {
+    if (env->print) printf ("signal");
+    res = 1;
+  } else {
+    if (env->print) printf ("unknown");
+    res = 1;
+  }
+  return res;
+}
+
+static void printrace (Env * env) {
+  char * name;
+  Data data;
+  Event * e;
+  int i;
+  memset (&data, 0, sizeof data);
+  data.print = 0;
+  assert (env->events);
+  assert (env->prefix);
+  name = malloc (strlen (env->prefix) + 80);
+  sprintf (name, "%s-%u.trace", env->prefix, env->seed);
+  data.trace = fopen (name, "w");
+  data.noptsfuzz = env->noptsfuzz;
+  assert (data.trace); //FIXME
+  for (i = 0; i < env->nevents; i++) {
+    e = env->events + i;
+    if (e->remove) continue;
+    (void) e->state (&data, e->rand);
+  }
+  fclose (data.trace);
+  free (name);
+}
+
+static void prwc (Env * env, const char * prefix) {
+  char * name = malloc (strlen (prefix) + 80);
+  int ch, res = 0;
+  FILE * file;
+  sprintf (name, "%s-%u.trace", prefix, env->seed);
+  file = fopen (name, "r");
+  assert (file);//FIXME
+  while ((ch = getc (file)) != EOF)
+    if (ch == '\n') res++;
+  fclose (file);
+  if (!env->quiet) {
+    printf (" %s %d", name, res);
+    fflush (stdout);
+  }
+  free (name);
+}
+
+static void dd (Env * env, const char * filename, int golden, int opt) {
+  unsigned rand;
+  State state;
+  FILE * file;
+  char * cmd;
+  int i;
+  file = fopen (filename, "r");
+  assert (file);//FIXME
+  env->nevents = 0;
+  while (fscanf (file, "%p %x\n", &state, &rand) == 2)
+    env->nevents += 1;
+  fclose (file);
+  env->events = calloc (env->nevents, sizeof (Event));
+  file = fopen (filename, "r");
+  assert (file);//FIXME
+  i = 0;
+  while (fscanf (file, "%p %x\n", &state, &rand) == 2) {
+    assert (i < env->nevents);
+    env->events[i].state = state;
+    env->events[i].rand = rand;
+    env->events[i].remove = 0;
+    i++;
+  }
+  fclose (file);
+  assert (i == env->nevents);
+  env->prefix = "bug";
+  run (env, printrace);
+  prwc (env, "bug");
+  // TODO now do delta debugging on the model level
+  // ...
+  cmd = malloc (100);
+  if (env->nodd)
+    sprintf (cmd, 
+	     "cp bug-%u.trace red-%u.trace",
+	     env->seed, env->seed);
+  else
+    sprintf (cmd, 
+	     "./lglddtrace %s bug-%u.trace red-%u.trace",
+	     opt ? "-O" : "", env->seed, env->seed);
+  {
+    int tmp = system (cmd);
+    (void) tmp;
+  }
+  prwc (env, "red");
+  free (cmd);
+  free (env->events);
+}
+
+static unsigned hashmac (void) {
+  FILE * file = fopen ("/sys/class/net/eth0/address", "r");
+  unsigned mac[6], res = 0;
+  if (!file) return 0;
+  if (fscanf (file, "%02x:%02x:%02x:%02x:%02x:%02x",
+              mac+0, mac+1, mac+2, mac+3, mac+4, mac+5) == 6) {
+    res =  mac[5];
+    res ^= mac[4] << 4;
+    res ^= mac[3] << 8;
+    res ^= mac[2] << 16;
+    res ^= mac[1] << 20;
+    res ^= mac[0] << 24;
+  }
+  fclose (file);
+  return res;
+}
+
+static const char * usage =
+"usage: lglmbt [ <option> ... ] [ <seed> ]\n"
+"\n"
+"where <option> is one of the following:\n"
+"\n"
+"  -k | --keep-lines\n"
+"  -q | --quiet\n"
+"  -f | --first-bug-only\n"
+"  -n | --no-delta-debugging\n"
+"  -a | --always-fork\n"
+"  -O | --optimize-by-delta-debugging-options\n"
+"\n"
+"  -m <maxruns>\n"
+;
+
+static Env env;
+static double start;
+
+static double currentime (void) {
+  double res = 0;
+  struct timeval tv;
+  if (!gettimeofday (&tv, 0)) res = 1e-6 * tv.tv_usec, res += tv.tv_sec;
+  return res;
+}
+
+static double getime () { return currentime () - start; }
+static double average (double a, double b) { return b ? a / b : 0; }
+
+static void stats (void) {
+  double t = getime ();
+  int valid = env.round - env.violations;
+  printf ("[lglmbt] finished after %.2f seconds\n", t);
+  printf ("[lglmbt] %d rounds = %.0f rounds per second\n", 
+    env.round, average (env.round, t));
+  printf ("[lglmbt] %d violations = %.0f rounds per second\n", 
+    env.violations, average (env.violations, t));
+  printf ("[lglmbt] %d valid runs = %.0f rounds per second\n", 
+    valid, average (valid, t));
+  printf ("[lglmbt] %d bugs = %.0f bugs per second\n", 
+    env.bugs, average (env.bugs, t));
+}
+
+static void sighandler (int sig) {
+  fflush (stdout);
+  fflush (stderr);
+  printf ("*** lglmbt: caught signal %d in round %d\n", sig, env.round);
+  fflush (stdout);
+  stats ();
+  exit (1);
+}
+
+static void setsighandlers (void) {
+  (void) signal (SIGINT, sighandler);
+  (void) signal (SIGSEGV, sighandler);
+  (void) signal (SIGABRT, sighandler);
+  (void) signal (SIGTERM, sighandler);
+}
+
+int main (int argc, char ** argv) {
+  int i, max, res, tmp, prev, opt, mac, pid;
+  start = currentime ();
+  memset (&env, 0, sizeof env);
+  max = INT_MAX; 
+  prev = 1;
+  memset (&env, 0, sizeof env);
+  env.seed = -1;
+  env.terminal = isatty (1);
+  env.timeout = 0;
+  opt = 0;
+  for (i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h")) {
+      printf ("%s", usage);
+      exit (0);
+    }
+    else if (!strcmp (argv[i], "-k") ||
+             !strcmp (argv[i], "--keep-lines")) env.terminal = 0;
+    else if (!strcmp (argv[i], "-q") ||
+             !strcmp (argv[i], "--quiet")) env.quiet = 1;
+    else if (!strcmp (argv[i], "-f") ||
+             !strcmp (argv[i], "--first-bug-only")) env.first = 1;
+    else if (!strcmp (argv[i], "-n") ||
+             !strcmp (argv[i], "--no-delta-debugging")) env.nodd = 1;
+    else if (!strcmp (argv[i], "-d") ||
+             !strcmp (argv[i], "--do-not-fuzz-options")) env.noptsfuzz = 1;
+    else if (!strcmp (argv[i], "-a") ||
+             !strcmp (argv[i], "--always-fork")) env.alwaysfork = 1;
+    else if (!strcmp (argv[i], "-O") ||
+             !strcmp (argv[i], "--optimize-by-delta-debugging-options"))
+      opt = 1;
+    else if (!strcmp (argv[i], "-t")) {
+      if (++i == argc)
+	die ("argument to '-t' missing (try '-h')");
+      if (!isnumstr (argv[i]))
+	die ("argument '%s' to '-t' not a number (try '-h')", argv[i]);
+      env.timeout = atoi (argv[i]);
+    } else if (!strcmp (argv[i], "-m")) {
+      if (++i == argc)
+	die ("argument to '-m' missing (try '-h')");
+      if (!isnumstr (argv[i]))
+	die ("argument '%s' to '-m' not a number (try '-h')", argv[i]);
+      max = atoi (argv[i]);
+    } else if (!isnumstr (argv[i])) {
+      die ("invalid command line option '%s' (try '-h')", argv[i]);
+    } else env.seed = atoi (argv[i]);
+  }
+  env.print = !env.quiet;
+  if (env.seed != -1 && !env.alwaysfork) {
+    rantrav (&env);
+    printf ("\n");
+  } else {
+    mac = hashmac ();
+    pid = getpid ();
+    setsighandlers ();
+    for (env.round = 0; env.round < max; env.round++) {
+      if (!(prev & 1)) prev++;
+      {
+	env.seed = mac;
+	env.seed *= 123301093;
+	env.seed += times (0);
+	env.seed *= 223531513;
+	env.seed += pid;
+	env.seed *= 31752023;
+	env.seed += prev;
+	env.seed *= 43376579;
+	prev = env.seed = abs (env.seed) >> 1;
+      }
+      if (!env.quiet) {
+	if (env.terminal) erase ();
+	printf ("%d %d ", env.round, env.seed);
+	fflush (stdout);
+      }
+      res = run (&env, rantrav);
+      if (res > 0) {
+	char name[100];
+	env.bugs++;
+	sprintf (name, "/tmp/lglmbt-tmp-%d.trace", getpid ());
+	env.file = fopen (name, "w");
+	env.print = 0;
+#ifndef NDEBUG
+	tmp = 
+#endif
+	run (&env, rantrav);
+	assert (tmp == res);
+	fclose (env.file);
+	env.file = 0;
+	dd (&env, name, res, opt);
+	unlink (name);
+	env.print = !env.quiet;
+      }
+      if (!env.quiet) {
+	if (res || !env.terminal) printf ("\n");
+	fflush (stdout);
+      }
+      if (res && env.first) break;
+    }
+  }
+  if (!env.quiet) {
+    if (env.terminal) erase ();
+    printf ("forked %d\n", env.forked);
+  }
+  stats ();
+  return 0;
+}
diff --git a/lgloptl.h b/lgloptl.h
new file mode 100644
index 0000000..ecbd397
--- /dev/null
+++ b/lgloptl.h
@@ -0,0 +1,355 @@
+OPT(abstime,0,0,1,"print absolute time when reporting");
+OPT(activity,0,0,2,"activity based clause reduction");
+OPT(agility,1,0,1,"enable agility based restart skipping");
+OPT(agilitylim,70,0,100,"agility limit for restarts in percent");
+OPT(bate,1,0,1,"basic ATE removal during probing");
+OPT(batewait,2,0,2,"wait for BCE (1) and/or BVE (2)");
+OPT(bca,0,0,2,"enable blocked clause addition (1=weak,2=strong)");
+OPT(bcaddlimldscale,2,-7,7,"bca added clause limit ld scale");
+OPT(bcamaxeff,10*M,0,I,"BCA maximum number of steps");
+OPT(bcaminuse,100,0,I,"min number of literals required to be usable");
+OPT(bcawait,2,0,2,"wait for BCE (1) and/or BVE (2)");
+OPT(bkwdocclim,100,0,I,"backward occurrence limit");
+OPT(bkwdresched,1,0,1,"reschedule variables during backward");
+OPT(bkwdroundlim,7,1,I,"bkwd round limit");
+OPT(bkwdscale,100,1,10000,"bkwd steps vs elm steps in percent");
+OPT(blkboost,10,1,10000,"initial BCE boost");
+OPT(blkboostvlim,10*M,0,I,"BCE boost variable limit");
+OPT(blkclslim,1*M,3,I,"max blocked clause size");
+OPT(blklarge,1,0,1,"BCE of large clauses");
+OPT(blkmaxeff,800*M,-1,I,"max effort in BCE (-1=unlimited)");
+OPT(blkmineff,50*M,0,I,"min effort in BCE");
+OPT(blkocclim1,100*K,1,I,"one-sided max occ of BCE");
+OPT(blkocclim,1*M,3,I,"max occ in BCE");
+OPT(blkocclim2,10*K,2,I,"two-sided max occ of BCE");
+OPT(blkreleff,100,0,K,"rel effort in BCE");
+OPT(blkresched,1,0,1,"reschedule tried but failed literals");
+OPT(blkrtc,0,0,1,"run BCE until completion");
+OPT(blksmall,1,0,1,"BCE of small clauses");
+OPT(blksuccessmaxwortc,6,1,I,"BCE success max without run-to-completion");
+OPT(blksuccessrat,100,1,I,"BCE success ratio");
+OPT(block,0,0,1,"blocked clause elimination (BCE)");
+OPT(blockwait,1,0,1,"wait for BVE");
+OPT(boost,1,0,1,"enable boosting of preprocessors");
+OPT(bumpreasonlits,1,0,1,"bump reason literals too");
+OPT(bumpsimp,0,0,1,"bump during simplification too");
+OPT(card,1,0,1,"cardinality constraint reasoning");
+OPT(cardcut,2,0,2,"1=gomoroy-cuts,2=strengthen");
+OPT(cardexpam1,3,2,I,"min length of exported at-most-one constraint");
+OPT(cardglue,0,-1,MAXGLUE,"use lrg red cls too (-1=irr,0=moved,...)");
+OPT(cardignused,0,0,1,"ignore already used literals in extraction");
+OPT(cardmaxeff,300*M,-1,I,"max effort for cardmineff reasoning");
+OPT(cardmaxlen,1000,0,I,"maximal length of cardinality constraints");
+OPT(cardmineff,2*M,0,I,"min effort for cardmineff reasoning");
+OPT(cardminlen,3,0,I,"minimal length of (initial) card constraints");
+OPT(cardocclim1,300,0,I,"one-sided cardinality constraints occ limit");
+OPT(cardocclim2,15,0,I,"two-sided cardinality constraints occ limit");
+OPT(cardreleff,5,0,10*K,"rel effort for cardinality reasoning");
+OPT(cardreschedint,10,1,I,"reschedule variable for card reasoning");
+OPT(carduse,2,0,3,"use clauses (1=oneside,2=bothsidetoo,3=anyside)");
+OPT(cardwait,0,0,2,"wait for BCE (1) and/or BVE (2)");
+OPT(classify,2,0,3,"classifier for parameter setting");
+OPT(cce2wait,1,0,I,"wait for ATE to finish before doing ABCE");
+OPT(cce,3,0,3,"covered clause elimination (1=ate,2=abce,3=acce)");
+OPT(cce3wait,2,0,I,"wait for ABCE to finish before doing ACCE");
+OPT(cceateint,2,1,I,"frequency of only ATE");
+OPT(cceboost,10,1,1000,"CCE boost");
+OPT(cceboostdel,3,0,100,"initial CCE boost delay");
+OPT(cceboostint,5,1,I,"CCE boost interval");
+OPT(cceboostvlim,10*M,0,I,"CCE boost variable limit");
+OPT(ccemaxeff,I,-1,I,"max effort in covered clause elimination");
+OPT(ccemaxround,3,0,I,"cce maximum rounds");
+OPT(ccemineff,30*M,0,I,"min effort in covered clause elimination");
+OPT(ccereleff,50,0,K,"rel effort in covered clause elimination");
+OPT(ccertc,0,0,2,"run CCE until completition (1=almost-no-limit)");
+OPT(ccertcint,15,1,I,"run CCE until completion interval");
+OPT(ccertcintvlim,2*M,1,I,"run CCE until completion int var limit");
+OPT(ccesuccessrat,100,1,I,"CCE success ratio");
+OPT(ccewait,2,0,2,"wait for BCE (1) and/or BVE (2)");
+OPT(check,0,0,3,"check level");
+OPT(clim,-1,-1,I,"conflict limit");
+OPT(compact,0,0,2,"compactify after 'lglsat/lglsimp' (1=UNS,2=SAT)");
+OPT(deco,1,0,1,"learn decision-only clauses too");
+OPT(deco1opt,1,0,1,"optimized deco 1");
+OPT(decolim,100,0,I,"decision-only clauses glue limit");
+OPT(decompose,1,0,1,"enable decompose");
+OPT(defragfree,50,10,K,"defragmentation free watches limit");
+OPT(defragint,10*M,100,I,"defragmentation pushed watches interval");
+OPT(delmax,10,0,10,"maximum delay");
+OPT(dlim,-1,-1,I,"decision limit");
+OPT(druplig,0,0,1,"connect to Druplig library");
+OPT(drupligcheck,0,0,1,"enable checking of proof by Druplig");
+OPT(drupligtrace,0,0,1,"enable tracing of proof by Druplig");
+OPT(drupligtraceorig,0,0,1,"trace original clauses too");
+OPT(elim,1,0,1,"bounded variable eliminiation (BVE)");
+OPT(elmaxeff,800*M,-1,I,"max effort in BVE (-1=unlimited)");
+OPT(elmblk,1,0,1,"enable BCE during BVE");
+OPT(elmblkwait,1,0,1,"wait for BVE to be completed once");
+OPT(elmboost,20,1,1000,"elimination boost");
+OPT(elmboostdel,3,0,100,"initial elimination boost delay");
+OPT(elmboostint,5,1,I,"elimination boost interval");
+OPT(elmboostvlim,4*M,1,I,"elimination boost var lim");
+OPT(elmclslim,1*M,3,I,"max antecendent size in elimination");
+OPT(elmfull,0,0,1,"no elimination limits");
+OPT(elmineff,20*M,0,I,"min effort in BVE");
+OPT(elmlitslim,200,0,I,"one side literals limit for elimination");
+OPT(elmocclim1,1000,1,I,"one-sided max occ of BVE");
+OPT(elmocclim,1*M,3,I,"max occurrences in BVE");
+OPT(elmocclim2,100,2,I,"two-sided max occ of BVE");
+OPT(elmoccsumforced,0,0,10,"forced occurrence sum");
+OPT(elmreleff,200,0,10*K,"rel effort in BVE");
+OPT(elmresched,0,0,7,"reschedule variables (1=else,2=boost,4=full)");
+OPT(elmroundlim,3,1,I,"variable elimination rounds limit");
+OPT(elmrtc,0,0,2,"run BVE until completion (1=almost-no-limit)");
+OPT(elmrtcint,10,1,I,"run BVE until completion interval");
+OPT(elmrtcintvlim,500*K,1,I,"run BVE until completion int var limit");
+OPT(elmotfstr,1,0,1,"on-the-fly strengthening during BVE");
+OPT(elmotfsub,1,0,1,"on-the-fly subsumption during BVE");
+OPT(elmsuccessmaxwortc,4,1,I,"BVE success max without run-to-completion");
+OPT(elmsuccessrat,100,1,I,"BVE success ratio");
+OPT(exitonabort,0,0,1,"exit instead abort after internal error");
+OPT(factmax,100000,1,I,"maximum factor");
+OPT(factor,3,0,3,"{cls,occ}lim factors (0=const1,1=ld,2=lin,3=sqr)");
+OPT(features,0,0,I,"print features after that many simplifications");
+OPT(gauss,1,0,1,"enable gaussian elimination");
+OPT(gausscardweak,1,0,1,"extract XOR from cardinality constraints");
+OPT(gaussexptrn,1,0,1,"export trn cls from gaussian elimination");
+OPT(gaussextrall,1,0,1,"extract all xors (with duplicates)");
+OPT(gaussmaxeff,50*M,-1,I,"max effort in gaussian elimination");
+OPT(gaussmaxor,20,2,64,"maximum xor size in gaussian elimination");
+OPT(gaussmineff,2*M,0,I,"min effort in gaussian elimination");
+OPT(gaussreleff,2,0,10*K,"rel effort in gaussian elimination");
+OPT(gausswait,2,0,2,"wait for BCE (1) and/or BVE (2) for XOR extraction");
+OPT(gluekeep,4,1,I,"keep clauses with this original glue");
+OPT(gluekeepsize,15,1,I,"but limit them to this size");
+OPT(gluemacdfast,5,0,32,"e for fast (D)EMA with alpha=2^-e");
+OPT(gluemacdslow,16,0,32,"e for slow (D)EMA with alpha=2^-e");
+OPT(gluemacdsmooth,3,0,32,"e for avg EMA with alpha=2^-e");
+OPT(gluescale,4,1,5,"glue scaling: 1=ar1,2=ar2,3=sqrt,4=sqrtld,5=ld");
+OPT(hbrdom,2,0,2,"0=root-impl-tree,1=lca-impl-tree,2=lca-big-dag");
+OPT(import,1,0,1,"import external indices and map them");
+OPT(incredcint,1,1,I,"incremental reduce conflict interval");
+OPT(incredconfslim,0,0,100,"incremental reduce conflict limit");
+OPT(incsavevisits,0,0,1,"incremental start new visits counter");
+OPT(inprocessing,1,0,1,"enable inprocessing");
+OPT(irrlim,1,0,1,"use irredundant clauses as limit for simps");
+OPT(itsmacdfast,12,0,32,"e for fast (D)EMA with alpha=2^-e");
+OPT(itsmacdslow,18,0,32,"e for slow (D)EMA with alpha=2^-e");
+OPT(itsmacdsmooth,10,0,32,"e for avg EMA with alpha=2^-e");
+OPT(jlevelmacdfast,12,0,32,"e for fast (D)EMA with alpha=2^-e");
+OPT(jlevelmacdslow,14,0,32,"e for slow (D)EMA with alpha=2^-e");
+OPT(jlevelmacdsmooth,10,0,32,"e for avg EMA with alpha=2^-e");
+OPT(jwhred,1,0,2,"JWH score based on redundant clauses too (2=only)");
+OPT(keepmaxglue,1,0,1,"keep maximum glue clauses");
+OPT(keepmaxglueint,1,1,I,"keep maximum glue clause interval (1 always)");
+OPT(lhbr,1,0,1, "enable lazy hyber binary reasoning");
+OPT(lkhd,2,-1,3, "-1=LOCS,0=LIS,1=JWH,2=TREELOOK,3=LENSUM");
+OPT(locs,0,-1,I,"use local search (-1=always otherwise how often)");
+OPT(locsbanner,0,0,1,"print version number of LOCS component");
+OPT(locsboost,2,0,100,"initial local search boost");
+OPT(locscint,10*K,1,I,"conflict interval for LOCS");
+OPT(locsclim,1*M,0,(I>>8),"clause limit for local search");
+OPT(locset,2,0,2,"initialize local search phases (1=prev,2=cur)");
+OPT(locsexport,1,0,1,"export phases from local search");
+OPT(locsmaxeff,100000,0,I,"max effort in local search");
+OPT(locsmineff,1000,0,I,"min effort in local search");
+OPT(locsred,0,0,4,"apply local search on redundant clauses too");
+OPT(locsreleff,5,0,100,"rel effort in local search");
+OPT(locsrtc,0,0,1,"run local search until completion");
+OPT(locsvared,100,0,1000,"max variable reduction for LOCS");
+OPT(locswait,2,0,2,"wait for BCE(1) and/or BVE(2)");
+OPT(log,-1,-1,5,"log level");
+OPT(maxscaledglue,MAXGLUE,0,MAXGLUE,"maximum scaled glue bound");
+OPT(memlim,-1,-1,I,"memory limit in MB (-1=no limit)");
+OPT(minimize,2,0,2,"minimize learned clauses (1=local,2=recursive)");
+OPT(minlocalgluelim,200,0,I,"glue limit for using local minimization");
+OPT(minlocalsizelim,3000,0,I,"size limit for using local minimization");
+OPT(minrecgluelim,100,0,I,"glue limit for using recursive minimization");
+OPT(minrecsizelim,1000,0,I,"size limit for using recursive minimization");
+OPT(move,2,0,2,"move redundant cls (1=only-binary,2=ternary-too)");
+OPT(otfs,0,0,1,"enable on-the-fly subsumption");
+OPT(penmax,4,0,16,"maximum penalty");
+OPT(phase,0,-1,1,"default initial phase (-1=neg,0=JeroslowWang,1=pos)");
+OPT(phaseluckfactor,200,100,10*K,"min phase luck factor (pos/neg)");
+OPT(phaselucklim,100,0,1000,"phase luck limit in promille");
+OPT(phaseluckmaxround,10,0,I,"maximum number of phase luck checks");
+OPT(phasesave,1,-1,1,"save and use previous phase (-1=reverse)");
+OPT(plain,0,0,1,"plain mode disables all preprocessing");
+OPT(plim,-1,-1,I,"propagation limit (thousands)");
+OPT(poison,1,0,1,"poison optimization for clause minimization");
+OPT(prbasic,1,0,2,"enable basic probing procedure (1=roots-only)");
+OPT(prbasicmaxeff,400*M,-1,I,"max effort in basic probing");
+OPT(prbasicmineff,M,0,I,"min effort in basic probing");
+OPT(prbasicreleff,50,0,10*K,"rel effort in basic probing");
+OPT(prbasicroundlim,8,1,I,"basic probing round limit");
+OPT(prbasicrtc,0,0,1,"run basic probing until completion");
+OPT(prbrtc,0,0,1,"run all probing until completion");
+OPT(prbsimple,2,0,3,"simple probing (1=shallow,2=deep,3=touchall)");
+OPT(prbsimpleboost,10,1,1000,"initial simple probing boost");
+OPT(prbsimpleliftdepth,2,1,4,"simple probing lifting depth");
+OPT(prbsimplemaxeff,200*M,-1,I,"max effort in simple probing");
+OPT(prbsimplemineff,2*M,0,I,"min effort in simple probing");
+OPT(prbsimplereleff,40,0,10*K,"rel effort in simple probing");
+OPT(prbsimplertc,0,0,1,"run simple probing until completion");
+OPT(probe,1,0,1,"enable probing");
+OPT(profile,1,0,4,"profile level");
+OPT(profilelong,0,0,1,"print long profile information");
+OPT(promote,1,0,1,"keep clauses with reduced glue longer");
+OPT(promotegluelim,8,0,MG,"promoted clauses reduced glue limit");
+OPT(prune,0,0,1,"pruning through satisfication");
+OPT(pruneclim,1000,0,I,"maximum conflict limit");
+OPT(pruneinit,2,1,I,"initial decision interval");
+OPT(prunelevel,2,1,I,"maximum decision level");
+OPT(prunesize,10,2,I,"maximum clause size");
+OPT(prunemin,0,0,I,"minimum decision interval");
+OPT(prunemax,1000000,1,I,"maximum decision interval");
+OPT(prunepure,1,0,1,"find and treat pure literals explicitly");
+OPT(prunered,1,0,1,"learned pruning clauses as redundant clauses");
+OPT(prunevsids,0,0,1,"pruning decisions using default heuristic");
+OPT(pure,1,0,1,"enable pure literal elimination during BCE");
+OPT(quatres,1,0,1,"enable quaternay resolution");
+OPT(quatreswait,2,0,2,"wait with quaternay resolution");
+OPT(queuesort,1,0,1,"sort decision queue by JWH score");
+OPT(randec,0,0,1,"enable random decisions order");
+OPT(randecint,809,2,I/2,"random decision order interval");
+OPT(randphase,0,0,1,"enable random decision phases");
+OPT(randphaseint,503,2,I/2,"random decision phases interval");
+OPT(redcls,1,0,1,"reduce literals in learned clauses");
+OPT(redclsglue,6,0,I,"upper glue limit for clause reduction");
+OPT(redclsize,30,0,I,"size limit reducing literals in learned clauses");
+OPT(redclsmaxdec,5,1,I,"max decisions checked per lit");
+OPT(redclsmaxdepth,10,1,I,"max depth for propagation per lit");
+OPT(redclsmaxlrg,10,0,I,"max large checked per lit for redcls");
+OPT(redclsmaxprops,100,0,I,"max props per lit for redcls");
+OPT(redclstype,4,2,4,"type of clauses used for reduction");
+OPT(reduce,1,0,1,"enable clause reduction");
+OPT(reducefixed,0,0,1,"enabled fixed bound on learned clauses");
+OPT(reduceinc,300,1,10*M,"reduce limit increment");
+OPT(reduceinit,2*K,1,100*M,"initial reduce limit");
+OPT(reducereset,0,0,2,"enable reduce increment reset");
+OPT(restart,1,0,1,"enable restarting");
+OPT(restartfixed,0,0,1,"fixed restart");
+OPT(restartblock,0,0,2,"enable restart blocking (1=conflict,2=restart)");
+OPT(restartblocklim,200,1,K,"restart blocking limit percent (glucose R)");
+OPT(restartblockbound,10*K,0,I,"restart blocking conflict lower bound");
+OPT(restartcheckforced,1,0,1,"enable skipping restarts if not forced");
+OPT(restartdelay,1,0,1,"enable restart delaying based on jump level");
+OPT(restartdelaylim,50,1,K,"restart delaying limit in percent");
+OPT(restartint,10,1,I,"base restart interval");
+OPT(restartforcelim,115,1,K,"restart forcing limit percent (glucose K)");
+OPT(restartforcemode,1,0,2,"forced restart mode (0=avg,1=ema,2=macd)");
+OPT(restartpen1,1,0,1,"increase restart interval if few units");
+OPT(restartpen2,1,0,1,"increase restart interval if few binary clauses");
+OPT(restartpen3,1,0,1,"increase restart interval if few ternary clauses");
+OPT(restartpenstab,1,0,1,"increase restart interval if stabilizing");
+OPT(retireint,4,0,1000,"retire inactive clauses inprocessing phases count");
+OPT(retiremin,1,0,I,"minimum glue for retirement");
+OPT(retirenb,1,0,1,"enabled inactive clause retirement");
+OPT(reusetrail,1,0,1,"reuse trail");
+OPT(rmincpen,4,0,32,"logarithm of watcher removal penalty");
+OPT(scincinc,250,1,10*K,"score increment increment in per mille");
+OPT(scincincdelta,10,0,10*K,"delta score inc inc in per mille");
+OPT(scincincincint,100*K,1,I,"score inc inc inc interval");
+OPT(scincincmin,50,1,10*K,"min score inc inc in per mille");
+OPT(scincincmode,1,0,2,"score inc inc mode (0=keep,1=delta,2=avg)");
+OPT(scoreshift,24,0,64,"score shift");
+OPT(seed,0,0,I,"random number generator seed");
+OPT(simpbintinc,100,1,I,"inprocessing binary interval increment");
+OPT(simpbintinclim,10*K,1,I,"inprocessing bin int inc limit");
+OPT(simpcintdelay,2000,0,I,"inprocessing conflict delay");
+OPT(simpcintinc,20*K,10,M,"inprocessing conflict interval increment");
+OPT(simpcintincdiv,1,0,3,"cintinc reduction: 0=no,1=div1,2=div2,3=heur");
+OPT(simpcintmaxhard,10*M,-1,I,"hard max conflict interval limit");
+OPT(simpcintmaxsoft,1*M,-1,I,"soft max conflict interval limit");
+OPT(simpidiv,3,1,100,"simplification inter delay divisor");
+OPT(simpincdelmaxfact,50,0,1000,"inproc incremental delay max fact");
+OPT(simpincdelmaxmin,10*K,0,I,"inproc incremental delay max min confs");
+OPT(simpinitdelay,0,0,I,"initial simplification delay");
+OPT(simpintsizepen,0,0,1,"penalize interval (positively) by size");
+OPT(simpiscale,100,1,10000,"relative simplification inter delay scale");
+OPT(simpitdelay,10,0,1000,"delay inpr by simpitdelay/delta-conf-per-it");
+OPT(simpjleveldecdelay,1,0,1,"delay simp if jlevel decreases");
+OPT(simpitintdecdelay,1,0,1,"delay simp if iteration interval decreases");
+OPT(simpitintinc,10,1,I,"inprocessing iteration interval increment");
+OPT(simpitintinclim,1*K,1,I,"inprocessing its int inc limit");
+OPT(simplify,2,0,2,"enable simplification");
+OPT(simprtc,5,1,100,"min var reduction for simplification RTC");
+OPT(simptintinc,1000,1,I,"inprocessing ternary interval increment");
+OPT(simptintinclim,10*K,1,I,"inprocessing trn int inc limit");
+OPT(simpvarchg,100,1,1000, "simp remaining vars percentage change lim");
+OPT(simpvarlim,100,0,I, "simp remaining vars min limit");
+OPT(sizemaxpen,5,0,20,"maximum logarithmic size penalty");
+OPT(sizepen,1*M,1,I,"number of clauses size penalty starting point");
+OPT(sleeponabort,0,0,I,"sleep this seconds before abort/exit");
+OPT(smallirr,90,0,100,"max percentage irr lits for BCE and VE");
+OPT(smallve,1,0,1,"enable small number variables elimination");
+OPT(smallvevars,FUNVAR,4,FUNVAR, "variables small variable elimination");
+OPT(smallvewait,0,0,1,"wait with small variable elimination");
+OPT(sortlits,0,0,1,"sort lits of cls during garbage collection");
+OPT(stabema,7,0,32,"e for stability EMA with alpha=2^-e");
+OPT(subl,0,0,10*K,"try to subsume this many recent learned clauses");
+OPT(sweep,1,0,1,"enabled SAT sweeping");
+OPT(sweepboost,10,1,1000,"sweeping boost");
+OPT(sweepboostdel,4,0,100,"initial sweeping boost delay");
+OPT(sweepboostint,7,1,I,"sweeping boost interval");
+OPT(sweepboostvlim,1*M,1,I,"sweeping boost var lim");
+OPT(sweepfacdec,10,1,100,"decisions limit factor");
+OPT(sweepforgive,2,0,I,"forgive that many unsucessful rounds");
+OPT(sweepirr,3,0,3,"irredundant clauses (1=bin,2=trn,3=lrg)");
+OPT(sweepmaxdec,10*K,0,I,"maximum decisions in one sweep implies check");
+OPT(sweepmaxeff,200*M,-1,I,"max effort in sweeping");
+OPT(sweepmaxround,3,-1,I,"maximum rounds in sweeping");
+OPT(sweepmindec,100,0,I,"mininum decisions in one sweep implies check");
+OPT(sweepmineff,M,0,I,"min effort in sweeping");
+OPT(sweepred,3,0,3,"include redundant clauses (1=bin,2=trn,3=lrg)");
+OPT(sweepreleff,3,0,10*K,"rel effort in sweeping");
+OPT(sweeprtc,0,0,1,"run sweeping until completion");
+OPT(sweeprtcint,14,1,I,"run sweeping until completion interval");
+OPT(sweeprtcintvlim,100*K,1,I,"run sweeping until completion int var lim");
+OPT(sweepsuccessmaxwortc,6,1,I,"sweeping success max wo run-to-completion");
+OPT(sweepsuccessrat,1000,1,I,"sweeping success ratio");
+OPT(sweepwait,2,0,2,"wait for BCE (1) and/or BVE (2)");
+OPT(synclsall,1,0,1,"always synchronize all unconsumed clauses");
+OPT(synclsglue,8,0,I,"clause synchronization glue limit");
+OPT(synclsint,100,0,1000,"clause synchronization confs interval");
+OPT(synclslen,40,0,I,"clause synchronization length limit");
+OPT(syncunint,111111,0,M,"unit synchronization steps interval");
+OPT(termint,122222,0,M,"termination check interval");
+OPT(ternres,1,0,1,"generate ternary resolvents");
+OPT(ternresboost,5,1,100,"initial ternary resolution boost");
+OPT(ternresrtc,0,0,1,"run ternary resolvents until completion");
+OPT(ternreswait,2,0,2,"wait for BCE (1) and/or BVE (2)");
+OPT(tlevelema,12,0,32,"e for EMA with alpha=2^-e");
+OPT(transred,1,0,1,"enable transitive reduction");
+OPT(transredwait,2,0,2,"wait for BCE (1) and/or BVE (2)");
+OPT(trapiflush,0,0,1,"flush API trace after each call");
+OPT(trdmaxeff,2*M,-1,I,"max effort in transitive reduction");
+OPT(trdmineff,100*K,0,I,"min effort in transitive reduction");
+OPT(trdreleff,10,0,10*K,"rel effort in transitive reduction");
+OPT(treelook,1,0,2,"enable tree-based look-ahead (2=scheduleprobing)");
+OPT(treelookboost,10,1,100000,"tree-based look-head boost factor");
+OPT(treelookfull,0,0,1,"do not limit tree-based look-head");
+OPT(treelookmaxeff,50*M,-1,I,"max effort in tree-look based probing");
+OPT(treelookmineff,300*K,0,I,"min effort in tree-look based probing");
+OPT(treelookreleff,2,0,10*K,"rel effort in tree-look based probing");
+OPT(treelookrtc,0,0,1,"run tree-based look-ahead until completion");
+OPT(trep,0,0,1,"enable time based interval reporting");
+OPT(trepint,55555,1,I,"interval for time based reporting");
+OPT(trnreleff,10,0,K,"rel effort in ternary resolutions");
+OPT(trnrmaxeff,200*M,-1,I,"max effort in ternary resolutions");
+OPT(trnrmineff,4*M,0,I,"min effort in ternary resolutions");
+OPT(unhdatrn,2,0,2,"unhide redundant ternary clauses (1=move,2=force)");
+OPT(unhdextstamp,1,0,1,"used extended stamping features");
+OPT(unhdhbr,0,0,1,"enable unhiding hyper binary resolution");
+OPT(unhdlnpr,3,0,I,"unhide no progress round limit");
+OPT(unhdmaxeff,20*M,-1,I,"max effort in unhiding");
+OPT(unhdmineff,100*K,0,I,"min effort in unhiding");
+OPT(unhdreleff,2,0,10*K,"rel effort in unhiding");
+OPT(unhdroundlim,20,0,100,"unhide round limit");
+OPT(unhide,1,0,1,"enable unhiding");
+OPT(unhidewait,0,0,2,"wait for BCE (1) and/or BVE (2)");
+OPT(usedtwice,1,0,1,"used twice optimization for clause minimization");
+OPT(verbose,0,-1,5,"verbosity level");
+OPT(wait,1,0,1,"enable or disable all waiting");
+OPT(waitmax,4,-1,I,"max simps to wait (-1=nomax)");
+OPT(witness,1,0,1,"print witness");
diff --git a/lglopts.c b/lglopts.c
new file mode 100644
index 0000000..9b205cc
--- /dev/null
+++ b/lglopts.c
@@ -0,0 +1,30 @@
+#include "lglopts.h"
+
+#include <stdlib.h>
+#include <limits.h>
+#include <assert.h>
+
+void lglgetenv (struct LGL * lgl, Opt * opt, const char * lname);
+
+void lglinitopts (struct LGL * lgl, Opts * opts) {
+  const int K = 1000, M = K*K, I = INT_MAX;
+  const int MG = MAXGLUE;
+#ifdef OPT
+#undef OPT
+#endif
+#define OPT(LNG,VAL,MIN,MAX,DESCRP) \
+do { \
+  Opt * opt = &opts->LNG; \
+  opt->lng = #LNG; \
+  opt->dflt = opt->val = VAL; \
+  assert (MIN <= VAL); \
+  opt->min = MIN; \
+  assert (VAL <= MAX); \
+  opt->max = MAX; \
+  opt->descrp = DESCRP; \
+  lglgetenv (lgl, opt, #LNG); \
+} while (0)
+
+#include "lgloptl.h"
+}
+
diff --git a/lglopts.h b/lglopts.h
new file mode 100644
index 0000000..7e98878
--- /dev/null
+++ b/lglopts.h
@@ -0,0 +1,39 @@
+#ifndef lglopts_h_INCLUDED
+#define lglopts_h_INCLUDED
+
+#include "lglconst.h"
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Opt {
+  const char * lng, * descrp;
+  int val, min, max, dflt;
+} Opt;
+
+/*------------------------------------------------------------------------*/
+
+#ifdef OPT
+#undef OPT
+#endif
+#define OPT(LNG,VAL,MIN,MAX,DESCRP) Opt LNG
+
+typedef struct Opts {
+  Opt beforefirst;
+#include "lgloptl.h"
+  Opt afterlast;
+} Opts;
+
+struct LGL;
+
+/*------------------------------------------------------------------------*/
+
+#define FIRSTOPT(lgl) (&(lgl)->opts->beforefirst + 1)
+#define LASTOPT(lgl) (&(lgl)->opts->afterlast - 1)
+
+/*------------------------------------------------------------------------*/
+
+void lglinitopts (struct LGL *, Opts *);
+
+/*------------------------------------------------------------------------*/
+
+#endif
diff --git a/lgluntrace.c b/lgluntrace.c
new file mode 100644
index 0000000..b9d9220
--- /dev/null
+++ b/lgluntrace.c
@@ -0,0 +1,187 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <signal.h>
+
+#include "lglib.h"
+
+void lglchkclone (LGL *);
+
+static int verbose, exitonabort, lineno;
+static const char * name;
+
+static void die (const char * fmt, ...) {
+  va_list ap;
+  fputs ("*** lgluntrace: ", stderr);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  exit (1);
+}
+
+static void perr (const char * fmt, ...) {
+  va_list ap;
+  fprintf (stderr,
+           "*** lgluntrace: parse error in '%s' line %d: ", name, lineno);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  exit (1);
+}
+
+static void msg (const char * fmt, ...) {
+  va_list ap;
+  if (!verbose) return;
+  fputs ("c [lgluntrace] ", stdout);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+static int isnumstr (const char * str) {
+  const char * p;
+  int ch;
+  if (*(p = str) == '-') p++;
+  if (!isdigit ((int)*p++)) return 0;
+  while (isdigit (ch = *p)) p++;
+  return !ch;
+}
+
+static int intarg (char * op) {
+  const char * tok;
+  if (!(tok = strtok (0, " ")) || !isnumstr (tok) || strtok (0, " ")) {
+    perr ("expected integer argument for '%s'", op);
+    exit (1);
+  }
+  return atoi (tok);
+}
+
+static int noarg (const char * str, char * op) {
+  if (strcmp (str, op)) return 0;
+  if (strtok (0, " ")) perr ("argument after '%s'", op);
+  return 1;
+}
+
+static void exitonsig (int sig) { 
+  msg ("exit(%d) on signal %d", sig, sig);
+  exit (sig); 
+}
+
+int main (int argc, char ** argv) {
+  int i, len, ch, close = 0, res, arg;
+  char buffer[80], * tok, * opt;
+  FILE * file;
+  char * cmd;
+  LGL * lgl;
+  for (i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h")) {
+      printf ("usage: lgluntrace [-h][-v][-e][<trace>[.gz]]\n");
+      exit (0);
+    } else if (!strcmp (argv[i], "-v")) verbose = 1;
+    else if (!strcmp (argv[i], "-e")) exitonabort = 1;
+    else if (argv[i][0] == '-')
+      die ("invalid command line option '%s' (try '-h')", argv[i]);
+    else if (name)
+      die ("two traces '%s' and '%s' specified (try '-h')", name, argv[i]);
+    else name = argv[i];
+  }
+  if(name) {
+    len = strlen (name);
+    if (len >= 3 && !strcmp (name + len - 3, ".gz")) {
+      cmd = malloc (len + 20);
+      sprintf (cmd, "gunzip -c %s", name);
+      file = popen (cmd, "r");
+      free (cmd);
+      if (file) close = 2;
+    } else {
+      file = fopen (name, "r");
+      if (file) close = 1;
+    }
+    if (!file) die ("can not read '%s'", name);
+  } else name = "<stdin>", file = stdin;
+  if (exitonabort) {
+    msg ("setting signal handlers since '-e' specified");
+    signal (SIGINT, exitonsig);
+    signal (SIGSEGV, exitonsig);
+    signal (SIGABRT, exitonsig);
+    signal (SIGTERM, exitonsig);
+  }
+  msg ("reading %s", name);
+  buffer[len = 0] = 0;
+  lineno = 1;
+  res = 0;
+  lgl = 0;
+NEXT:
+  ch = getc (file);
+  if (ch == EOF) goto DONE;
+  if (ch == '\r') goto NEXT;
+  if (ch != '\n') {
+    if (len + 1 >= sizeof (buffer)) perr ("line buffer exceeded");
+    buffer[len++] = ch;
+    buffer[len] = 0;
+    goto NEXT;
+  }
+  msg ("line %d : %s", lineno, buffer);
+  if (!(tok = strtok (buffer, " "))) perr ("empty line");
+  else if (!strcmp (tok, "add")) lgladd (lgl, intarg ("add"));
+  else if (!strcmp (tok, "return")) {
+    arg = intarg ("return");
+    if (arg != res) 
+      die ("expected return value %d but got %d", arg, res);
+  } else if (!strcmp (tok, "deref")) res = lglderef (lgl, intarg ("deref"));
+  else if (!strcmp (tok, "failed")) res = lglfailed (lgl, intarg ("failed"));
+  else if (!strcmp (tok, "fixed")) res = lglfixed (lgl, intarg ("fixed"));
+  else if (!strcmp (tok, "repr")) res = lglrepr (lgl, intarg ("repr"));
+  else if (noarg (tok, "incvar")) res = lglincvar (lgl);
+  else if (noarg (tok, "maxvar")) res = lglmaxvar (lgl);
+  else if (noarg (tok, "changed")) res = lglchanged (lgl);
+  else if (noarg (tok, "inconsistent")) res = lglinconsistent (lgl);
+  else if (noarg (tok, "lkhd")) res = lglookahead (lgl);
+  else if (noarg (tok, "fixate")) lglfixate (lgl);
+  else if (noarg (tok, "reduce")) lglreducecache (lgl);
+  else if (noarg (tok, "flush")) lglflushcache (lgl);
+  else if (noarg (tok, "chkclone")) lglchkclone (lgl);
+  else if (!strcmp (tok, "assume")) lglassume (lgl, intarg ("assume"));
+  else if (noarg (tok, "init")) lgl = lglinit ();
+  else if (noarg (tok, "sat")) res = lglsat (lgl);
+  else if (!strcmp (tok, "simp")) res = lglsimp (lgl, intarg ("simp"));
+  else if (noarg (tok, "stats")) lglstats (lgl);
+  else if (!strcmp (tok, "freeze")) lglfreeze (lgl, intarg ("freeze"));
+  else if (!strcmp (tok, "melt")) lglmelt (lgl, intarg ("melt"));
+  else if (!strcmp (tok, "reuse")) lglreuse (lgl, intarg ("reuse"));
+  else if (!strcmp (tok, "frozen")) res = lglfrozen (lgl, intarg ("frozen"));
+  else if (!strcmp (tok, "usable")) res = lglusable (lgl, intarg ("usable"));
+  else if (!strcmp (tok, "reusable"))
+    res = lglreusable (lgl, intarg ("reusable"));
+  else if (!strcmp (tok, "setimportant"))
+    lglsetimportant (lgl, intarg ("setimportant"));
+  else if (noarg (tok, "setphases")) lglsetphases (lgl);
+  else if (!strcmp (tok, "setphase")) lglsetphase (lgl, intarg ("setphase"));
+  else if (!strcmp (tok, "resetphase"))
+    lglresetphase (lgl, intarg ("resetphase"));
+  else if (!strcmp (tok, "option")) {
+    if (!(opt = strtok (0, " "))) perr ("option name missing");
+    lglsetopt (lgl, opt, intarg ("option"));
+  } else if (noarg (tok, "release")) lglrelease (lgl);
+  else perr ("invalid command '%s'", tok);
+  lineno++;
+  len = 0;
+  goto NEXT;
+DONE:
+  if(close == 1) fclose (file);
+  if(close == 2) pclose (file);
+  msg ("done %s", name);
+  return 0;
+}
diff --git a/makefile.in b/makefile.in
new file mode 100644
index 0000000..4914087
--- /dev/null
+++ b/makefile.in
@@ -0,0 +1,89 @@
+MAKEFLAGS=-j $(if $(CORES),$(CORES),1)
+
+CC=@CC@
+CFLAGS=@CFLAGS@
+
+LIBS=@LIBS@
+LDEPS=@LDEPS@
+HDEPS=@HDEPS@
+EXTRAOBJS=@EXTRAOBJS@
+AIGER=@AIGER@
+
+all: targets
+
+-include makefile.mus
+-include makefile.other
+
+targets: liblgl.a
+targets: lingeling plingeling ilingeling treengeling
+targets: lglmbt lgluntrace lglddtrace
+targets: @AIGERTARGETS@
+
+analyze:
+	clang --analyze $(CFLAGS) $(shell ls *.c *.h)
+
+liblgl.a: lglib.o lglbnr.o lgldimacs.o lglopts.o makefile $(EXTRAOBJS)
+	ar rc $@ lglib.o lglbnr.o lgldimacs.o lglopts.o $(EXTRAOBJS)
+	ranlib $@
+
+lingeling: lglmain.o liblgl.a makefile $(LDEPS)
+	$(CC) $(CFLAGS) -o $@ lglmain.o -L. -llgl $(LIBS)
+plingeling: plingeling.o liblgl.a makefile $(LDEPS)
+	$(CC) $(CFLAGS) -pthread -o $@ plingeling.o -L. -llgl $(LIBS)
+treengeling: treengeling.o liblgl.a makefile $(LDEPS)
+	$(CC) $(CFLAGS) -pthread -o $@ treengeling.o -L. -llgl $(LIBS)
+blimc: blimc.o liblgl.a makefile $(AIGER)/aiger.o $(LDEPS)
+	$(CC) $(CFLAGS) -o $@ blimc.o -L. $(AIGER)/aiger.o -llgl $(LIBS)
+ilingeling: ilingeling.o liblgl.a makefile $(LDEPS)
+	$(CC) $(CFLAGS) -pthread -o $@ ilingeling.o -L. -llgl $(LIBS)
+lglmbt: lglmbt.o liblgl.a $(LDEPS)
+	$(CC) $(CFLAGS) -o $@ lglmbt.o -L. -llgl $(LIBS)
+lgluntrace: lgluntrace.o liblgl.a makefile $(LDEPS)
+	$(CC) $(CFLAGS) -o $@ lgluntrace.o -L. -llgl $(LIBS)
+lglddtrace: lglddtrace.o liblgl.a makefile $(LDEPS)
+	$(CC) $(CFLAGS) -o $@ lglddtrace.o -L. -llgl $(LIBS)
+
+lglmain.o: lglmain.c lglib.h makefile
+	$(CC) $(CFLAGS) -c lglmain.c
+plingeling.o: plingeling.c lglib.h makefile
+	$(CC) $(CFLAGS) -c plingeling.c
+treengeling.o: treengeling.c lglib.h makefile
+	$(CC) $(CFLAGS) -c treengeling.c
+ilingeling.o: ilingeling.c lglib.h makefile
+	$(CC) $(CFLAGS) -c ilingeling.c
+blimc.o: blimc.c lglib.h $(AIGER)/aiger.h makefile
+	$(CC) $(CFLAGS) -I$(AIGER) -c -o $@ blimc.c
+lglmbt.o: lglmbt.c lglib.h makefile
+	$(CC) $(CFLAGS) -c lglmbt.c
+lgluntrace.o: lgluntrace.c lglib.h makefile
+	$(CC) $(CFLAGS) -c lgluntrace.c
+lglddtrace.o: lglddtrace.c lglib.h makefile
+	$(CC) $(CFLAGS) -c lglddtrace.c
+
+lglib.o: lglib.c lglib.h lglconst.h lgloptl.h lglopts.h makefile $(HDEPS)
+	$(CC) $(CFLAGS) -c lglib.c
+lgldimacs.o: lgldimacs.c lgldimacs.h makefile
+	$(CC) $(CFLAGS) -c lgldimacs.c
+lglbnr.o: lglbnr.c lglcfg.h lglcflags.h makefile
+	$(CC) $(CFLAGS) -c lglbnr.c
+lglopts.o: lglopts.c lglopts.h lglconst.h lgloptl.h makefile
+	$(CC) $(CFLAGS) -c lglopts.c
+
+lglcfg.h: VERSION mkconfig.sh lglbnr.c lglib.c lglmain.c lglcflags.h makefile
+	rm -f $@
+	./mkconfig.sh > $@
+lglcflags.h: makefile
+	rm -f $@
+	echo '#define LGL_CC "$(shell $(CC) --version|head -1)"' >> $@
+	echo '#define LGL_CFLAGS "$(CFLAGS)"' >> $@
+
+clean: clean-all clean-config
+clean-config:
+	rm -f makefile lglcfg.h lglcflags.h
+clean-all:
+	rm -f lingeling plingeling ilingeling treengeling blimc
+	rm -f lglmbt lgluntrace lglddtrace
+	rm -f *.gcno *.gcda cscope.out gmon.out *.gcov *.gch *.plist
+	rm -f *.E *.o *.s *.a log/*.log 
+
+.PHONY: all targets clean clean-config clean-all
diff --git a/mkconfig.sh b/mkconfig.sh
new file mode 100755
index 0000000..7d6f1bb
--- /dev/null
+++ b/mkconfig.sh
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+LC_TIME="en_US"
+export LC_TIME
+
+die () {
+   echo "*** mkconfig.sh: $*" 1>&2
+   exit 1
+}
+
+[ -f makefile ] || die "can not find 'makefile'"
+
+cat<<EOF
+/*************************************************************/
+/* Automatically generated by './mkconfig.sh': do note edit! */
+/*************************************************************/
+EOF
+
+echo "#define LGL_OS \"`uname -srmn`\""
+echo "#define LGL_COMPILED \"`date`\""
+cat<<EOF
+#define LGL_RELEASED "Thu May 17 11:57:41 CEST 2018"
+#define LGL_VERSION "bcj"
+#define LGL_ID "78ebb8672540bde0a335aea946bbf32515157d5a"
+EOF
diff --git a/plingeling.c b/plingeling.c
new file mode 100644
index 0000000..98519ee
--- /dev/null
+++ b/plingeling.c
@@ -0,0 +1,1364 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include "lglib.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <limits.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <stdarg.h>
+#include <signal.h>
+#include <unistd.h>
+#include <math.h>
+
+/*------------------------------------------------------------------------*/
+
+#define NWORKERS 8
+#define MAXGB 12
+#define NUNITS (1<<9)
+
+/*------------------------------------------------------------------------*/
+#if 0
+static int memdbgcnt;
+#define LOGMEM(TYPE,PTR,BYTES) \
+do { \
+  fprintf (stderr, "%ld %10d " #TYPE " %ld\n", \
+    (long) PTR, memdbgcnt++, (long) BYTES); \
+  fflush (stderr); \
+} while (0)
+#else
+#define LOGMEM(...) do { } while (0)
+#endif
+/*------------------------------------------------------------------------*/
+
+#define NEW(PTR,NUM) \
+do { \
+  size_t BYTES = (NUM) * sizeof *(PTR); \
+  if (!((PTR) = malloc (BYTES))) { die ("out of memory"); exit (1); } \
+  LOGMEM (a, (PTR), BYTES); \
+  memset ((PTR), 0, BYTES); \
+  incmem (BYTES); \
+} while (0)
+
+#define DEL(PTR,NUM) \
+do { \
+  size_t BYTES = (NUM) * sizeof *(PTR); \
+  LOGMEM (d, (PTR), BYTES); \
+  decmem (BYTES); \
+  free (PTR); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Cls { int wid, count, glue, lits[1]; } Cls;
+
+typedef struct Worker {
+  LGL * lgl;
+  pthread_t thread;
+  int res, fixed;
+  int units[NUNITS], nunits;
+  int * cls, szcls;
+  long clsimported;
+  Cls * dead;
+  struct {
+    struct { int calls, produced, consumed; } units;
+    struct { int produced, consumed; } cls, eqs;
+    int produced, consumed;
+  } stats;
+} Worker;
+
+/*------------------------------------------------------------------------*/
+
+static int verbose, plain, nounits, noeqs, nocls, gclim = 1, gclimset;
+#ifndef NLGLOG
+static int loglevel;
+#endif
+#ifndef NLGLYALSAT
+static int forcelocs;
+#endif
+
+/*------------------------------------------------------------------------*/
+
+static int nworkers, nconsumers, leavebehind, locs;
+static int64_t memlimit, softmemlimit;
+static Worker * workers;
+static int nvars, nclauses;
+static int * vals, * fixed, * repr;
+struct { Cls ** start; long first, num, added, collected, size; } clauses;
+static int nfixed, globalres, gcs;
+static const char * name;
+static int nworkers2;
+struct { size_t max, current;} mem;
+static int catchedsig;
+static double start;
+static FILE * file;
+
+struct { int units, cls, eqs; } syncs;
+static int done, termchks, units, eqs, flushed;
+static pthread_mutex_t donemutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t msgmutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t fixedmutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t reprmutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t memutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t clsmutex = PTHREAD_MUTEX_INITIALIZER;
+
+/*------------------------------------------------------------------------*/
+
+static double currentime (void) {
+  double res = 0;
+  struct timeval tv;
+  if (!gettimeofday (&tv, 0)) res = 1e-6 * tv.tv_usec, res += tv.tv_sec;
+  return res;
+}
+
+static double getime () { 
+  return currentime () - start; 
+}
+
+static void msg (int wid, int level, const char * fmt, ...) {
+  va_list ap;
+  if (verbose < level) return;
+  pthread_mutex_lock (&msgmutex);
+  fflush (stderr);
+  if (wid < 0) printf ("c - "); else printf ("c %d ", wid);
+  printf ("W %6.1f ", getime ());
+  va_start (ap, fmt);
+  vfprintf (stdout, fmt, ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  pthread_mutex_unlock (&msgmutex);
+}
+
+static void die (const char * fmt, ...) {
+  va_list ap;
+  fflush (stdout);
+  fputs ("c *** plingeling error: ", stderr);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  exit (1);
+}
+
+static void warn (const char * fmt, ...) {
+  va_list ap;
+  fflush (stdout);
+  fputs ("c *** plingeling warning: ", stderr);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+}
+
+/*------------------------------------------------------------------------*/
+
+static double percent (double a, double b) { return b ? (100 * a) / b : 0; }
+
+static void stats (void) {
+  double real, process, mpps, cps, mb;
+  int64_t decs, confs, props;
+  int i, unitcalls;
+  Worker * w;
+  unitcalls = decs = confs = 0;
+  props = 0;
+  mb = mem.max / (double)(1<<20);
+  for (i = 0; i < nworkers; i++) {
+    w = workers + i;
+    if (!w->lgl) continue;
+    decs += lglgetdecs (w->lgl);
+    confs += lglgetconfs (w->lgl);
+    props += lglgetprops (w->lgl);
+    mb += lglmaxmb (w->lgl);
+    unitcalls += w->stats.units.calls;
+  }
+  real = getime ();
+  process = lglprocesstime ();
+  cps = real > 0 ? confs / real : 0;
+  mpps = real > 0 ? (props/1e6) / real : 0;
+  printf ("c %d termination checks\n", termchks);
+  printf ("c\n");
+  printf ("c units: %d found, %d publications, %d syncs, %d flushed\n", 
+          units, unitcalls, syncs.units, flushed);
+  printf ("c clauses: %ld clauses added, %ld collected %.0f%%, %d gcs\n",
+    clauses.added,
+    clauses.collected, percent (clauses.collected, clauses.added),
+    gcs);
+  printf ("c equivalences: %d found, %d syncs\n", eqs, syncs.eqs);
+  printf ("c\n");
+  printf ("c %lld decisions, %lld conflicts, %.1f conflicts/sec\n", 
+          (long long)decs, (long long)confs, cps);
+  printf ("c %lld0 propagations, %.1f megaprops/sec\n",
+          (long long)props, mpps);
+  printf ("c %.1f process time, %.0f%% utilization\n",
+          process, real > 0 ? (100.0 * process) / real / nworkers : 0.0);
+  printf ("c\n");
+  printf ("c %.1f seconds, %.1f MB\n", real, mb);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void incmem (size_t bytes) {
+  if (pthread_mutex_lock (&memutex))
+    warn ("failed to lock 'mem' mutex in 'incmem'");
+  mem.current += bytes;
+  if (mem.current > mem.max) mem.max = mem.current;
+  if (pthread_mutex_unlock (&memutex))
+    warn ("failed to unlock 'mem' mutex in 'incmem'");
+}
+
+static void decmem (size_t bytes) {
+  if (pthread_mutex_lock (&memutex))
+    warn ("failed to lock 'mem' mutex in 'decmem'");
+  assert (mem.current >= bytes);
+  mem.current -= bytes;
+  if (pthread_mutex_unlock (&memutex))
+    warn ("failed to unlock 'mem' mutex in 'decmem'");
+}
+
+static void * alloc (void * dummy, size_t bytes) {
+  char * res;
+  NEW (res, bytes);
+  return res;
+}
+
+static void dealloc (void * dummy, void * void_ptr, size_t bytes) {
+  char * char_ptr = void_ptr;
+  LOGMEM (d, void_ptr, bytes);
+  DEL (char_ptr, bytes);
+}
+
+static void * resize (void * dummy, void * ptr, 
+                      size_t old_bytes, size_t new_bytes) {
+  void * res;
+  if (pthread_mutex_lock (&memutex))
+    warn ("failed to lock 'mem' mutex in 'resize'");
+  assert (mem.current >= old_bytes);
+  mem.current -= old_bytes;
+  mem.current += new_bytes;
+  if (mem.current > mem.max) mem.max = mem.current;
+  if (pthread_mutex_unlock (&memutex))
+    warn ("failed to unlock 'mem' mutex in 'resize'");
+  LOGMEM (d, ptr, old_bytes);
+  res = realloc (ptr, new_bytes);
+  LOGMEM (a, res, new_bytes);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void (*sig_int_handler)(int);
+static void (*sig_segv_handler)(int);
+static void (*sig_abrt_handler)(int);
+static void (*sig_term_handler)(int);
+
+static void resetsighandlers (void) {
+  (void) signal (SIGINT, sig_int_handler);
+  (void) signal (SIGSEGV, sig_segv_handler);
+  (void) signal (SIGABRT, sig_abrt_handler);
+  (void) signal (SIGTERM, sig_term_handler);
+}
+
+static void caughtsigmsg (int sig) {
+  if (!verbose) return;
+  printf ("c\nc CAUGHT SIGNAL %d\nc\n", sig);
+  fflush (stdout);
+}
+
+static void catchsig (int sig) {
+  if (!catchedsig) {
+    fputs ("c s UNKNOWN\n", stdout);
+    fflush (stdout);
+    catchedsig = 1;
+    caughtsigmsg (sig);
+    stats ();
+    caughtsigmsg (sig);
+  }
+  resetsighandlers ();
+  if (getenv ("LGLSLEEPONABORT")) {
+    const int sec = 1000;
+    fprintf (stderr,
+      "plingeling: plingeling.c:%d: "
+      "process %ld sleeping for %d seconds\n",
+      __LINE__, (long) getpid (), sec); fflush (stderr); sleep (sec);
+  }
+  if (!getenv ("LGLNABORT")) raise (sig); else exit (1);
+}
+
+static void setsighandlers (void) {
+  sig_int_handler = signal (SIGINT, catchsig);
+  // sig_segv_handler = signal (SIGSEGV, catchsig);
+  sig_abrt_handler = signal (SIGABRT, catchsig);
+  sig_term_handler = signal (SIGTERM, catchsig);
+}
+
+/*------------------------------------------------------------------------*/
+
+static const char * parse (void) {
+  int ch, lit, sign, minlen, maxlen, len, * occs;
+HEADER:
+  ch = getc (file);
+  if (ch == 'c') {
+    while ((ch = getc (file)) != '\n')
+      if (ch == EOF) return "EOF in comment";
+    goto HEADER;
+  }
+  if (ch != 'p') return "expected header or comment";
+  ungetc (ch, file);
+  if (fscanf (file, "p cnf %d %d", &nvars, &nclauses) != 2)
+    return "can not parse header";
+  msg (-1, 1, "p cnf %d %d", nvars, nclauses);
+  NEW (fixed, nvars + 1);
+  NEW (vals, nvars + 1);
+  NEW (occs, 2*nvars + 1);
+  occs += nvars;
+  if (!noeqs) NEW (repr, nvars + 1);
+  minlen = INT_MAX, maxlen = -1, len = 0;
+LIT:
+  ch = getc (file);
+  if (ch == 'c') {
+    while ((ch = getc (file)) != '\n')
+      if (ch == EOF) return "EOF in comment";
+    goto LIT;
+  }
+  if (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') goto LIT;
+  if (ch == EOF) {
+    double avg, std;
+    if (nclauses > 0) return "not enough clauses";
+    if (minlen == maxlen) msg (-1, 0, "uniform clause length %d", minlen);
+    else msg (-1, 0, "clause length between %d and %d", minlen, maxlen);
+    if (nvars > 0) {
+      avg = 0;
+      for (lit = -nvars; lit <= nvars; lit++)
+	if (lit) avg += occs[lit];
+      avg /= 2*nvars;
+      msg (-1, 0, "average literal occurrence %.2f", avg);
+      std = 0;
+      for (lit = -nvars; lit <= nvars; lit++) 
+        if (lit) {
+	  double diff = avg - (double) occs[lit];
+	  std += diff*diff;
+	}
+      std = sqrt (std / (2*nvars));
+      msg (-1, 0, "literal occurrence standard deviation %.2f", std);
+      if (avg > 0)
+	 msg (-1,  0,
+	   "relative literal occurrence standard deviation %.2f%%",
+	   100.0*std/avg);
+    } else avg = std = 0;
+    occs -= nvars;
+    DEL (occs, 2*nvars + 1);
+    if (avg > 5 && std/avg < 0.5) {
+      if (minlen == maxlen) {
+	locs = 2;
+	msg (-1, 0, "looks like a real uniform random instance");
+      } else {
+	locs = 1;
+	msg (-1, 0,
+	  "looks like random instance without uniform clause length");
+      }
+    } else {
+      locs = 0;
+      msg (-1, 0, "instance does not seem to be uniform random");
+    }
+    msg (-1, 1, "finished parsing in %.1f seconds", getime ());
+    return 0;
+  }
+  if (ch == '-') {
+    ch = getc (file);
+    sign = -1;
+  } else sign = 1;
+  if (!isdigit (ch)) return "expected digit";
+  if (!nclauses) return "too many clauses";
+  lit = ch - '0';
+  while (isdigit (ch = getc (file)))
+    lit = 10 * lit + (ch - '0');
+  if (lit < 0 || lit > nvars) return "invalid variable index";
+  lit *= sign;
+  lgladd (workers[0].lgl, lit);
+  if (!lit) {
+    nclauses--;
+    if (len > maxlen) maxlen = len;
+    if (len < minlen) minlen = len;
+    len = 0;
+  } else len++, occs[lit]++;
+  goto LIT;
+}
+
+static int isposnum (const char * str) {
+  int ch;
+  if (!(ch = *str++) || !isdigit (ch)) return 0;
+  while (isdigit (ch = *str++))
+    ;
+  return !ch;
+}
+
+static int term (void * voidptr) {
+  Worker * worker = voidptr;
+  int wid = worker - workers, res;
+  assert (0 <= wid && wid < nworkers);
+  msg (wid, 3, "checking early termination");
+  if (pthread_mutex_lock (&donemutex))
+    warn ("failed to lock 'done' mutex in termination check");
+  res = done;
+  termchks++;
+  if (pthread_mutex_unlock (&donemutex)) 
+    warn ("failed to unlock 'done' mutex in termination check");
+  msg (wid, 3, "early termination check %s", res ? "succeeded" : "failed");
+  return res;
+}
+
+static void flush (Worker * worker, int keep_locked) {
+  int wid = worker - workers;
+  int lit, idx, val, tmp, i;
+  assert (worker->nunits);
+  msg (wid, 2, "flushing %d units", worker->nunits);
+  if (pthread_mutex_lock (&fixedmutex))
+    warn ("failed to lock 'fixed' mutex in flush");
+  flushed++;
+  for (i = 0; i < worker->nunits; i++) {
+    lit = worker->units[i];
+    idx = abs (lit);
+    assert (1 <= idx && idx <= nvars);
+    assert (0 <= wid && wid < nworkers);
+    worker->stats.units.calls++;
+    val = (lit < 0) ? -1 : 1;
+    tmp = vals[idx];
+    if (!tmp) {
+      assert (nfixed < nvars);
+      fixed[nfixed++] = lit;
+      vals[idx] = val;
+      assert (!fixed[nfixed]);
+      worker->stats.units.produced++;
+      worker->stats.produced++;
+      units++;
+    } else if (tmp == -val) {
+      if (pthread_mutex_lock (&donemutex))
+	warn ("failed to lock 'done' mutex flushing unit");
+      if (!globalres) msg (wid, 1, "mismatched unit");
+      globalres = 20;
+      done = 1;
+      if (pthread_mutex_unlock (&donemutex)) 
+	warn ("failed to unlock 'done' mutex flushing unit");
+      break;
+    } else assert (tmp == val);
+  }
+  worker->nunits = 0;
+  if (keep_locked) return;
+  if (pthread_mutex_unlock (&fixedmutex)) 
+    warn ("failed to unlock 'fixed' mutex in flush");
+}
+
+static void produceunit (void * voidptr, int lit) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  assert (worker->nunits < NUNITS);
+  worker->units[worker->nunits++] = lit;
+  msg (wid, 3, "producing unit %d", lit);
+  if (worker->nunits == NUNITS) flush (worker, 0);
+}
+
+static void consumeunits (void * voidptr, int ** fromptr, int ** toptr) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  if (worker->nunits) flush (worker, 1);
+  else if (pthread_mutex_lock (&fixedmutex))
+    warn ("failed to lock 'fixed' mutex in consume");
+  msg (wid, 3, "starting unit synchronization");
+  syncs.units++;
+  *fromptr = fixed + worker->fixed;
+  *toptr = fixed + nfixed;
+  if (pthread_mutex_unlock (&fixedmutex))
+    warn ("failed to unlock 'fixed' in 'consumeunits'");
+}
+
+static void consumedunits (void * voidptr, int consumed) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  worker->stats.units.consumed += consumed;
+  worker->stats.consumed += consumed;
+  msg (wid, 3, "consuming %d units", consumed);
+}
+
+static void * resize (void*,void*,size_t,size_t);
+
+static size_t sizecls (int len) { return sizeof (Cls) + len * sizeof (int); }
+
+static int lencls (int * c) { int res = 0; while (*c++) res++; return res; }
+
+static void producecls (void * voidptr, int * c, int glue) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  int len, * q, lit;
+  const int * p;
+  size_t bytes;
+  Cls * cls;
+  len = lencls (c);
+  bytes = sizecls (len);
+  cls = malloc (bytes);
+  if (!cls) { die ("out of memory in 'producecls'"); exit (1); }
+  LOGMEM (a, cls, bytes);
+  incmem (bytes);
+  cls->wid = wid;
+  cls->glue = glue;
+  cls->count = 0;
+  p = c, q = cls->lits; 
+  while ((lit = *p++)) *q++ = lit;
+  *q++ = 0;
+  if (pthread_mutex_lock (&clsmutex))
+    warn ("failed to lock 'cls' mutex in 'producecls'");
+  msg (wid, 3, "producing glue %d length %d clause %ld",
+    glue, len, clauses.added);
+  if (clauses.num == clauses.size) {
+    int newsize = clauses.size ? 2*clauses.size : 1;
+    size_t old_bytes = clauses.size * sizeof *clauses.start;
+    size_t new_bytes = newsize * sizeof *clauses.start;
+    clauses.start = resize (0, clauses.start, old_bytes, new_bytes);
+    clauses.size = newsize;
+  }
+  clauses.start[clauses.num++] = cls;
+  clauses.added++;
+  if (pthread_mutex_unlock (&clsmutex))
+    warn ("failed to unlock 'cls' mutex in 'producecls'");
+  worker->stats.cls.produced++;
+  worker->stats.produced++;
+}
+
+static void deletecls (Cls * cls) {
+  int len = lencls (cls->lits);
+  size_t bytes = sizecls (len);
+  LOGMEM (d, cls, bytes);
+  decmem (bytes);
+  free (cls);
+}
+
+static void deleteallcls () {
+  Cls * c;
+  int i;
+  for (i = clauses.first; i < clauses.num; i++) {
+    c = clauses.start[i];
+    if (c) deletecls (c);
+  }
+  DEL (clauses.start, clauses.size);
+}
+
+static void gcls (void) {
+  long j, k, l;
+  Cls * c;
+  int i;
+  assert (0 <= clauses.first);
+  assert (clauses.first <= clauses.num);
+  gcs++;
+  msg (-1, 1, "garbage collecting clauses: first=%ld, num=%ld, SIZE=%ld",
+    clauses.first, clauses.num, clauses.size);
+  for (k = 0; k < clauses.first; k++) assert (!clauses.start[k]);
+  while (k < clauses.num) {
+    c = clauses.start[k];
+    if (c->count > gclim) break;
+    clauses.start[k++] = 0;
+    deletecls (c);
+  }
+  assert (clauses.first <= k);
+  for (i = 0; i < nworkers; i++) {
+    Worker * worker = workers + i;
+    if (k < worker->clsimported) worker->clsimported -= k;
+    else worker->clsimported = 0;
+  }
+  j = 0;
+  for (l = k; l < clauses.num; l++)
+    clauses.start[j++] = clauses.start[l];
+  clauses.collected += k;
+  clauses.first = 0;
+  clauses.num -= k;
+  assert (clauses.num >= 0);
+}
+
+static void consumecls (void * voidptr, int ** cptr, int * glueptr) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  int res, len, newsize;
+  Cls * cls;
+  if (pthread_mutex_lock (&clsmutex))
+    warn ("failed to lock 'cls' mutex in 'consumecls'");
+  assert (worker->clsimported <= clauses.num);
+RESTART:
+  if (worker->dead) deletecls (worker->dead), worker->dead = 0;
+  if (worker->clsimported == clauses.num) {
+    msg (wid, 3, "all %d clauses already consumed", clauses.num);
+    *cptr = 0;
+  } else {
+    res = worker->clsimported++;
+    cls = clauses.start[res];
+    if (!cls) goto RESTART;
+    cls->count++;
+    if (cls->count + leavebehind >= nconsumers) {
+      clauses.start[res] = 0;
+      assert (!worker->dead);
+      worker->dead = cls;
+      assert (clauses.first <= res);
+      clauses.first++;
+      if (clauses.num > 10000 &&
+	  clauses.first > clauses.num/(nconsumers + 1)) gcls ();
+    }
+    if (cls->wid == wid) goto RESTART;
+    len = lencls (cls->lits);
+    if (len + 1 >= worker->szcls) {
+      newsize = 2*(len + 1);
+      worker->cls = resize (0, worker->cls, 
+                            worker->szcls * sizeof (int),
+                            newsize * sizeof (int));
+      worker->szcls = newsize;
+    }
+    memcpy (worker->cls, cls->lits, (len+1) * sizeof (int));
+    *cptr = worker->cls;
+    *glueptr = cls->glue;
+    msg (wid, 3,
+      "consuming glue %d length %d clause %d",
+      *glueptr, len, res);
+  }
+  if (pthread_mutex_unlock (&clsmutex))
+    warn ("failed to unlock 'cls' mutex in 'consumecls'");
+}
+
+static void consumedcls (void * voidptr, int consumed) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  worker->stats.cls.consumed += consumed;
+  worker->stats.consumed += consumed;
+  msg (wid, 3, "consuming %d clause", consumed);
+}
+
+static int * lockrepr (void * voidptr) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  if (pthread_mutex_lock (&reprmutex))
+    warn ("failed to lock 'repr' mutex");
+  msg (wid, 3, "starting equivalences synchronization");
+  syncs.eqs++;
+  return repr;
+}
+
+static void unlockrepr (void * voidptr, int consumed, int produced) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  msg (wid, 3, 
+       "finished equivalences synchronization: %d consumed, %d produced",
+       consumed, produced);
+  worker->stats.eqs.consumed += consumed;
+  worker->stats.eqs.produced += produced;
+  worker->stats.consumed += consumed;
+  worker->stats.produced += produced;
+  eqs += produced;
+  assert (eqs < nvars);
+  if (pthread_mutex_unlock (&reprmutex))
+    warn ("failed to unlock 'repr' mutex");
+}
+
+static void msglock (void * voidptr) {
+  (void) voidptr;
+  pthread_mutex_lock (&msgmutex);
+}
+
+static void msgunlock (void * voidptr) {
+  (void) voidptr;
+  pthread_mutex_unlock (&msgmutex);
+}
+
+static void * work (void * voidptr) {
+  Worker * worker = voidptr;
+  int wid = worker - workers;
+  LGL * lgl = worker->lgl;
+  assert (0 <= wid && wid < nworkers);
+  msg (wid, 1, "running");
+  assert (workers <= worker && worker < workers + nworkers);
+  worker->res = lglsat (lgl);
+  msg (wid, 1, "result %d", worker->res);
+  if (!worker->res) return 0;
+  if (pthread_mutex_lock (&donemutex))
+    warn ("failed to lock 'done' mutex in worker");
+  done = 1;
+  if (pthread_mutex_unlock (&donemutex)) 
+    warn ("failed to unlock 'done' mutex in worker");
+  msg (wid, 2, "%d decisions, %d conflicts, %.0f props, %.1f MB",
+       lglgetdecs (lgl), lglgetconfs (lgl), lglgetprops (lgl), lglmb (lgl));
+  if (verbose >= 2) {
+    if (pthread_mutex_lock (&fixedmutex))
+      warn ("failed to lock 'fixed' in work");
+    msg (wid, 2, "consumed %d units %.0f%%, produced %d units %.0f%%",
+	 worker->stats.units.consumed, 
+	 percent (worker->stats.units.consumed, nfixed),
+	 worker->stats.units.produced, 
+	 percent (worker->stats.units.produced, nfixed));
+    if (pthread_mutex_unlock (&fixedmutex))
+      warn ("failed to unlock 'fixed' in work");
+  }
+  return worker;
+}
+
+static int64_t getsystemtotalmem (int explain) {
+  long long res;
+  FILE * p = popen ("grep MemTotal /proc/meminfo", "r");
+  if (p && fscanf (p, "MemTotal: %lld kB", &res) == 1) {
+    if (explain)
+      msg (-1, 0, "%lld KB total memory according to /proc/meminfo", res);
+    res <<= 10;
+  } else {
+    res = ((long long) MAXGB) << 30;;
+    if (explain) 
+      msg (-1, 0, "assuming compiled in memory size of %d GB", MAXGB);
+  }
+  if (p) pclose (p);
+  return (int64_t) res;
+}
+
+static int getsystemcores (int explain) {
+  int syscores, coreids, physids, procpuinfocores;
+  int usesyscores, useprocpuinfo, amd, intel, res;
+  FILE * p;
+
+  syscores = sysconf (_SC_NPROCESSORS_ONLN);
+  if (explain) {
+    if (syscores > 0)
+      msg (-1, 1, "'sysconf' reports %d processors online", syscores);
+    else
+      msg (-1, 1, "'sysconf' fails to determine number of online processors");
+  }
+
+  p = popen ("grep '^core id' /proc/cpuinfo 2>/dev/null|sort|uniq|wc -l", "r");
+  if (p) {
+    if (fscanf (p, "%d", &coreids) != 1) coreids = 0;
+    if (explain) {
+      if (coreids > 0) 
+	msg (-1, 1, "found %d unique core ids in '/proc/cpuinfo'", coreids);
+      else
+	msg (-1, 1, "failed to extract core ids from '/proc/cpuinfo'");
+    }
+    pclose (p);
+  } else coreids = 0;
+
+  p = popen (
+        "grep '^physical id' /proc/cpuinfo 2>/dev/null|sort|uniq|wc -l", "r");
+  if (p) {
+    if (fscanf (p, "%d", &physids) != 1) physids = 0;
+    if (explain) {
+      if (physids > 0) 
+	msg (-1, 1, "found %d unique physical ids in '/proc/cpuinfo'", 
+            physids);
+      else
+	msg (-1, 1, "failed to extract physical ids from '/proc/cpuinfo'");
+    }
+    pclose (p);
+  } else physids = 0;
+
+  if (coreids > 0 && physids > 0 && 
+      (procpuinfocores = coreids * physids) > 0) {
+    if (explain)
+      msg (-1, 1, 
+           "%d cores = %d core times %d physical ids in '/proc/cpuinfo'",
+           procpuinfocores, coreids, physids);
+  } else procpuinfocores = 0;
+
+  usesyscores = useprocpuinfo = 0;
+
+  if (procpuinfocores > 0 && procpuinfocores == syscores) {
+    if (explain) msg (-1, 1, "'sysconf' and '/proc/cpuinfo' results match");
+    usesyscores = 1;
+  } else if (procpuinfocores > 0 && syscores <= 0) {
+    if (explain) msg (-1, 1, "only '/proc/cpuinfo' result valid");
+    useprocpuinfo = 1;
+  } else if (procpuinfocores <= 0 && syscores > 0) {
+    if (explain) msg (-1, 1, "only 'sysconf' result valid");
+    usesyscores = 1;
+  } else {
+    intel = !system ("grep vendor /proc/cpuinfo 2>/dev/null|grep -q Intel");
+    if (intel && explain) 
+      msg (-1, 1, "found Intel as vendor in '/proc/cpuinfo'");
+    amd = !system ("grep vendor /proc/cpuinfo 2>/dev/null|grep -q AMD");
+    if (amd && explain) 
+      msg (-1, 1, "found AMD as vendor in '/proc/cpuinfo'");
+    assert (syscores > 0);
+    assert (procpuinfocores > 0);
+    assert (syscores != procpuinfocores);
+    if (amd) {
+      if (explain) msg (-1, 1, "trusting 'sysconf' on AMD");
+      usesyscores = 1;
+    } else if (intel) {
+      if (explain) {
+	msg (-1, 1, 
+	     "'sysconf' result off by a factor of %f on Intel", 
+	     syscores / (double) procpuinfocores);
+	msg (-1, 1, "trusting '/proc/cpuinfo' on Intel");
+      }
+      useprocpuinfo = 1;
+    }  else {
+      if (explain)
+	msg (-1, 1, "trusting 'sysconf' on unknown vendor machine");
+      usesyscores = 1;
+    }
+  } 
+  
+  if (useprocpuinfo) {
+    if (explain) 
+      msg (-1, 0, 
+        "assuming cores = core * physical ids in '/proc/cpuinfo' = %d",
+        procpuinfocores);
+    res = procpuinfocores;
+  } else if (usesyscores) {
+    if (explain) 
+      msg (-1, 0,
+           "assuming cores = number of processors reported by 'sysconf' = %d",
+           syscores);
+    res = syscores;
+  } else {
+    if (explain) 
+      msg (-1, 0, "using compiled in default value of %d workers", NWORKERS);
+    res = NWORKERS;
+  }
+
+  return res;
+}
+
+static int cmproduced (const void * p, const void * q) {
+  Worker * u = *(Worker**) p;
+  Worker * v = *(Worker**) q;
+  int res = v->stats.produced - u->stats.produced;
+  if (res) return res;
+  return u - v;
+}
+
+static int cmpconsumed (const void * p, const void * q) {
+  Worker * u = *(Worker**) p;
+  Worker * v = *(Worker**) q;
+  int res = v->stats.consumed - u->stats.consumed;
+  if (res) return res;
+  return u - v;
+}
+
+static int parsenbcoreenv (void) {
+  const char * str = getenv ("NBCORE");
+  if (!str) return 0;
+  if (!isposnum (str)) 
+    die ("invalid value '%s' for environment variable NBCORE", str);
+  return atoi (str);
+}
+
+static void setopt (int i, LGL * lgl, const char * opt, int val) {
+  int oldval, newval;
+  if (!lglhasopt (lgl, opt))
+    msg (i, 1, "option '%s' does not exist", opt);
+  else if ((oldval = lglgetopt (lgl, opt)) == val)
+    msg (i, 1, "option '%s' already set to '%d'", opt, val);
+  else {
+   lglsetopt (lgl, opt, val);
+   newval = lglgetopt (lgl, opt);
+   if (newval != val)
+     msg (i, 1, "option '%s' set to '%d' (but requested %d)",
+       opt, newval, val);
+   else
+     msg (i, 1, "option '%s' set to '%d'", opt, val);
+  }
+}
+
+static void setopts (LGL * lgl, int i) {
+  Worker * w = workers + i;
+  int j;
+  w->lgl = lgl;
+  lglsetid (lgl, i, nworkers);
+  lglsetime (lgl, getime);
+  setopt (i, lgl, "verbose", verbose);
+#ifndef NLGLOG
+  if (!verbose)
+  setopt (i, lgl, "log", loglevel);
+#endif
+  setopt (i, lgl, "seed", i);
+  setopt (i, lgl, "classify", 0);
+
+  if (i && (locs >= 2 || (locs && (i > 7 || (i & 1))))) {
+    setopt (i, lgl, "plain", locs == 2 || (i & 3) == 1);
+    setopt (i, lgl, "locs", -1);
+    setopt (i, lgl, "locsrtc", 1);
+    setopt (i, lgl, "locswait", 0);
+    setopt (i, lgl, "locsclim", (1<<24));
+  } else {
+    j = locs ? i/2 : i;
+    switch (j % 13) {
+      case  0: default: break;
+      case  1: setopt (i, lgl, "plain", 1),
+               setopt (i, lgl, "decompose", 1); break;
+      case  2: setopt (i, lgl, "restartint", 1000); break;
+      case  3: setopt (i, lgl, "elmresched", 7); break;
+      case  4: setopt (i, lgl, "scincincmin", 250); break;
+      case  5: setopt (i, lgl, "block", 0),
+               setopt (i, lgl, "cce", 0); break;
+      case  6: setopt (i, lgl, "scincinc", 50); break;
+      case  7: setopt (i, lgl, "phase", -1); break;
+      case  8: setopt (i, lgl, "phase", 1); break;
+      case  9: setopt (i, lgl, "sweeprtc", 1); break;
+      case 10: setopt (i, lgl, "restartint", 100); break;
+      case 11: setopt (i, lgl, "reduceinit", 10000);
+               setopt (i, lgl, "reducefixed", 1); break;
+      case 12: setopt (i, lgl, "restartint", 4); break;
+    }
+  }
+  lglseterm (lgl, term, w);
+  lglsetmsglock (lgl, msglock, msgunlock, w);
+  if (!nounits) {
+    lglsetproduceunit (lgl, produceunit, w);
+    lglsetconsumeunits (lgl, consumeunits, w);
+    lglsetconsumedunits (lgl, consumedunits, w);
+  }
+  if (!nocls) {
+    lglsetproducecls (lgl, producecls, w);
+    lglsetconsumecls (lgl, consumecls, w);
+    lglsetconsumedcls (lgl, consumedcls, w);
+  }
+  if (!noeqs) {
+    lglsetlockeq (lgl, lockrepr, w);
+    lglsetunlockeq (lgl, unlockrepr, w);
+  }
+  msg (i, 2, "initialized");
+}
+
+static long long bytes2mbll (int64_t bytes) {
+  return (bytes + (1ll<<20) - 1) >> 20;
+}
+
+static long long bytes2gbll (int64_t bytes) {
+  return (bytes + (1ll<<30) - 1) >> 30;
+}
+
+static int cloneworker (int i) {
+  assert (0 < i && i < nworkers);
+  assert (!workers[i].lgl);
+  msg (-1, 0, "trying to clone worker %d from worker 0", i);
+  msg (-1, 0, 
+    "prediction: %lld MB to be cloned + allocated %lld MB = %lld MB",
+    bytes2mbll (lglbytes (workers[0].lgl)),
+    bytes2mbll (mem.current),
+    bytes2mbll (lglbytes (workers[0].lgl) + mem.current));
+
+  if (lglbytes (workers[0].lgl) + mem.current >= softmemlimit) {
+    msg (-1, 0,
+      "will not clone worker %d since soft memory limit %lld MB would be hit",
+     i, bytes2mbll (softmemlimit));
+    return 0;
+  }
+  workers[i].lgl = lglclone (workers[0].lgl);
+  setopts (workers[i].lgl, i);
+  msg (-1, 0,
+    "%lld MB total allocated memory after cloning worker %d from worker 0",
+    bytes2mbll (mem.current), i);
+  return 1;
+}
+
+int main (int argc, char ** argv) {
+  int i, res, clin, lit, val, id, nbcore, witness = 1, tobecloned, tobestarted;
+  Worker * w, * winner, *maxconsumer, * maxproducer, ** sorted, *earlyworker;
+  int sumconsumed, sumconsumedunits, sumconsumedcls, sumconsumedeqs;
+  const char * errstr, * arg;
+  size_t bytes;
+  char * cmd;
+  start = currentime ();
+  clin = 0;
+  for (i = 1; i < argc; i++) {
+    size_t totalmem = getsystemtotalmem (0);
+    if (!strcmp (argv[i], "-h")) {
+      printf (
+"usage: plingeling [ <option> ... ] [ <dimacs>[.gz|.bz2|.7z|.zip|.lzma] [<threads>] ]\n"
+"\n"
+"where <option> is one of the following:\n"
+"\n"
+"  -h         print this command line option summary\n"
+"  -v         increase verbose level\n"
+#ifndef NLGLOG
+"  -l         increase logging level\n"
+#endif
+"  -n         do not print solution / witness\n"
+#ifndef NLGLYALSAT
+"\n"
+"  --force-locs    force (mainy) local search\n"
+#endif
+"\n"
+"  -t <num>   number of worker threads (default %d on this machine)\n"
+"  -m <num>   maximal memory in MB (default %lld MB on this machine)\n"
+"  -g <num>   maximal memory in GB (default %lld GB on this machine)\n"
+"  -l <num>   limit on number of workers before collecting shared clause\n"
+"\n"
+"  -p         plain portfolio, no sharing, e.g. implies the following:\n"
+"\n"
+"                --do-not-share-units\n"
+"                --do-not-share-clauses\n"
+"                --do-not-share-equivalences\n",
+getsystemcores (0), bytes2mbll (totalmem), bytes2gbll (totalmem));
+      exit (0);
+    }
+    if (!strcmp (argv[i], "-v")) verbose++;
+#ifndef NLGLOG
+    else if (!strcmp (argv[i], "-l")) loglevel++;
+#endif
+    else if (!strcmp (argv[i], "-p")) plain = 1;
+    else if (!strcmp (argv[i], "-n")) witness = 0;
+#ifndef NLGLYALSAT
+    else if (!strcmp (argv[i], "--force-locs")) forcelocs++;
+#endif
+    else if (!strcmp (argv[i], "--do-not-share-units")) nounits = 1;
+    else if (!strcmp (argv[i], "--do-not-share-clauses")) nocls = 1;
+    else if (!strcmp (argv[i], "--do-not-share-equivalences")) noeqs = 1;
+    else if (!strcmp (argv[i], "-t")) {
+      if (nworkers) die ("multiple '-t' options");
+      if (nworkers2) die ("number of threads and '-t' option given");
+      if (i + 1 == argc) die ("argument to '-t' missing");
+      if (!isposnum (arg = argv[++i]) || (nworkers = atoi (arg)) <= 0)
+	die ("invalid argument '%s' to '-t'", arg);
+    } else if (!strcmp (argv[i], "-m")) {
+      if (memlimit) die ("multiple '-m' or '-g' options");
+      if (i + 1 == argc) die ("argument to '-m' missing");
+      if (!isposnum (arg = argv[++i]) || (memlimit = (atoll (arg)<<20)) <= 0)
+	die ("invalid argument '%s' to '-m'", arg);
+    } else if (!strcmp (argv[i], "-g")) {
+      if (memlimit) die ("multiple '-g' or '-m' options");
+      if (i + 1 == argc) die ("argument to '-g' missing");
+      if (!isposnum (arg = argv[++i]) || (memlimit = (atoll (arg)<<30)) <= 0)
+	die ("invalid argument '%s' to '-g'", arg);
+    } else if (!strcmp (argv[i], "-l")) {
+      if (gclimset) die ("multiple '-l' options");
+      if (i + 1 == argc) die ("argument to '-l' missing");
+      if (!isposnum (argv[++i]))
+	die ("invalid argument '%s' to '-l'", argv[i]);
+      gclim = atoi (argv[i]);
+      gclimset = 1;
+    } else if (argv[i][0] == '-') 
+      die ("invalid option '%s' (try '-h')", argv[i]);
+    else if (!name && isposnum (argv[i]))
+      die ("<dimacs> file name can not be a positive number '%s'", argv[i]);
+    else if (name && nworkers2)
+      die ("too many arguments (including <dimacs> and <threads>)");
+    else if (name && !isposnum (argv[i]))
+      die ("expected positive number of threads but got '%s'", argv[i]);
+    else if (name) {
+      if ((nworkers2 = atoi (argv[i])) <= 0)
+	die ("invalid number of threads '%s'", argv[i]);
+    } else name = argv[i];
+  }
+  if (nworkers2) assert (!nworkers), nworkers = nworkers2;
+  lglbnr ("Plingeling Parallel SAT Solver", "c ", stdout);
+  fflush (stdout);
+  if (verbose) printf ("c\n");
+  nbcore = parsenbcoreenv ();
+  if (nworkers) {
+    msg (-1, 1, 
+	 "command line option '-t %d' overwrites system default %d",
+	 nworkers, getsystemcores (0));
+    if (nbcore)
+      msg (-1, 1, 
+           "and also overwrites environment variable NBCORE=%d",
+	   nbcore);
+  } else if (nbcore) {
+    msg (-1, 1, 
+	 "environment variable NBCORE=%d overwrites system default %d",
+	 nbcore, getsystemcores (0));
+    nworkers = nbcore;
+  } else {
+    msg (-1, 1,
+      "no explicit specification of number of workers");
+      nworkers = getsystemcores (1);
+  }
+  msg (-1, 0, "USING %d WORKER THREADS", nworkers);
+  if (memlimit) {
+    msg (-1, 1,
+      "memory limit %lld MB ('-g %lld') overwrites system default %lld MB",
+      bytes2mbll (memlimit), bytes2gbll (memlimit),
+      bytes2mbll (getsystemtotalmem (0)));
+  } else {
+    memlimit = getsystemtotalmem (1);
+    msg (-1, 1, "memory limit set to system default of %lld MB total memory",
+         bytes2mbll (memlimit));
+  }
+  softmemlimit = (memlimit + 2)/3;
+  msg (-1, 0, "soft memory limit set to %lld MB", bytes2mbll (softmemlimit));
+  if (gclimset)
+    msg (-1, 0, "garbage collection limit %d ('-l %d')", gclim, gclim);
+  else msg (-1, 0, "default garbage collection limit %d", gclim);
+  if (plain) {
+    nounits = nocls = noeqs = 1;
+    msg (-1, 0, "not sharing anything in plain portolio mode ('-p')");
+  } else {
+    if (noeqs) msg (-1, 0, "not sharing units ('--do-not-share-units')");
+    else msg (-1, 0, "sharing of units enabled");
+    if (nocls) msg (-1, 0, "not sharing clauses ('--do-not-share-clauses')");
+    else msg (-1, 0, "sharing of clauses enabled");
+    if (noeqs)
+      msg (-1, 0,
+        "not sharing equivalences ('--do-not-share-equivalences')");
+    else msg (-1, 0, "sharing of equivalences enabled");
+  }
+  NEW (workers, nworkers);
+  workers[0].lgl = lglminit (0, alloc, resize, dealloc);
+  lglsetopt (workers[0].lgl, "druplig", 0);
+  setopt (0, workers[0].lgl, "bca", 0);
+  if (!verbose) setopt (0, workers[0].lgl, "trep", 1);
+  if (!verbose) setopt (0, workers[0].lgl, "profile", 0);
+  if (verbose) lglopts (workers[0].lgl, "c 0 ", 0);
+  setsighandlers ();
+  if (name) { 
+    if (strlen (name) >= 3 && !strcmp (name + strlen(name) - 3, ".gz")) {
+      bytes = strlen (name) + 30;
+      cmd = alloc (0, bytes);
+      sprintf (cmd, "gunzip -c %s", name);
+      file = popen (cmd, "r");
+      dealloc (0, cmd, bytes);
+      clin = 4;
+    } else if (strlen (name) >= 4 &&
+               !strcmp (name + strlen(name) - 4, ".zip")) {
+      bytes = strlen (name) + 30;
+      cmd = alloc (0, bytes);
+      sprintf (cmd, "unzip -p %s", name);
+      file = popen (cmd, "r");
+      dealloc (0, cmd, bytes);
+      clin = 4;
+    } else if (strlen (name) >= 5 &&
+               !strcmp (name + strlen(name) - 5, ".lzma")) {
+      bytes = strlen (name) + 30;
+      cmd = alloc (0, bytes);
+      sprintf (cmd, "lzcat %s", name);
+      file = popen (cmd, "r");
+      dealloc (0, cmd, bytes);
+      clin = 4;
+    } else if (strlen (name) >= 4 &&
+               !strcmp (name + strlen(name) - 4, ".bz2")) {
+      bytes = strlen (name) + 30;
+      cmd = alloc (0, bytes);
+      sprintf (cmd, "bzcat %s", name);
+      file = popen (cmd, "r");
+      dealloc (0, cmd, bytes);
+      clin = 4;
+    } else if (strlen (name) >= 3 && 
+               !strcmp (name + strlen (name) - 3, ".7z")) {
+      bytes = strlen (name) + 40;
+      cmd = alloc (0, bytes);
+      sprintf (cmd, "7z x -so %s 2>/dev/null", name);
+      file = popen (cmd, "r");
+      dealloc (0, cmd, bytes);
+      clin = 4;
+    } else {
+      file = fopen (name, "r");
+      clin = 1;
+    }
+    if (!file) die ("can not read %s", name);
+  } else file = stdin, name = "<stdin>";
+  msg (-1, 0, "parsing %s", name);
+  errstr = parse ();
+  if (errstr) die ("parse error: %s", errstr);
+  if (clin == 1) fclose (file);
+  if (clin == 2) pclose (file);
+#ifdef NLGLYALSAT
+  locs = 0;
+#else
+  if (forcelocs) locs = forcelocs;
+#endif
+  setopts (workers[0].lgl, 0);
+  if (locs >= 2) nconsumers = 1;
+  else if (locs == 1) {
+    nconsumers = 1;
+    for (i = 1; i < nworkers; i++)
+      if (i < 8 && !(i & 1)) nconsumers++;
+  } else nconsumers = nworkers;
+  msg (-1, 1,
+    "assuming %d consumers out of %d workers",
+    nconsumers, nworkers);
+  leavebehind = nconsumers / 4;
+  msg (-1, 1,
+    "will leave behind %d consumers out of %d",
+    leavebehind, nconsumers);
+  earlyworker = (nworkers > 1 && cloneworker (1)) ? workers + 1 : 0;
+  if (earlyworker) {
+    assert (earlyworker->lgl);
+    if (pthread_create (&earlyworker->thread, 0, work, earlyworker))
+      die ("failed to create additional early worker thread 1");
+    msg (-1, 2, "started additional early worker 1");
+  }
+  if (!locs) {
+    msg (-1, 0, "simplifying original formula with worker 0");
+    lglsetopt (workers[0].lgl, "clim", 0);
+    (void) work (workers + 0);
+    lglsetopt (workers[0].lgl, "clim", -1);
+  }
+  res = workers[0].res;
+  if (res) {
+    msg (-1, 1,
+      "simplification of first worker 0 produced %d", res);
+    if (earlyworker) {
+      if (pthread_join (earlyworker->thread, 0))
+	die ("failed to join early worker thread 1");
+      msg (-1, 2, "joined early worker 1");
+    }
+  } else {
+    if ((tobecloned = (nworkers - 2 + !earlyworker)) > 0) {
+      msg (-1, 0, "trying to clone %d workers", tobecloned);
+      for (i = 1; i < nworkers; i++)
+	if (earlyworker != workers + i && !cloneworker (i))
+	  break;
+    }
+    tobestarted = 0;
+    for (i = 0; i < nworkers; i++)
+      if (workers + i != earlyworker)
+	tobestarted++;
+    assert (tobestarted > 0);
+    msg (-1, 2, "starting %d worker threads", tobestarted);
+    for (i = 0; i < nworkers; i++) {
+      w = workers + i;
+      if (w == earlyworker) continue;
+      if (!w->lgl) continue;
+      if (pthread_create (&w->thread, 0, work, w))
+	die ("failed to create worker thread %d", i);
+      msg (-1, 2, "started worker %d", i);
+    }
+    msg (-1, 2, "joining %d workers", tobestarted + 1 - !earlyworker);
+    for (i = 0; i < nworkers; i++) {
+      w = workers + i;
+      if (!w->lgl) continue;
+      if (pthread_join (w->thread, 0))
+	die ("failed to join worker thread %d", i);
+      msg (-1, 2, "joined worker %d", i);
+    }
+  }
+  maxproducer = maxconsumer = winner = 0;
+  for (i = 0; i < nworkers; i++) {
+    w = workers + i;
+    if (!w->lgl) continue;
+    if (w->res) {
+      if (!res) {
+	res = w->res;
+	winner = w;
+	msg (-1, 0, "worker %d is the WINNER with result %d", i, res);
+      } else if (res != w->res) die ("result discrepancy");
+    }
+    if (!maxconsumer || w->stats.consumed > maxconsumer->stats.consumed)
+      maxconsumer = w;
+    if (!maxproducer || w->stats.produced > maxproducer->stats.produced)
+      maxproducer = w;
+  }
+  NEW (sorted, nworkers);
+  for (i = 0; i < nworkers; i++) sorted[i] = workers + i;
+  printf ("c\n");
+  assert (maxproducer);
+  qsort (sorted, nworkers, sizeof *sorted, cmproduced);
+  for (i = 0; i < nworkers; i++) {
+    w = sorted[i];
+    if (!w->lgl) continue;
+    id = w - workers;
+    printf (
+      "c %2d %s %7d %3.0f%% = %7d units %3.0f%% + %7d cls %3.0f%% + %7d eqs %3.0f%%\n",
+       id, (w == maxproducer ? "PROD" : "prod"),
+       w->stats.produced,
+         percent (w->stats.produced, units + eqs + clauses.added),
+       w->stats.units.produced, percent (w->stats.units.produced, units),
+       w->stats.cls.produced, percent (w->stats.cls.produced, clauses.added),
+       w->stats.eqs.produced, percent (w->stats.eqs.produced, eqs));
+  }
+  fputs ("c ", stdout);
+  for (i = 0; i < 79; i++) fputc ('-', stdout);
+  fputc ('\n', stdout);
+  printf (
+    "c    prod %7lld 100%% = %7d units 100%% + %7lld cls 100%% + %7d eqs 100%%\n",
+    (long long) units + eqs + clauses.added, units, (long long) clauses.added, eqs);
+  printf ("c\n");
+  assert (maxconsumer);
+  qsort (sorted, nworkers, sizeof *sorted, cmpconsumed);
+  sumconsumed = sumconsumedunits = sumconsumedcls = sumconsumedeqs =0;
+  for (i = 0; i < nworkers; i++) {
+    w = sorted[i];
+    if (!w->lgl) continue;
+    id = w - workers;
+    sumconsumed += w->stats.consumed;
+    sumconsumedeqs += w->stats.eqs.consumed;
+    sumconsumedcls += w->stats.cls.consumed;
+    sumconsumedunits += w->stats.units.consumed;
+    printf (
+      "c %2d %s %7d %3.0f%% = %7d units %3.0f%% + %7d cls %3.0f%% + %7d eqs %3.0f%%\n",
+      id, (w == maxconsumer ? "CONS" : "cons"),
+      w->stats.consumed, percent (w->stats.consumed, units + eqs + clauses.added),
+      w->stats.units.consumed, percent (w->stats.units.consumed, units),
+      w->stats.cls.consumed, percent (w->stats.cls.consumed, clauses.added),
+      w->stats.eqs.consumed, percent (w->stats.eqs.consumed, eqs));
+  }
+  fputs ("c ", stdout);
+  for (i = 0; i < 79; i++) fputc ('-', stdout);
+  fputc ('\n', stdout);
+  printf (
+    "c    cons %7d %3.0f%% = %7d units %3.0f%% + %7d cls %3.0f%% + %7d eqs %3.0f%%\n",
+    sumconsumed,  percent (sumconsumed, units + eqs + clauses.added),
+    sumconsumedunits, percent (sumconsumedunits, units),
+    sumconsumedcls, percent (sumconsumedcls, clauses.added),
+    sumconsumedeqs, percent (sumconsumedeqs, eqs));
+  DEL (sorted, nworkers);
+  fflush (stdout);
+  if (!res) res = globalres;
+  if (!res) die ("no result by any worker");
+  assert (res);
+  msg (-1, 2, "copying assignment");
+  if (winner && res == 10) {
+    for (i = 1; i <= nvars; i++) {
+      val = lglderef (winner->lgl, i);
+      if (vals[i]) assert (val == vals[i]);
+      vals[i] = val;
+    }
+  }
+  resetsighandlers ();
+
+  if (res == 10) {
+    printf ("s SATISFIABLE\n");
+    if (witness) {
+      fflush (stdout);
+      if (nvars) {
+	printf ("v");
+	for (i = 1; i <= nvars; i++) {
+	  if (!(i & 7)) fputs ("\nv", stdout);
+	  lit = vals[i] < 0 ? -i : i;
+	  printf (" %d", lit);
+	}
+	printf ("\n");
+      }
+      printf ("v 0\n");
+    }
+  } else if (res == 20) {
+    printf ("s UNSATISFIABLE\n");
+  } else printf ("c s UNKNOWN\n");
+  fflush (stdout);
+
+  if (verbose) {
+    for (i = 0; i < nworkers; i++) {
+      if (!workers[i].lgl) continue;
+      printf ("c\nc ------------[worker %d statistics]------------ \nc\n", i);
+      lglstats (workers[i].lgl);
+    }
+    printf ("c\nc -------------[overall statistics]------------- \nc\n");
+  } else printf ("c\n");
+  stats ();
+
+  if (verbose >= 2) printf ("c\n");
+  msg (-1, 2, "releasing %d workers", nworkers);
+  for (i = 0; i < nworkers; i++) {
+    w = workers + i;
+    if (!w->lgl) continue;
+    lglrelease (w->lgl);
+    msg (-1, 2, "released worker %d", i);
+    if (w->dead) deletecls (w->dead), w->dead = 0;
+    DEL (w->cls, w->szcls);
+  }
+  DEL (workers, nworkers);
+  DEL (fixed, nvars + 1);
+  if (!noeqs) DEL (repr, nvars + 1);
+  DEL (vals, nvars + 1);
+  deleteallcls ();
+
+  assert (getenv ("PLINGELINGLEAK") || !mem.current);
+
+  return res;
+}
diff --git a/treengeling.c b/treengeling.c
new file mode 100644
index 0000000..c54a662
--- /dev/null
+++ b/treengeling.c
@@ -0,0 +1,2358 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2010-2018 Armin Biere Johannes Kepler University Linz Austria */
+/*-------------------------------------------------------------------------*/
+
+#include "lglib.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <limits.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+/*------------------------------------------------------------------------*/
+#if 0
+#define LOG(ARGS) do { printf ("c %s\n", ARGS); fflush (stdout); } while (0)
+#else
+#define LOG(ARGS...) do  { } while (0)
+#endif
+/*------------------------------------------------------------------------*/
+
+#define NCORES			8
+#define CORES2WORKERS(C)	(C)
+#define ACTIVEPERWORKER		8
+#define WORKERS2ACTIVE(W)	(ACTIVEPERWORKER*(W))
+#define CORES2ACTIVE(C)		WORKERS2ACTIVE(CORES2WORKERS(C))
+#define MAXGB			12ll
+#define MAXBYTES		(MAXGB<<30)
+#define MINCLIM			1000
+#define INITCLIM 		10000
+#define MAXCLIM			100000
+#define STOPLKHDRED		20
+#define MAXSTOPLKH		128
+#define FULLINT			10
+#define ASYMMETRIC		1
+#define FULLSIMP		4
+#define FULLSEARCH		2
+#define DEFBRANCHES		50
+#define OPTIMIZE		10
+
+/*------------------------------------------------------------------------*/
+
+#define NEW(PTR,NUM) \
+do { \
+  size_t BYTES = (NUM) * sizeof *(PTR); \
+  (PTR) = malloc (BYTES); \
+  if (!(PTR)) { err ("out of memory"); exit (1); } \
+  memset ((PTR), 0, BYTES); \
+  incmem (BYTES); \
+} while (0)
+
+#define DEL(PTR,NUM) \
+do { \
+  size_t BYTES = (NUM) * sizeof *(PTR); \
+  decmem (BYTES); \
+  free (PTR); \
+} while (0)
+
+#define PUSH(STACK,ELEM) \
+do { \
+  if (size ## STACK == num ## STACK) { \
+    size_t NEW_SIZE = size ## STACK; \
+    size_t OLD_BYTES = NEW_SIZE * sizeof *STACK, NEW_BYTES; \
+    if (NEW_SIZE) NEW_SIZE *= 2; else NEW_SIZE = 1; \
+    NEW_BYTES = NEW_SIZE * sizeof *STACK; \
+    decmem (OLD_BYTES); \
+    STACK = realloc (STACK, NEW_BYTES); \
+    if (!STACK) { err ("out of memory"); exit (1); } \
+    incmem (NEW_BYTES); \
+    size ## STACK = NEW_SIZE; \
+  } \
+  STACK[num ## STACK ++] = (ELEM); \
+} while (0)
+
+#define LL long long
+
+/*------------------------------------------------------------------------*/
+
+typedef enum State { 
+  FREE = 0,
+  READY = 1,
+  SIMP = 2,
+  LKHD = 3,
+  SPLIT = 4,
+  SEARCH = 5,
+} State;
+
+typedef struct Node {
+  State state;
+  int pos, lookahead, depth, res, simplified, consumed;
+  int64_t id, decisions, conflicts, propagations;
+  int * cube;
+  LGL * lgl;
+} Node;
+
+typedef struct Leaf {
+  int64_t id;
+  struct Leaf * next, * prev;
+  int * lits;
+} Leaf;
+
+typedef struct Parallel {
+  int64_t decisions, conflicts, propagations;
+  struct { int64_t leafs, units; } consumed, produced;
+  int res, nunits, *units;
+  pthread_t thread;
+  LGL * lgl;
+} Parallel;
+
+typedef struct Job {
+  int pos;
+  State state;
+  Node * node;
+  void * (*fun)(void *);
+  pthread_t thread;
+  const char * name;
+} Job;
+
+typedef struct Lock {
+  pthread_mutex_t mutex;
+  int locked, waited;
+} Lock;
+
+/*------------------------------------------------------------------------*/
+
+static int verbose, balance, showstats, nowitness, ncores, randswap, locslkhd;
+static int reducecache, nosimp, forcesimp, forcelkhd = 1, nosearch, noparallel;
+static int stoplkhd, stoplkhdint = 1, lkhdsuccessful, optimize = -1;
+static int fullint = FULLINT, asymmetric = ASYMMETRIC, eager = 1;
+static int splitsuccessful = 1, branches = -1, portfolio = 0;
+
+static int clim, newclim, forcedclim, thisclim, initclim, maxclim, minclim;
+static int nvars, nclauses;
+
+static LGL * root;
+static Node ** nodes;
+static int numnodes, maxnumnodes, sizenodes;
+static int rootconsumed;
+
+static Parallel parallel;
+static int nparallel;
+
+static int maxactive, firstosplit, numtosplit, lastosplit;
+static int maxworkers, maxworkers2, numworkers, maxnumworkers;
+
+static Job ** jobs;
+static int numjobs, sizejobs;
+static struct { int64_t cnt, lkhd, split, simp, search; } js;
+
+static int64_t * confstack;
+static int numconfstack, sizeconfstack;
+
+static const char * fname;
+static FILE * file;
+static int lineno;
+
+size_t maxbytes, hardlimbytes, softlimbytes, splitlimbytes, currentbytes;
+static int64_t ids, threads, conflicts, decisions, propagations;
+static int64_t sumclims, inclims, declims, forcedclims, sumsimplified;
+static struct { double epoch, simp, lkhd, split, search; } wct;
+static int round, started, deleted, simplified, added;
+static double * startimeptr, startime;
+static struct { int64_t set, def; } opts;
+
+struct { int num, max; int64_t count; Leaf * first, * last; } leafs;
+
+static int done, stop;
+
+static struct { unsigned z, w; } rng;
+
+static struct { 
+  Lock confs;
+  Lock done;
+  Lock leafs;
+  Lock mem;
+  Lock msg;
+  Lock nodes;
+  Lock opts;
+  Lock parleafs;
+  Lock parstats;
+  Lock parunits;
+  Lock simplified;
+  Lock stats;
+  Lock workers;
+} lock;
+
+static pthread_cond_t workerscond;
+
+/*------------------------------------------------------------------------*/
+
+static double currentime () {
+  double res = 0;
+  struct timeval tv;
+  if (!gettimeofday (&tv, 0))
+    res = 1e-6 * tv.tv_usec, res += tv.tv_sec;
+  return res;
+}
+
+static double getime () { return currentime () - wct.epoch; }
+
+static void warn (const char * fmt, ...) {
+  va_list ap;
+  fputs ("c *** warning *** ", stdout);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+static void startimer (double * timptr) {
+  assert (!started);
+  startimeptr = timptr;
+  startime = currentime ();
+  started = 1;
+}
+
+static double deltatime (double start) {
+  double res = currentime () - start;
+  if (res < 0) res = -res;
+  return res;
+}
+
+static double stoptimer () {
+  double * ptr, res = deltatime (startime);
+  assert (started);
+  assert (startimeptr);
+  started = 0;
+  if ((ptr = startimeptr)) *ptr += res;
+  startimeptr = 0;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void lockgen (Lock * lock, const char * name) {
+  if (pthread_mutex_lock (&lock->mutex))
+    warn ("failed to lock '%s' mutex", name);
+  assert (!lock->locked || lock->waited);
+  lock->locked++;
+}
+
+static void unlockgen (Lock *lock, const char * name) {
+  assert (lock->locked > 0 || lock->waited);
+  lock->locked--;
+  if (pthread_mutex_unlock (&lock->mutex))
+    warn ("failed to lock '%s' mutex", name);
+}
+
+#define LOCK(NAME) \
+  static void lock ## NAME () { \
+    lockgen (&lock.NAME, # NAME); \
+  }
+#define UNLOCK(NAME) \
+  static void unlock ## NAME () { \
+    unlockgen (&lock.NAME, # NAME); \
+  }
+
+LOCK (confs)
+LOCK (done)
+LOCK (leafs)
+LOCK (mem)
+LOCK (msg)
+LOCK (nodes)
+LOCK (opts)
+LOCK (parleafs)
+LOCK (parstats)
+LOCK (parunits)
+LOCK (simplified)
+LOCK (stats)
+LOCK (workers)
+UNLOCK (confs)
+UNLOCK (done)
+UNLOCK (leafs)
+UNLOCK (mem)
+UNLOCK (msg)
+UNLOCK (nodes)
+UNLOCK (opts)
+UNLOCK (parleafs)
+UNLOCK (parstats)
+UNLOCK (parunits)
+UNLOCK (simplified)
+UNLOCK (stats)
+UNLOCK (workers)
+
+/*------------------------------------------------------------------------*/
+
+static void err (const char * fmt, ...) {
+  va_list ap;
+  lockmsg ();
+  fputs ("c *** ", stdout);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  unlockmsg ();
+  exit (1);
+}
+
+static void smsg () {
+  double t = getime (), m;
+  lockmem ();
+  m  = currentbytes/(double)(1<<20);
+  unlockmem ();
+  printf (
+    "(%.1f %d %lld %d %d %.0f) ",
+    t, round, (LL) ids, numnodes, clim, m);
+}
+
+static void msg (const char * fmt, ...) {
+  va_list ap;
+  lockmsg ();
+  fputs ("c ", stdout);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  unlockmsg ();
+}
+
+static void vrb (const char * fmt, ...) {
+  va_list ap;
+  if (!verbose) return;
+  lockmsg ();
+  fputs ("c ", stdout);
+  smsg ();
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  unlockmsg ();
+}
+
+static void nmsg (Node * node, const char * fmt, ...) {
+  va_list ap;
+  if (!verbose) return;
+  lockmsg ();
+  printf ("c [%d %lld] ", node->depth, (LL) node->id);
+  smsg ();
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  unlockmsg ();
+}
+
+static void jmsg (Job * job, const char * msg) {
+  Node * node = job->node;
+  if (!verbose) return;
+  lockmsg ();
+  printf ("c [%d %lld] ", node->depth, (LL) node->id);
+  smsg ();
+  printf ("%s %s job %d\n", msg, job->name, job->pos);
+  fflush (stdout);
+  unlockmsg ();
+}
+
+static void mmsg (const char * msg, Node * node) {
+  if (!verbose) return;
+  lockmsg ();
+  printf ("c ");
+  smsg ();
+  printf ("%s [%d %lld]\n", 
+          msg, node->depth, (LL) node->id);
+  fflush (stdout);
+  unlockmsg ();
+}
+
+static void perr (const char * fmt, ...) {
+  va_list ap;
+  printf ("c *** parse error in '%s' at line %d: ", fname, lineno);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  exit (1);
+}
+
+static int skipnode (Node * node) {
+  assert (node->state != FREE);
+  if (lglinconsistent (node->lgl)) return 1;
+  return 0;
+}
+
+static void incround () {
+  round++;
+  vrb ("");
+  vrb ("=================== [ round %d ] ===================", round);
+  vrb ("");
+}
+
+static void startphase (const char * phase) {
+  if (!verbose) return;
+  vrb ("");
+  vrb ("------------------- [ %s %d ] -------------------", phase, round);
+  vrb ("");
+}
+
+/*------------------------------------------------------------------------*/
+
+static double avg (double a, double b) { return b > 0 ? a/b : 0.0; }
+static double pcnt (double a, double b) { return avg (100.0 * a, b); }
+
+/*------------------------------------------------------------------------*/
+
+static void incmem (size_t bytes) {
+  lockmem ();
+  currentbytes += bytes;
+  if (currentbytes > maxbytes) maxbytes = currentbytes;
+  unlockmem ();
+}
+
+static void decmem (size_t bytes) {
+  lockmem ();
+  assert (currentbytes >= bytes);
+  currentbytes -= bytes;
+  unlockmem ();
+}
+
+static void * alloc (void * dummy, size_t bytes) {
+  char * res;
+  NEW (res, bytes);
+  return res;
+}
+
+static void dealloc (void * dummy, void * void_ptr, size_t bytes) {
+  char * char_ptr = void_ptr;
+  DEL (char_ptr, bytes);
+}
+
+static void * resize (void * dummy, void * ptr, 
+                      size_t old_bytes, size_t new_bytes) {
+  lockmem ();
+  assert (currentbytes >= old_bytes);
+  currentbytes -= old_bytes;
+  currentbytes += new_bytes;
+  if (currentbytes > maxbytes) maxbytes = currentbytes;
+  unlockmem ();
+  return realloc (ptr, new_bytes);
+}
+
+static int64_t getotalmem (int explain) {
+  long long res;
+  FILE * p = popen ("grep MemTotal /proc/meminfo", "r");
+  if (p && fscanf (p, "MemTotal: %lld kB", &res) == 1) {
+    if (explain)
+      msg ("%lld KB total memory according to '/proc/meminfo'", res);
+    res <<= 10;
+  } else {
+    res = MAXGB << 30;
+    if (explain) 
+      msg ("assuming compiled in memory size of %d GB", MAXGB);
+  }
+  if (p) pclose (p);
+  return (int64_t) res;
+}
+
+static int getcores (int explain) {
+  int syscores, coreids, physids, procpuinfocores;
+  int usesyscores, useprocpuinfo, amd, intel, res;
+  FILE * p;
+
+  syscores = sysconf (_SC_NPROCESSORS_ONLN);
+  if (explain) {
+    if (syscores > 0)
+      msg ("'sysconf' reports %d processors online", syscores);
+    else
+      msg ("'sysconf' fails to determine number of online processors");
+  }
+
+  p = popen ("grep '^core id' /proc/cpuinfo 2>/dev/null|sort|uniq|wc -l", "r");
+  if (p) {
+    if (fscanf (p, "%d", &coreids) != 1) coreids = 0;
+    if (explain) {
+      if (coreids > 0) 
+	msg ("found %d unique core ids in '/proc/cpuinfo'", coreids);
+      else
+	msg ("failed to extract core ids from '/proc/cpuinfo'");
+    }
+    pclose (p);
+  } else coreids = 0;
+
+  p = popen (
+        "grep '^physical id' /proc/cpuinfo 2>/dev/null|sort|uniq|wc -l", "r");
+  if (p) {
+    if (fscanf (p, "%d", &physids) != 1) physids = 0;
+    if (explain) {
+      if (physids > 0) 
+	msg ("found %d unique physical ids in '/proc/cpuinfo'", 
+            physids);
+      else
+	msg ("failed to extract physical ids from '/proc/cpuinfo'");
+    }
+    pclose (p);
+  } else physids = 0;
+
+  if (coreids > 0 && physids > 0 && 
+      (procpuinfocores = coreids * physids) > 0) {
+    if (explain)
+      msg ("%d cores = %d core times %d physical ids in '/proc/cpuinfo'",
+           procpuinfocores, coreids, physids);
+  } else procpuinfocores = 0;
+
+  usesyscores = useprocpuinfo = 0;
+
+  if (procpuinfocores > 0 && procpuinfocores == syscores) {
+    if (explain) msg ("'sysconf' and '/proc/cpuinfo' results match");
+    usesyscores = 1;
+  } else if (procpuinfocores > 0 && syscores <= 0) {
+    if (explain) msg ("only '/proc/cpuinfo' result valid");
+    useprocpuinfo = 1;
+  } else if (procpuinfocores <= 0 && syscores > 0) {
+    if (explain) msg ("only 'sysconf' result valid");
+    usesyscores = 1;
+  } else if (procpuinfocores > 0 && syscores > 0) {
+    intel = !system ("grep vendor /proc/cpuinfo 2>/dev/null|grep -q Intel");
+    if (intel && explain) 
+      msg ("found Intel as vendor in '/proc/cpuinfo'");
+    amd = !system ("grep vendor /proc/cpuinfo 2>/dev/null|grep -q AMD");
+    if (amd && explain) 
+      msg ("found AMD as vendor in '/proc/cpuinfo'");
+    assert (syscores > 0);
+    assert (procpuinfocores > 0);
+    assert (syscores != procpuinfocores);
+    if (amd) {
+      if (explain) msg ("trusting 'sysconf' on AMD");
+      usesyscores = 1;
+    } else if (intel) {
+      if (explain) {
+	msg ("'sysconf' result off by a factor of %f on Intel", 
+	     syscores / (double) procpuinfocores);
+	msg ("trusting 'sysconf' on Intel (assuming HyperThreading)");
+      }
+      usesyscores = 1;
+    }  else {
+      if (explain)
+	msg ("trusting 'sysconf' on unknown vendor machine");
+      usesyscores = 1;
+    }
+  } 
+  
+  if (useprocpuinfo) {
+    if (explain) 
+      msg ("assuming cores = core * physical ids in '/proc/cpuinfo' = %d",
+           procpuinfocores);
+    res = procpuinfocores;
+  } else if (usesyscores) {
+    if (explain) 
+      msg (
+       "assuming cores = number of processors reported by 'sysconf' = %d",
+       syscores);
+    res = syscores;
+  } else {
+    if (explain) 
+      msg ("using compiled in default value of assumed %d cores", NCORES);
+    res = NCORES;
+  }
+
+  return res;
+}
+
+static void usage () {
+  int64_t b = getotalmem (0);
+  long long m = ((b+(1<<20)-1) >> 20), g = ((b+(1<<30)-1) >> 30); 
+  int c = getcores (0);
+  printf (
+"usage: treengeling [<option> ...] [<file> [<workers>]]\n"
+"\n"
+"where <option> is one of the following\n"
+"\n"
+"  -h             print option summary\n"
+"  --version      print version and exit\n"
+"  -v             increase verbose level\n"
+"  -S             print statistics for each solver instance too\n"
+"  -n             do not print satisfying assignments\n"
+"\n"             
+"  -t <workers>   maximum number actual worker threads (system default %d)\n"
+"  -a <nodes>     maximum number active nodes (system default %d)\n"
+"\n"             
+"  -m <mb>        assumed memory in mega bytes (system default %lld MB)\n"
+"  -g <gb>        assumed memory in giga bytes (system default %lld GB)\n"
+"\n"             
+"  -r <posnum>    randomize splits by swapping <posnum> nodes\n"
+"  -s <seed>      unsigned 64 bit seed for randomizing splits (default 0)\n"
+"\n"             
+"  -b <branches>  percentage of nodes split (default %d%%)\n"
+"\n"             
+"  --balance      split larger nodes first\n"
+"  --symmetric    symmetric splitting%s\n"
+"  --asymmetric   asymmetric splitting%s\n"
+"  --eager        eager splitting by forced reduction of limit (default)\n"
+"  --lazy         disable eager splitting (opposite of '--eager')\n"
+"  --portfolio    use portfolio style option fuzzing (default off)\n"
+"\n"             
+" --min=<lim>     minimum conflict limit per search (compiled default %d)\n"
+" --init=<lim>    initial conflict limit per search (compiled default %d)\n"
+" --max=<lim>     maximum conflict limit per search (compiled default %d)\n"
+"\n"             
+"  --reduce       reduce learned clause cache for all right branches\n"
+"  --force-simp   force simplification even after light simplification\n"
+"  --force-lkhd   force full look-ahead every time\n"
+"  --no-simp      do not explicitly simplify in each round\n"
+"  --no-search    do not even search in each round\n"
+"  --no-parallel  disable additional parallel solver instance\n"
+"  --no-full      no full rounds every %d rounds\n"
+"  -f <fullint>   full round interval (default %d)\n"
+"\n"
+"and the <file> is a DIMACS file.  If the name of the file has a '.gz'\n"
+"respectively '.bz2' suffix, it is assumed to be a file compressed with\n"
+"'gzip' respectively 'bzip2'.  In this case the parser will open a pipe\n"
+"and execute 'gunzip' respectively 'bzcat'.\n",
+  CORES2WORKERS (c),
+  CORES2ACTIVE (c),
+  m,
+  g, 
+  DEFBRANCHES,
+  ASYMMETRIC ? "" : " (default)",
+  ASYMMETRIC ? " (default)" : "",
+  MINCLIM,
+  INITCLIM,
+  MAXCLIM,
+  FULLINT,
+  FULLINT);
+  fflush (stdout);
+  exit (0);
+}
+
+static void version () { printf ("%s\n", lglversion ()); exit (0); }
+
+static int next () {
+  int res = getc (file);
+  if (res == '\n') lineno++;
+  return res;
+}
+
+static int ws (int ch) {
+  return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r';
+}
+
+static void parse (LGL * lgl) {
+  int sclauses, ch, sign, lit, last, nlits;
+  lineno = 1;
+HEADER:
+  if ((ch = next ()) == EOF) perr ("unexpected end-of-file before header");
+  if (ch == 'c') {
+    while ((ch = next ()) != '\n')
+      if (ch == EOF) perr ("unexpected end-of-file in header comment");
+    goto HEADER;
+  }
+  if (ch != 'p') perr ("unexpected character 0x%02x in header", ch);
+  if ((fscanf (file, " cnf %d %d", &nvars, &sclauses)) != 2 ||
+      nvars < 0 || sclauses < 0)
+    perr ("invalid header");
+  msg ("found 'p cnf %d %d' header", nvars, sclauses);
+  nlits = last = 0;
+BODY:
+  ch = next ();
+  if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') goto BODY;
+  if (ch == EOF) {
+    if (last) perr ("zero missing after %d in last clause", last);
+    if (nclauses < sclauses) perr ("%d clauses missing", sclauses - nclauses);
+    msg ("parsed %d literals in %d clauses in %.2f seconds",
+      nlits, nclauses, getime ());
+    return;
+  }
+  if (ch == 'c') {
+    while ((ch = next ()) != '\n')
+      if (ch == EOF) perr ("unexpected end-of-file in body comment");
+    goto BODY;
+  }
+  sign = 1;
+  if (ch == '-') {
+    if (!isdigit (ch = next ())) perr ("expected digit after '-'");
+    sign = -1;
+  } else if (!isdigit (ch)) perr ("expected digit or '-'");
+  lit = ch - '0';
+  while (isdigit (ch = next ()))
+    lit = 10*lit + (ch - '0');
+  if (lit > nvars) perr ("variable %d exceeds maximum %d", lit, nvars);
+  assert (nclauses <= sclauses);
+  if (nclauses == sclauses) perr ("too many clauses");
+  if (lit) lit *= sign, nlits++; else nclauses++;
+  if (ch != EOF && !ws (ch)) perr ("expected white space after %d", lit);
+  lgladd (lgl, lit);
+  last = lit;
+  goto BODY;
+}
+
+static int isnum (const char * str) {
+  const char * p = str;
+  if (!isdigit ((int)*p)) return 0;
+  while (*++p) if (!isdigit ((int)*p)) return 0;
+  return 1;
+}
+
+static int exists (const char * str) {
+  struct stat buf;
+  return !stat (str, &buf);
+}
+
+static int term (void * dummy) {
+  int res;
+  assert (!dummy);
+  lockdone ();
+  res = done || stop;
+  unlockdone ();
+  return res;
+}
+
+static void produceunit (void * voidptr, int lit) {
+  assert (!noparallel);
+  lockparunits ();
+  assert (parallel.nunits < nvars);
+  parallel.units[parallel.nunits++] = lit;
+  parallel.produced.units++;
+  unlockparunits ();
+}
+
+static void consumeunits (void * voidptr, int ** fromptr, int ** toptr) {
+  int * consumedptr = voidptr, produced, consumed;
+  assert (fromptr);
+  assert (toptr);
+  lockparunits ();
+  produced = parallel.nunits;
+  consumed = produced - *consumedptr;
+  parallel.consumed.units += consumed;
+  unlockparunits ();
+  assert (consumed >= 0);
+  *fromptr = parallel.units + *consumedptr;
+  *toptr = parallel.units + produced;
+  *consumedptr = produced;
+}
+
+static int intslen (const int * ints) {
+  const int * p;
+  for (p = ints; *p; p++)
+    ;
+  return p - ints;
+}
+
+static int * appendint (int * ints, int i) {
+  int len, * res, * q, other;
+  const int * p;
+  assert (ints);
+  len = intslen (ints) + 1;
+  NEW (res, len + 1);
+  q = res;
+  for (p = ints; (other = *p); p++) *q++ = other;
+  assert (p - ints == len - 1);
+  *q++ = i;
+  assert (q - res == len);
+  *q++ = 0;
+  return res;
+}
+
+static void addint (int ** intsptr, int i) {
+  int * oldints = *intsptr, len = intslen (oldints);
+  const int * p; int * q, o, * newints;
+  NEW (newints, len + 2);
+  q = newints;
+  for (p = oldints; (o = *p); p++) *q++ = o;
+  *q++ = i;
+  DEL (oldints, len + 1);
+  *intsptr = newints;
+}
+
+static void cubemsg (Node * node, const char * str) {
+  const int * p;
+  if (!verbose) return;
+  lockmsg ();
+  printf ("c [%d %lld] ", node->depth, (LL) node->id);
+  smsg ();
+  fputs (str, stdout);
+  if (node->cube) {
+    for (p = node->cube; *p; p++) printf (" %d", *p);
+    fputs (" 0", stdout);
+  } else fputs (" <cube-already-deleted>", stdout);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  unlockmsg ();
+}
+
+static void initroot () {
+  assert (!root);
+  msg ("initializing root solver instance");
+  root = lglminit (0, alloc, resize, dealloc);
+  lglsetopt (root, "druplig", 0);
+  lglsetopt (root, "classify", 0);
+  if (verbose) lglsetopt (root, "verbose", verbose);
+  else if (!showstats) lglsetopt (root, "profile", 0);
+  lglsetopt (root, "abstime", 1);
+  lglsetopt (root, "trep", 0);
+  lglsetopt (root, "compact", 1);
+  if (!noparallel) {
+    lglsetopt (root, "bca", 0);
+    lglseterm (root, term, 0);
+    lglsetconsumeunits (root, consumeunits, &rootconsumed);
+    lglsetmsglock (root, lockmsg, unlockmsg, 0);
+  }
+  lglsetime (root, getime);
+  lglsetprefix (root, "c (root) ");
+}
+
+static Node * newnode (Node * parent, int decision) {
+  char prefix[80];
+  Node * res;
+  locknodes ();
+  NEW (res, 1);
+  assert (res->state == FREE);
+  res->state = READY;
+  if (parent) res->depth = parent->depth + 1;
+  res->id = ids++;
+  res->pos = numnodes;
+  PUSH (nodes, res);
+  if (numnodes > maxnumnodes) maxnumnodes = numnodes;
+  unlocknodes ();
+  nmsg (res, "new node");
+  if (parent) {
+    res->lgl = lglclone (parent->lgl);
+    res->decisions = lglgetdecs (res->lgl);
+    res->conflicts = lglgetconfs (res->lgl);
+    res->propagations = lglgetprops (res->lgl);
+    res->consumed = parent->consumed;
+    res->cube = appendint (parent->cube, decision);
+    lgladd (res->lgl, decision);
+    lgladd (res->lgl, 0);
+  } else {
+    msg ("forking root solver instance");
+    NEW (res->cube, 1);
+    assert (!intslen (res->cube));
+    assert (root);
+    res->lgl = lglfork (root);
+  }
+  sprintf (prefix, "c (%d %lld) ", res->depth, (LL) res->id);
+  lglsetprefix (res->lgl, prefix);
+  lglseterm (res->lgl, term, 0);
+  lglsetmsglock (res->lgl, lockmsg, unlockmsg, 0);
+  if (!noparallel) lglsetconsumeunits (res->lgl, consumeunits, &res->consumed);
+  cubemsg (res, "opened cube");
+  added++;
+  return res;
+}
+
+static void updstats (Node * node) {
+  double * ptr, now, delta;
+  LGL * lgl = node->lgl;
+  lockstats ();
+  decisions += lglgetdecs (lgl) - node->decisions;
+  conflicts += lglgetconfs (lgl) - node->conflicts;
+  propagations += lglgetprops (lgl) - node->propagations;
+  if (started && (ptr = startimeptr)) {
+    now = currentime ();
+    delta = now - startime;
+    startime = now;
+    *ptr += delta;
+  }
+  unlockstats ();
+}
+
+static void delnode (Node * node) {
+  Node * last;
+  int lastpos;
+  LGL * lgl;
+  assert (node);
+  cubemsg (node, "closed cube");
+  nmsg (node, "delete node");
+  locknodes ();		// TODO why?
+  assert (0 <= node->pos && node->pos < sizenodes);
+  assert (nodes[node->pos] == node);
+  assert (node->state == READY);
+  assert (numnodes > 0);
+  lastpos = --numnodes;
+  last = nodes[lastpos];
+  assert (last && last->pos == lastpos);
+  if (node != last) { 
+    assert (node->pos < lastpos);
+    nodes[node->pos] = last;
+    last->pos = node->pos;
+  }
+  nodes[lastpos] = 0;
+  unlocknodes ();	// TODO why?
+  lgl = node->lgl;
+  updstats (node);
+  node->lgl = 0;
+  if (node->cube) DEL (node->cube, intslen (node->cube) + 1);
+  DEL (node, 1);
+  assert (lgl);
+  if (showstats) lglstats (lgl);
+  lglrelease (lgl);
+  deleted++;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void leafmsg (Leaf * leaf, const char * str) {
+  const int * p;
+  if (!verbose) return;
+  lockmsg ();
+  printf ("c %s leaf %lld clause", str, (LL) leaf->id);
+  if (leaf->lits) {
+    for (p = leaf->lits; *p; p++)
+      printf (" %d", *p);
+    printf (" 0");
+  } else fputs (" <literals-already-deleted>", stdout);
+  fputc ('\n', stdout);
+  fflush (stdout);
+  unlockmsg ();
+}
+
+static Leaf * newleaf (Node * node) {
+  int * p, lit;
+  Leaf * res;
+  NEW (res, 1);
+  if (++leafs.num > leafs.max) leafs.max = leafs.num;
+  res->id = ++leafs.count;
+  res->lits = node->cube;
+  node->cube = 0;
+  for (p = res->lits; (lit = *p); p++) *p = -lit;
+  leafmsg (res, "new");
+  return res;
+}
+
+static void deleaf (Leaf * leaf) {
+  leafmsg (leaf, "delete");
+  if (leaf->lits) DEL (leaf->lits, intslen (leaf->lits) + 1);
+  DEL (leaf, 1);
+  assert (leafs.num > 0);
+  leafs.count--;
+}
+
+static void enqleaf (Leaf * leaf) {
+  leafmsg (leaf, "enqueue");
+  lockleafs ();
+  if (leafs.last) leafs.last->next = leaf;
+  else leafs.first = leaf;
+  leaf->prev = leafs.last;
+  leafs.last = leaf;
+  assert (!leaf->next);
+  unlockleafs ();
+  lockparleafs ();
+  parallel.produced.leafs++;
+  unlockparleafs ();
+}
+
+static Leaf * deqleaf () {
+  Leaf * res;
+  lockleafs ();
+  res = leafs.first;
+  if (res) {
+    if (res->next) res->next->prev = 0;
+    else leafs.last = 0;
+    leafs.first = res->next;
+  }
+  unlockleafs ();
+  if (res) leafmsg (res, "dequeue");
+  return res;
+}
+
+static void enqnewleafromnode (Node * node) { enqleaf (newleaf (node)); }
+
+/*------------------------------------------------------------------------*/
+
+static int * clausetoconsume;
+
+static void consumecls (void * voidptr, int ** cptr, int * glueptr) {
+  Leaf * leaf = deqleaf ();
+  if (leaf) {
+    if (clausetoconsume)
+      DEL (clausetoconsume, intslen (clausetoconsume) + 1);
+    clausetoconsume = leaf->lits;
+    leaf->lits = 0;
+    *cptr = clausetoconsume;
+    *glueptr = 0;
+    deleaf (leaf);
+    parallel.consumed.leafs++;
+  } else *cptr = 0;
+}
+
+static void * runparallel (void * dummy) {
+  assert (!dummy);
+  int res;
+  if ((res = lglsat (parallel.lgl))) {
+    vrb ("parallel solver search result %d", res);
+    lockdone ();
+    parallel.res = res;
+    assert (!done || done == res);
+    done = parallel.res;
+    unlockdone ();
+  }
+  return dummy;
+}
+
+static void startparallel (LGL * lgl) {
+  char prefix[80];
+  assert (!noparallel);
+  assert (!parallel.lgl);
+  assert (!parallel.res);
+  assert (!parallel.nunits);
+  msg ( "cloning and starting %s additional parallel solver instance",
+    nparallel ? "second" : "first");
+  nparallel++;
+  assert (nparallel <= 2);
+  NEW (parallel.units, nvars);
+  parallel.lgl = lglclone (lgl);
+  sprintf (prefix, "c (parallel%d) ", nparallel);
+  lglsetprefix (parallel.lgl, prefix);
+  lglsetopt (parallel.lgl, "locs", -1);
+  lglsetopt (parallel.lgl, "locsbanner", nparallel == 1);
+  lglsetopt (parallel.lgl, "locsmaxeff", 1000000);
+  lglsetopt (parallel.lgl, "locsmineff", 10000);
+  lglsetopt (parallel.lgl, "locsreleff", 20);
+  lglsetopt (parallel.lgl, "locsvared", 1000);
+  lglsetopt (parallel.lgl, "locswait", 0);
+  lglsetopt (parallel.lgl, "block", 1);
+  lglsetopt (parallel.lgl, "bca", 0);
+  lglseterm (parallel.lgl, term, 0);
+  lglsetproduceunit (parallel.lgl, produceunit, 0);
+  lglsetconsumecls (parallel.lgl, consumecls, 0);
+  lglsetmsglock (parallel.lgl, lockmsg, unlockmsg, 0);
+  parallel.decisions = lglgetdecs (parallel.lgl);
+  parallel.conflicts = lglgetconfs (parallel.lgl);
+  parallel.propagations = lglgetprops (parallel.lgl);
+  lockdone ();
+  stop = 0;
+  unlockdone ();
+  if (pthread_create (&parallel.thread, 0, runparallel, 0))
+    err ("failed to create thread for additional parallel solver instance");
+}
+
+static int joinparallel () {
+  int res;
+  assert (!noparallel);
+  lockdone ();
+  stop = 1;
+  unlockdone ();
+  if (pthread_join (parallel.thread, 0))
+    err ("failed to join additional parallel solver instance thread");
+  res = parallel.res;
+  vrb ("joined parallel solver instance with result %d", res);
+  return res;
+}
+
+static void releaseparallel () {
+  LGL * lgl;
+  lockparstats ();
+  lgl = parallel.lgl;
+  parallel.lgl = 0;
+  parallel.res = 0;
+  decisions += lglgetdecs (lgl) - parallel.decisions;
+  conflicts += lglgetconfs (lgl) - parallel.conflicts;
+  propagations += lglgetprops (lgl) - parallel.propagations;
+  unlockparstats ();
+  if (showstats) lglstats (lgl);
+  lglrelease (lgl);
+  DEL (parallel.units, nvars);
+  parallel.nunits = 0;
+  vrb ("released parallel solver instance");
+}
+
+/*------------------------------------------------------------------------*/
+
+static char wbuf[80];
+static int wlen;
+
+static void wflush () {
+  int i;
+  fputc ('v', stdout);
+  for (i = 0; i < wlen; i++) fputc (wbuf[i], stdout);
+  fputc ('\n', stdout);
+  wlen = 0;
+}
+
+static void wprint (int lit) {
+  char str[20];
+  int len;
+  sprintf (str, " %d", lit);
+  len = strlen (str);
+  if (wlen + len > 74) wflush ();
+  strcpy (wbuf + wlen, str);
+  wlen += len;
+}
+
+static void witness (LGL * lgl) {
+  int idx, lit;
+  for (idx = 1; idx <= nvars; idx++) {
+    lit = (lglderef (lgl, idx) < 0) ? -idx : idx;
+    wprint (lit);
+  }
+  wprint (0);
+  if (wlen) wflush ();
+}
+
+/*------------------------------------------------------------------------*/
+
+static int nowfull () { return fullint && !(round % fullint); }
+
+/*------------------------------------------------------------------------*/
+
+static void schedulejob (Node * node, void*(*fun)(void*),
+                         const char * name, State state) {
+  Job * job;
+  js.cnt++;
+  assert (nowfull () || numjobs < maxactive);
+  assert (state != FREE);
+  assert (state != READY);
+  NEW (job, 1);
+  job->node = node;
+  job->fun = fun;
+  job->name = name;
+  job->state = state;
+  job->pos = numjobs;
+  PUSH (jobs, job);
+  jmsg (job, "scheduled");
+}
+
+static void runjob (Job * job) {
+  Node * node = job->node;
+  jmsg (job, "start");
+  assert (node->state == READY);
+  node->state = job->state;
+  threads++;
+  if (pthread_create (&job->thread, 0, job->fun, node))
+    err ("failed to create thread job %d %s [%d %lld]",
+         job->pos, job->name, node->depth, node->id);
+  jmsg (job, "end");
+}
+
+static void incworkers () {
+  lockworkers ();
+  assert (numworkers <= maxworkers);
+  while (numworkers >= maxworkers) {
+    lock.workers.waited++;
+    if (pthread_cond_wait (&workerscond, &lock.workers.mutex))
+      err ("failed to wait on decrease of the number of workers");
+    lock.workers.waited--;
+    assert (numworkers <= maxworkers);
+  }
+  numworkers++;
+  if (numworkers > maxnumworkers) maxnumworkers = numworkers;
+  vrb ("number of workers increased to %d", numworkers);
+  unlockworkers ();
+}
+
+static void decworkers () {
+  lockworkers ();
+  assert (numworkers > 0);
+  numworkers--;
+  vrb ("number of workers decreased to %d", numworkers);
+  if (pthread_cond_signal (&workerscond))
+    err ("failed to signal decrease of the number of workers");
+  unlockworkers ();
+}
+
+static size_t nodebytes (Node * n) {
+  assert (n->state == READY);
+  assert (n->lgl);
+  return lglbytes (n->lgl);
+}
+
+static size_t nodevars (Node * n) {
+  assert (n->state == READY);
+  assert (n->lgl);
+  return lglnvars (n->lgl);
+}
+
+static int cmpnodes (Node * m, Node * n, int dir) {
+  int res, skipm = skipnode (m), skipn = skipnode (n);
+  if ((res = skipm - skipn)) return res;
+  if (!skipn && !skipm &&
+      (res = nodevars (m) - nodevars (n))) return dir*res;
+  if ((res = n->depth - m->depth)) return res;
+  if (m->id > n->id) return -1;
+  if (m->id < n->id) return 1;
+  return 0;
+}
+
+static int cmpjobs4qsort (const void * p, const void * q) {
+  Job * j = *(Job**)p, * k = *(Job**) q;
+  return cmpnodes (j->node, k->node, -1);
+}
+
+static void fixjobspos () {
+  Job * job;
+  int i;
+  for (i = 0; i < numjobs; i++) {
+    job = jobs[i];
+    assert (job);
+    job->pos = i;
+  }
+}
+
+int bytes2mb (size_t bytes) {
+  size_t res = bytes;
+  res >>= 20;
+  if (res > INT_MAX) res = INT_MAX;
+  return res;
+}
+
+static void printnode (const char * prefix, Node * node) {
+  msg ("  %s:  node[%d] = [%d %lld]  (%d vars, %d MB)", 
+       prefix, node->pos, node->depth, (LL) node->id,
+       nodevars (node), bytes2mb (nodebytes (node)));
+}
+
+static void printjobs () {
+  char str[80];
+  Job * job;
+  int i;
+  msg ("");
+  for (i = 0; i < numjobs; i++) {
+    job = jobs[i];
+    assert (job);
+    assert (job->node);
+    assert (job->pos == i);
+    sprintf (str, "job[%d] round %d", i, round);
+    printnode (str, job->node);
+  }
+  msg ("");
+}
+
+static void sortjobs () {
+  qsort (jobs, numjobs, sizeof *jobs, cmpjobs4qsort);
+  fixjobspos ();
+  if (verbose) printjobs ();
+}
+
+static void runjobs () {
+  Job * job;
+  int i;
+  sortjobs ();
+  vrb ("running %d jobs", numjobs);
+  numworkers = 0;
+  for (i = 0; i < numjobs; i++) {
+    incworkers ();
+    job = jobs[i];
+    runjob (job);
+  }
+  vrb ("started running %d jobs", numjobs);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void joinjob (Job * job) {
+  Node * node = job->node;
+  assert (node->state != FREE);
+  assert (node->state != READY);
+  if (node->state == SEARCH) mmsg ("join search", node);
+  else if (node->state == SIMP) mmsg ("join simp", node);
+  else if (node->state == LKHD) mmsg ("join simp", node);
+  else assert (node->state == SPLIT), mmsg ("join split", node);
+  if (pthread_join (job->thread, 0))
+    err ("failed to join thread");
+  node->state = READY;
+  if (node->res == 20) {
+    mmsg ("unsatisfiable", node);
+  } else if (node->res == 10) {
+    lockdone ();
+    mmsg ("satisfiable", node);
+    done = 10;
+    unlockdone ();
+  } else {
+    assert (!node->res);
+    mmsg ("unknown", node);
+  }
+  DEL (job, 1);
+}
+
+static void joinjobs () {
+  int i;
+  vrb ("joining %d jobs in round %d", numjobs, round);
+  for (i = 0; i < numjobs; i++) joinjob (jobs[i]);
+  vrb ("finished joining %d nodes in round %d", numjobs, round);
+  numjobs = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int incmpnodes (const void * p, const void * q) {
+  return cmpnodes (*(Node**)p, *(Node**)q, 1);
+}
+
+static int decmpnodes (const void * p, const void * q) {
+  return cmpnodes (*(Node**)p, *(Node**)q, -1);
+}
+
+static void printnodes (const char * prefix) {
+  Node * node;
+  int i;
+  msg ("");
+  for (i = 0; i < numnodes; i++) {
+    node = nodes[i];
+    if (skipnode (node)) continue;
+    printnode (prefix, node);
+  }
+  msg ("");
+}
+
+static void fixnodespos () {
+  Node * node;
+  int i;
+  for (i = 0; i < numnodes; i++) {
+    node = nodes[i];
+    assert (node);
+    node->pos = i;
+  }
+}
+
+static void sortnodes (const char * name,
+                       int (*cmp)(const void *, const void*)) {
+  char prefix[80];
+  qsort (nodes, numnodes, sizeof *nodes, cmp);
+  fixnodespos ();
+  if (!verbose) return;
+  sprintf (prefix, "%s(%d) sorted", name, round);
+  printnodes (prefix);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void * simpnode (void * voidptr) {
+  Node * node = voidptr;
+  assert (!node->res);
+  assert (node->state == SIMP);
+  nmsg (node, "simp");
+  node->res = lglsimp (node->lgl, 1);
+  node->simplified = 1;
+  nmsg (node, "simp result %d", node->res);
+  if (node->res == 10) lockdone (), done = 10, unlockdone ();
+  else if (node->res == 20) {
+    locksimplified ();
+    simplified++;
+    sumsimplified++;
+    unlocksimplified ();
+  }
+  decworkers ();
+  return node;
+}
+
+static void simp () {
+  Node * node;
+  int i, l;
+  if (nosimp) return;
+  LOG ("simp");
+  startimer (&wct.simp);
+  startphase ("simp");
+  sortnodes ("simp", incmpnodes);
+  l = maxactive;
+  if (nowfull ()) l *= FULLSIMP;
+  if (l > numnodes) l = numnodes;
+  msg (" %d simplify  %d out of %d nodes %.0f%%",
+    round, l, numnodes, pcnt (l, numnodes));
+  for (i = 0; i < numnodes && numjobs < l; i++) {
+    node = nodes[i];
+    assert (node);
+    if (skipnode (node)) continue;
+    if (!forcesimp && node->simplified) continue;
+    js.simp++;
+    schedulejob (node, simpnode, "simp", SIMP);
+  }
+  vrb ("scheduled %d simplification jobs in round %d", numjobs, round);
+  runjobs ();
+  joinjobs ();
+  stoptimer ();
+}
+
+/*------------------------------------------------------------------------*/
+
+void mysrand (unsigned long long seed) {
+  unsigned z = seed >> 32, w = seed;
+  if (!z) z = ~z; if (!w) w = ~w;
+  rng.z = z, rng.w = w;
+}
+
+static unsigned myrand () {
+  unsigned res;
+  rng.z = 36969 * (rng.z & 65535) + (rng.z >> 16);
+  rng.w = 18000 * (rng.w & 65535) + (rng.w >> 16);
+  res = (rng.z << 16) + rng.w;
+  return res;
+}
+
+static unsigned myrandmod (unsigned mod) {
+  unsigned res;
+  assert (mod >= 1);
+  if (mod <= 1) return 0;
+  res = myrand ();
+  res %= mod;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void * lookaheadnode (void * voidptr) {
+  int oldvars, newvars, redpermille, oldjwhred;
+  Node * node = voidptr;
+  assert (!node->res);
+  assert (node->state == LKHD);
+  oldjwhred = lglgetopt (node->lgl, "jwhred");
+  oldvars = lglnvars (node->lgl);
+  if (!stoplkhd) {
+    nmsg (node, "full tree-based lookahead");
+    lglsetopt (node->lgl, "lkhd", 2);
+  } else if (locslkhd) {
+    nmsg (node, "local search based lookahead");
+    lglsetopt (node->lgl, "lkhd", -1);
+  } else {
+    nmsg (node, "no lookahead");
+    lglsetopt (node->lgl, "lkhd", 1);	// JWH
+    lglsetopt (node->lgl, "jwhred", 2);
+  }
+  node->lookahead = lglookahead (node->lgl);
+  lglsetopt (node->lgl, "jwhred", oldjwhred);
+  nmsg (node, "lookahead literal %d", node->lookahead);
+  newvars = lglnvars (node->lgl);
+  assert (newvars <= oldvars);
+  if (!oldvars) redpermille = 0;
+  else 
+    redpermille = 
+      (1000ll * (long long) (oldvars -  newvars)) / (long long) oldvars;
+  nmsg (node, "lookahead reduced %d variables to %d variables %.1f%%", 
+    oldvars, newvars, redpermille / 10.0);
+  if (redpermille >= STOPLKHDRED) lkhdsuccessful = 1;
+  decworkers ();
+  return node;
+}
+
+static int firstlkhd () {
+  int numactive = (maxactive > numnodes) ? numnodes : maxactive;
+  numtosplit = (numactive * branches + 99) / 100;
+  if (numnodes < maxactive) {
+    int delta = maxactive - numnodes;
+    if (numtosplit <= delta) numtosplit = delta;
+    if (numtosplit > numnodes) numtosplit = numnodes;
+  }
+  if (asymmetric) {
+    lastosplit = numactive - 1;
+    firstosplit = lastosplit - numtosplit + 1;
+  } else {
+    firstosplit = 0;
+    lastosplit = numtosplit - 1;
+    if (numtosplit > numnodes) lastosplit = numnodes-1;
+  }
+  msg (
+    " %d lookahead %d out of %d nodes %.0f%% on nodes [%d..%d]",
+    round,
+    numtosplit, numnodes,
+    pcnt (numtosplit, numnodes),
+    firstosplit, lastosplit);
+  fflush (stdout);
+  return firstosplit;
+}
+
+static int donelkhd (int i) {
+  assert (firstosplit <= i), assert (i <= lastosplit + 1);
+  return i > lastosplit;
+}
+
+static int nextlkhd (int i) { return i + 1; }
+
+static void lookahead () {
+  size_t sumbytes = currentbytes, expected;
+  int i, j, k;
+  Node * node;
+  LOG ("lookahead");
+  startimer (&wct.lkhd);
+  lkhdsuccessful = 0;
+  for (i = 0; i < numnodes; i++) {
+    node = nodes[i];
+    assert (node);
+    node->lookahead = 0;
+  }
+  startphase ("lookahead");
+  sortnodes ("lookahead", balance ? decmpnodes : incmpnodes);
+  if (randswap) {
+    vrb ("swapping %d random node pairs", randswap);
+    for (k = 0; k < randswap; k++) {
+      i = myrandmod (numnodes);
+      j = myrandmod (numnodes);
+      vrb ("swapping nodes %d and %d", i, j);
+      node = nodes[i];
+      nodes[i] = nodes[j];
+      nodes[j] = node;
+    }
+    fixnodespos ();
+  }
+  vrb ("starting lookahead round %d", round);
+  for (i = firstlkhd (); !donelkhd (i); i = nextlkhd (i)) {
+    node = nodes[i];
+    expected = nodebytes (node);
+    nmsg (node, "cloning might add %d MB", bytes2mb (expected));
+    nmsg (node, "plus already scheduled %d MB gives %d MB",
+	  bytes2mb (sumbytes), bytes2mb (expected + sumbytes));
+    if (sumbytes + expected > softlimbytes) {
+      vrb ("resulting size %d MB exceeds soft memory limit %d MB",
+           bytes2mb (sumbytes + expected), bytes2mb (softlimbytes));
+      if (!splitlimbytes || splitlimbytes > sumbytes)
+	splitlimbytes = sumbytes;
+    } else {
+      sumbytes += expected;
+      if (!stoplkhd) js.lkhd++;
+      schedulejob (node, lookaheadnode, "lookahead", LKHD);
+    }
+  }
+  vrb ("final size is expected not to exceed %d MB", bytes2mb (sumbytes));
+  vrb ("scheduled %d lookahead jobs out of %d in round %d", 
+       numjobs, numnodes, round);
+  runjobs ();
+  joinjobs ();
+  if (stoplkhd) stoplkhd--;
+  else if (!forcelkhd && !lkhdsuccessful) {
+    assert (0 < stoplkhdint && stoplkhdint <= MAXSTOPLKH);
+    if (stoplkhdint < MAXSTOPLKH) stoplkhdint *= 2;
+    stoplkhd = stoplkhdint;
+  } else if (stoplkhdint > 1) stoplkhdint--;
+  stoptimer ();
+}
+
+/*------------------------------------------------------------------------*/
+
+static void * splitnode (void * voidptr) {
+  Node * node = voidptr;
+  Node * child;
+  assert (node->state == SPLIT);
+  child = newnode (node, -node->lookahead);
+  addint (&node->cube, node->lookahead);
+  cubemsg (node, "extended");
+  lgladd (node->lgl, node->lookahead);
+  lgladd (node->lgl, 0);
+  nmsg (node, "light simplification");
+  (void) lglsimp (node->lgl, 0);
+  if (reducecache) {
+    nmsg (child, "reducing cache");
+    lglreducecache (child->lgl);
+    lglreducecache (node->lgl);
+  }
+  nmsg (child, "light simplification");
+  (void) lglsimp (child->lgl, 0);
+  nmsg (node, "cloned and lightly simplified node and child");
+  child->simplified = node->simplified = 0;
+  decworkers ();
+  splitsuccessful = 1;
+  return node;
+}
+
+static void split () {
+  int i, tosplit = 0, found = 0;
+  Node * node;
+  LOG ("split");
+  startimer (&wct.split);
+  startphase ("split");
+  splitsuccessful = 0;
+  for (i = 0; i < numnodes; i++) {
+    node = nodes[i];
+    assert (node);
+    tosplit += (node->lookahead != 0);
+  }
+  msg (" %d splitting %d out of %d nodes %.0f%%", 
+    round, tosplit, numnodes, pcnt (tosplit, numnodes));
+  assert (!numjobs);
+  for (i = 0; i < numnodes; i++) {
+    node = nodes[i];
+    if (skipnode (node)) continue;
+    found++;
+    if (!node->lookahead) continue;
+    js.split++;
+    schedulejob (node, splitnode, "split", SPLIT);
+  }
+  vrb ("scheduled %d cloning jobs for %d / %d nodes in round %d",
+       numjobs, tosplit, found, round);
+  runjobs ();
+  joinjobs ();
+  stoptimer ();
+}
+
+/*------------------------------------------------------------------------*/
+
+static void varspan (int * minvarsptr, int * actvarsptr, int * maxvarsptr) {
+  int i, minvars, actvars, maxvars, j;
+  sortnodes ("varspan", incmpnodes);
+  for (i = 0; i < numnodes; i++)
+    if (!skipnode (nodes[i])) break;
+  minvars = (i < numnodes) ? lglnvars (nodes[i]->lgl) : 0;
+  for (i = numnodes-1; i >= 0; i--)
+    if (!skipnode (nodes[i])) break;
+  maxvars = (i < 0) ? 0 : lglnvars (nodes[i]->lgl);
+  j = 0;
+  for (i = 0; i < numnodes; i++)
+    if (!skipnode (nodes[i]) && ++j == maxactive)
+      break;
+  actvars = (j == maxactive) ? lglnvars (nodes[i]->lgl) : maxvars;
+  *minvarsptr = minvars;
+  *actvarsptr = actvars;
+  *maxvarsptr = maxvars;
+}
+
+static void report () {
+  int minvars, maxvars, actvars, isfull = nowfull ();
+  double t = getime (), m;
+  lockmem ();
+  m  = currentbytes/(double)(1<<20);
+  unlockmem ();
+  varspan (&minvars, &actvars, &maxvars);
+  msg ("%c%d %lld%c %.1f sec, "
+    "%.0f MB, %d nodes +%d -%d s%d, vars[%d..%d..%d]",
+    (isfull ? '[' : '('), round, (LL) ids, (isfull ? ']' : ')'), t, m,
+    numnodes, added, deleted, simplified, minvars, actvars, maxvars);
+}
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Opt { const char * name; int val; } Opt;
+
+static Opt lopts[] = {
+  { "restartint", 4 },
+  { "restartint", 1000 },
+  { "phase", -1 },
+};
+
+static const int nopts = sizeof lopts / sizeof *lopts;
+
+static unsigned long long hashtwo64 (unsigned long long a,
+                                     unsigned long long b) {
+  return 123369937ull * a + 4443739543 * b + 346961;
+}
+
+static void setopts (Node * node) {
+  unsigned long long r = hashtwo64 (node->id, round);
+  int def = !(r%2), newval, first;
+  LGL * lgl = node->lgl;
+  Opt * o;
+  lockopts ();
+  first = !opts.set++;
+  if (def) opts.def++;
+  unlockopts ();
+  if (first) {
+    msg ("");
+    msg ("using %d options for portfolio solving:", nopts);
+    msg ("");
+    for (o = lopts; o < lopts + nopts; o++)
+      msg ("  --%s=%d", o->name, o->val);
+    msg ("");
+  }
+  if (def) {
+    for (o = lopts; o < lopts + nopts; o++) {
+      newval = lgldefopt (lgl, o->name);
+      if (lglgetopt (lgl, o->name) == newval) continue;
+      nmsg (node,
+	"resetting option --%s=%d (default)",
+	o->name, newval);
+      lglsetopt (lgl, o->name, newval);
+    }
+  } else {
+    o = lopts + (r % nopts);
+    nmsg (node,
+      "setting option --%s=%d%s",
+      o->name, o->val, (def ? " (default)" : ""));
+    lglsetopt (lgl, o->name, o->val);
+    lglsetopt (lgl, "seed", def);
+  }
+}
+
+static void * searchnode (void * voidptr) {
+  Node * node = voidptr;
+  int64_t oldconfs = lglgetconfs (node->lgl), deltaconfs;
+  assert (!node->res);
+  assert (node->state == SEARCH);
+  if (portfolio) setopts (node);
+  nmsg (node, "search for %d conflicts", thisclim);
+  lglsetopt (node->lgl, "clim", thisclim);
+  node->res = lglsat (node->lgl);
+  node->simplified = 0;
+  nmsg (node, "search result %d", node->res);
+  if (node->res == 10) lockdone (), done = 10, unlockdone ();
+  decworkers ();
+  lockconfs ();
+  deltaconfs = lglgetconfs (node->lgl) - oldconfs;
+  PUSH (confstack, deltaconfs);
+  unlockconfs ();
+  return node;
+}
+
+static int cmpint64 (const void * p, const void * q) {
+  int64_t a = *(int64_t*) p, b = *(int64_t*) q;
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+static void search () {
+  int64_t avgconfs, medianconfs;
+  Node * node;
+  int i, l;
+  LOG ("search");
+  lockconfs ();			// TODO why?
+  numconfstack = 0;
+  if (eager &&
+      clim > minclim &&
+      numnodes < maxactive &&
+      (!softlimbytes || currentbytes < softlimbytes)) {
+    assert (minclim > 0);
+    forcedclim = minclim;
+    vrb (" %d forcing limit %d instead of %d", round, forcedclim, clim);
+  } else forcedclim = 0;
+  thisclim = forcedclim ? forcedclim : clim;
+  newclim = clim;
+  unlockconfs ();
+  if (nosearch) return;
+  startimer (&wct.search);
+  startphase ("search");
+  sortnodes ("search", incmpnodes);
+  l = maxactive;
+  if (nowfull ()) l *= FULLSEARCH;
+  if (l > numnodes) l = numnodes;
+  msg (" %d searching %d out of %d nodes %.0f%% limit %d%s",
+    round, l, numnodes, pcnt (l, numnodes), thisclim,
+    forcedclim ? " forced" : "");
+  for (i = 0; i < numnodes && numjobs < l; i++) {
+    node = nodes[i];
+    assert (node);
+    if (skipnode (node)) continue;
+    js.search++;
+    schedulejob (node, searchnode, "search", SEARCH);
+  }
+  vrb ("scheduled %d search jobs in round %d", numjobs, round);
+  runjobs ();
+  joinjobs ();
+  lockconfs ();			// TODO why?
+  assert (numconfstack >= 0);
+  if (numconfstack) {
+    avgconfs = 0;
+    for (i = 0; i < numconfstack; i++) avgconfs += confstack[i];
+    avgconfs = numconfstack ? avgconfs / numconfstack : 0;
+    qsort (confstack, numconfstack, sizeof *confstack, cmpint64);
+    medianconfs = confstack[numconfstack/2];
+    msg (" %d average actual conflicts %lld median %lld",
+      round, (LL) avgconfs, (LL) medianconfs);
+    newclim = medianconfs;
+  }
+  unlockconfs ();
+  stoptimer ();
+}
+
+/*------------------------------------------------------------------------*/
+
+static void updateclim () {
+  int oldclim = clim, delta;
+  assert (oldclim);
+  if (forcedclim) { forcedclim = 0; forcedclims++; goto DONE; }
+  assert (simplified <= deleted);
+  delta = deleted - simplified;
+  if (delta > added || !splitsuccessful) newclim *= 2;
+  else if (!delta) newclim /= 2;
+  else if (delta < added) newclim = (9*newclim)/10;
+  if (newclim < minclim) clim = minclim;
+  else if (newclim > maxclim) clim = maxclim;
+  else clim = newclim;
+  if (newclim < oldclim) declims++;
+  if (newclim > oldclim) inclims++;
+DONE:
+  if (oldclim != clim) vrb ("new conflict limit set to %d", clim);
+  else vrb ("conflict limit remains at %d", clim);
+  sumclims += clim;
+  added = deleted = simplified = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int flush () {
+  int i, before = numnodes, flushed, res;
+  Node * node;
+  i = 0; 
+  LOG ("flush");
+  while (i < numnodes) {
+    node = nodes[i];
+    assert (node);
+    assert (node->state == READY);
+    if (node->res == 20) enqnewleafromnode (node), delnode (node);
+    else if (lglinconsistent (node->lgl)) {
+      mmsg ("inconsistent", node);
+      enqnewleafromnode (node), delnode (node);
+    } else i++;
+  }
+  if ((flushed = before - numnodes)) vrb ("flushed %d nodes", flushed);
+  if (numnodes) {
+    res = 0;
+    vrb ("still %d nodes left", numnodes);
+  } else {
+    res = 20;
+    msg ("no more nodes left");
+    printf ("s UNSATISFIABLE\n");
+    fflush (stdout);
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void mergestats () {
+  Node * node;
+  int i;
+  for (i = 0; i < numnodes; i++) {
+    node = nodes[i];
+    assert (node);
+    assert (node->state != FREE);
+    if (node->lgl) updstats (node);
+  }
+  lockparstats ();
+  if (!noparallel && parallel.lgl) {
+    decisions += lglgetdecs (parallel.lgl) - parallel.decisions;
+    conflicts += lglgetconfs (parallel.lgl) - parallel.conflicts;
+    propagations += lglgetprops (parallel.lgl) - parallel.propagations;
+  }
+  unlockparstats ();
+}
+
+static void stats () {
+  double w = getime (), t = lglprocesstime ();
+  msg ("");
+  msg ("%d rounds, %lld nodes (%d max), %lld threads (%d max)", 
+       round, (LL) ids, maxnumnodes,
+       !noparallel + (LL) threads, maxnumworkers + !noparallel);
+  msg ("%.0f avg clim, %lld incs, %lld decs, %lld forced, %lld simp", 
+      avg (sumclims, inclims + declims + 1),
+      (LL) inclims, (LL) declims,
+      (LL) forcedclims, (LL) sumsimplified);
+  msg ("");
+  msg ("%.2f wall clock time, %.2f process time", w, t);
+  msg ("%.0f%% utilization for %d%s worker threads on %d cores",
+       pcnt (t, (maxworkers + !noparallel) * w), maxworkers,
+       (!noparallel ? " + 1" : ""), ncores);
+  msg ("");
+  if (!noparallel) {
+    msg ("started %d additional parallel solver instances", nparallel);
+    msg ("%lld units consumed %.0f%% of %lld produced",
+      (LL) parallel.consumed.units,
+      pcnt (parallel.consumed.units, parallel.produced.units),
+      (LL) parallel.produced.units);
+    msg ("%lld leaf clauses consumed %.0f%% of %lld produced",
+      (LL) parallel.consumed.leafs,
+      pcnt (parallel.consumed.leafs, parallel.produced.leafs),
+      (LL) parallel.produced.leafs);
+  }
+  msg ("");
+  msg ("%lld conflicts, %.0f conflicts per second", 
+       (LL) conflicts, avg (conflicts, w));
+  msg ("%lld decisions, %.0f decisions per second",
+       (LL) decisions, avg (decisions, w));
+  msg ("%lld propagations, %.1f million propagations per second",
+       (LL) propagations, avg (propagations/1e6, w));
+  msg ("");
+  msg ("%7d %3.0f%% lookaheads      %7.2f seconds %4.0f%%",
+    js.lkhd, pcnt (js.lkhd, js.cnt), wct.lkhd, pcnt (wct.lkhd,w));
+  msg ("%7d %3.0f%% splits          %7.2f seconds %4.0f%%",
+    js.split, pcnt (js.split, js.cnt), wct.split, pcnt (wct.split,w));
+  msg ("%7d %3.0f%% simplifications %7.2f seconds %4.0f%%",
+    js.simp, pcnt (js.simp, js.cnt), wct.simp, pcnt (wct.simp,w));
+  msg ("%7d %3.0f%% searches        %7.2f seconds %4.0f%%",
+    js.search, pcnt (js.search, js.cnt), wct.search, pcnt (wct.search,w));
+  msg ("======================================================");
+  msg ("%7d 100%% scheduled jobs  %7.2f seconds, %.0f MB",
+    js.cnt, w, maxbytes / (double)(1<<20));
+}
+
+/*------------------------------------------------------------------------*/
+
+static void parallelwins (int res) {
+  assert (!noparallel);
+  msg ("%s parallel solver instance wins with result %d after "
+       "%.2f seconds", nparallel == 1 ? "first" : "second", res, getime ());
+  if (res == 10) {
+    printf ("s SATISFIABLE\n");
+    if (!nowitness) {
+      fflush (stdout);
+      if (nparallel > 1) {
+	lgljoin (root, parallel.lgl);
+	witness (root);
+      } else witness (parallel.lgl);
+    }
+  } else if (res == 20) printf ("s UNSATISFIABLE\n");
+  else printf ("c s UNKNOWN\n"), abort ();		// TODO unreachable?
+  fflush (stdout);
+}
+
+static int finish () {
+  Node * node;
+  int i, res;
+  LOG ("finish");
+  if ((res = flush ())) return res;
+  for (i = 0; i < numnodes; i++) {
+    node = nodes[i];
+    assert (node);
+    assert (node->state == READY);
+    assert (node->lgl);
+    if (node->res == 10) break;
+  }
+  if (i < numnodes) {
+    vrb ("node %d sat", i);
+    res = 10;
+    node = nodes[i];
+    assert (node);
+    assert (node->res == 10);
+    msg ("winner [%d %lld] satisfiable in round %d "
+         "after %lld nodes and %.2f seconds",
+      node->depth, (LL) node->id, round, (LL) ids, getime ());
+    printf ("s SATISFIABLE\n");
+    if (!nowitness) {
+      fflush (stdout);
+      assert (node->lgl != root);
+      lgljoin (root, node->lgl);
+      witness (root);
+    }
+    fflush (stdout);
+  } else if (!noparallel) {
+    lockdone ();
+    res = parallel.res;
+    unlockdone ();
+    vrb ("no node result thus parallel result %d", res);
+    if (res) parallelwins (res);
+  } else {
+    assert (numnodes > 0);
+#ifndef NDEBUG
+    for (i = 0; i < numnodes; i++) {
+      node = nodes[i];
+      assert (node);
+      assert (node->state == READY);
+      assert (!node->res);
+      assert (node->lgl);
+      assert (!lglinconsistent (node->lgl));
+    }
+#endif
+    vrb ("no satisfiable node found but still %d nodes left in round %d", 
+	 numnodes, round);
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int catchedsig;
+
+static void (*sig_int_handler)(int);
+static void (*sig_segv_handler)(int);
+static void (*sig_abrt_handler)(int);
+static void (*sig_term_handler)(int);
+
+static void resetsighandlers () {
+  (void) signal (SIGINT, sig_int_handler);
+  (void) signal (SIGSEGV, sig_segv_handler);
+  (void) signal (SIGABRT, sig_abrt_handler);
+  (void) signal (SIGTERM, sig_term_handler);
+}
+
+static void caughtsigmsg (int sig) {
+  if (!verbose) return;
+  printf ("c\nc CAUGHT SIGNAL %d\nc\n", sig);
+  fflush (stdout);
+}
+
+static void catchsig (int sig) {
+  if (!catchedsig) {
+    fputs ("c s UNKNOWN\n", stdout);
+    fflush (stdout);
+    catchedsig = 1;
+    caughtsigmsg (sig);
+    mergestats ();
+    stats ();
+    caughtsigmsg (sig);
+  }
+  resetsighandlers ();
+  raise (sig);
+}
+
+static void setsighandlers () {
+  sig_int_handler = signal (SIGINT, catchsig);
+  sig_segv_handler = signal (SIGSEGV, catchsig);
+  sig_abrt_handler = signal (SIGABRT, catchsig);
+  sig_term_handler = signal (SIGTERM, catchsig);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void init () {
+  wct.epoch = currentime ();
+
+  pthread_mutex_init (&lock.confs.mutex, 0);
+  pthread_mutex_init (&lock.done.mutex, 0);
+  pthread_mutex_init (&lock.leafs.mutex, 0);
+  pthread_mutex_init (&lock.mem.mutex, 0);
+  pthread_mutex_init (&lock.msg.mutex, 0);
+  pthread_mutex_init (&lock.nodes.mutex, 0);
+  pthread_mutex_init (&lock.parleafs.mutex, 0);
+  pthread_mutex_init (&lock.parstats.mutex, 0);
+  pthread_mutex_init (&lock.parunits.mutex, 0);
+  pthread_mutex_init (&lock.simplified.mutex, 0);
+  pthread_mutex_init (&lock.stats.mutex, 0);
+  pthread_mutex_init (&lock.workers.mutex, 0);
+
+  pthread_cond_init (&workerscond, 0);
+}
+
+static int has (const char * str, const char * suffix) {
+  int l = strlen (str), k = strlen (suffix);
+  if (l < k) return 0;
+  return !strcmp (str + l - k, suffix);
+}
+
+static FILE * cmd (const char * fmt, const char * name) {
+  FILE * res;
+  char * s = malloc (strlen (fmt) + strlen (name) + 1);
+  sprintf (s, fmt, name);
+  res = popen (s, "r");
+  free (s);
+  return res;
+}
+
+static int parselopt (const char * arg, int * resptr, const char * opt) {
+  const char * p, * q;
+  if (arg[0] != '-' && arg[1] != '-') return 0;
+  p = arg + 2, q = opt;
+  while (*p == *q) p++, q++;
+  if (*q) return 0;
+  if (*p++ != '=') return 0;
+  if (*resptr) err ("multiple '--%s=...' options", opt);
+  if (!isnum (p))
+    err ("expected number as argument in '%s'", arg);
+  if ((*resptr = atoi (p)) <= 0) 
+    err ("expected positive number in '%s'", arg);
+  return 1;
+}
+
+#define U64_MAX ((~0ull)>>1)
+
+int parseu64 (const char * arg, const char * opt) {
+  unsigned long long res = 0;
+  const char * p = arg;
+  int ch;
+  ch = *p++;
+  if (!ch) err ("empty string argument to '%s'", opt);
+  res = ch - '0';
+  while (isdigit (ch = *p++)) {
+    int digit;
+    if (U64_MAX/10 < res)
+TOOLARGE:
+      err ("argument to '%s' too large", opt);
+    res *= 10;
+    assert (res > 0);
+    digit = ch - '0';
+    if (U64_MAX - digit < res) goto TOOLARGE;
+    res += digit;
+    assert (res > 0);
+  }
+  if (ch) err ("invalid unsigned 64 bit number in '%s %s'", opt, arg);
+  assert (res > 0);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+int main (int argc, char ** argv) {
+  unsigned long long seed = 0;
+  int i, res, tmp, clf;
+  Node * node;
+  Leaf * leaf;
+  double sec;
+  init ();
+  for (i = 1; i < argc; i++) {
+    if (!strcmp (argv[i], "-h")) usage ();
+    else if (!strcmp (argv[i], "--version")) version ();
+    else if (!strcmp (argv[i], "-v")) verbose++;
+    else if (!strcmp (argv[i], "-S")) showstats = 1;
+    else if (!strcmp (argv[i], "-n")) nowitness = 1;
+    else if (!strcmp (argv[i], "-O")) optimize = 1;
+    else if (argv[i][0] == '-' && argv[i][1] == 'O' && isnum (argv[i]+2)) {
+      if (optimize >= 0) err ("multiple '-O...' options");
+      if ((optimize = atoi (argv[i] + 2)) < 0)
+	err ("invalid number in '%s'", argv[i]);
+    } else if (!strcmp (argv[i], "--reduce")) reducecache = 1;
+    else if (!strcmp (argv[i], "--locslkhd")) locslkhd = 1;
+    else if (!strcmp (argv[i], "--force-simp")) forcesimp = 1;
+    else if (!strcmp (argv[i], "--no-force-lkhd")) forcelkhd = 0;
+    else if (!strcmp (argv[i], "--no-simp")) nosimp = 1;
+    else if (!strcmp (argv[i], "--no-search")) nosearch = 1;
+    else if (!strcmp (argv[i], "--no-parallel")) noparallel = 1;
+    else if (!strcmp (argv[i], "--no-full")) fullint = 0;
+    else if (!strcmp (argv[i], "-f")) {
+      if (++i == argc) err ("argument to '-f' missing");
+      if (!isnum (argv[i]) || (fullint = atoi (argv[i])) < 0)
+	err ("expected (non negative) number as argument in '-f %s'",
+	     argv[i]);
+    } else if (!strcmp (argv[i], "--balance")) balance = 1;
+    else if (!strcmp (argv[i], "--symmetric")) asymmetric = 0;
+    else if (!strcmp (argv[i], "--asymmetric")) asymmetric = 1;
+    else if (!strcmp (argv[i], "--portfolio")) portfolio = 1;
+    else if (!strcmp (argv[i], "--eager")) eager = 1;
+    else if (!strcmp (argv[i], "--lazy")) eager = 0;
+    else if (!strcmp (argv[i], "-m")) {
+      if (hardlimbytes) err ("multiple memory limit specification");
+      if (++i == argc) err ("argument to '-m' missing");
+      if (!isnum (argv[i]))
+	err ("expected number as argument in '-m %s'", argv[i]);
+      hardlimbytes = (size_t) atoll (argv[i]);
+      if (hardlimbytes > 0) hardlimbytes <<= 20;
+      if (hardlimbytes <= 0) err ("invalid number of MB in '-m %s'", argv[i]);
+    } else if (!strcmp (argv[i], "-g")) {
+      if (hardlimbytes) err ("multiple memory limit specification");
+      if (++i == argc) err ("argument to '-g' missing");
+      if (!isnum (argv[i]))
+	err ("expected number as argument in '-g %s'", argv[i]);
+      hardlimbytes = (size_t) atoll (argv[i]);
+      if (hardlimbytes > 0) hardlimbytes <<= 30;
+      if (hardlimbytes <= 0) err ("invalid number of GB in '-g %s'", argv[i]);
+    } else if (!strcmp (argv[i], "-t")) {
+      if (maxworkers > 0) err ("multiple '-t <workers>' options");
+      if (maxworkers2 > 0) err ("both '-t <workers>' and '<workers>'");
+      if (++i == argc) err ("argument to '-t' missing");
+      if (!isnum (argv[i]))
+	err ("expected number as argument in '-t %s'", argv[i]);
+      if ((maxworkers = atoi (argv[i])) <= 0) 
+	err ("expected positive number in '-t %s'", argv[i]);
+    } else if (!strcmp (argv[i], "-a")) {
+      if (maxactive > 0) err ("multiple '-a <nodes>' options");
+      if (++i == argc) err ("argument to '-a' missing");
+      if (!isnum (argv[i]))
+	err ("expected number as argument in '-a %s'", argv[i]);
+      if ((maxactive = atoi (argv[i])) <= 0) 
+	err ("expected positive number in '-a %s'", argv[i]);
+    } else if (!strcmp (argv[i], "-b")) {
+      if (branches >= 0) err ("multiple '-b <branches>' options");
+      if (++i == argc) err ("argument to '-b' missing");
+      if (!isnum (argv[i]))
+	err ("expected number as argument in '-b %s'", argv[i]);
+      if ((branches = atoi (argv[i])) <= 0) 
+	err ("expected positive number in '-b %s'", argv[i]);
+      if (branches > 100)
+	err ("expected number not larger than 100 in '-b %s'", argv[i]);
+    } else if (!strcmp (argv[i], "-r")) {
+      if (randswap > 0) err ("multiple '-r <posnum>' options");
+      if (++i == argc) err ("argument to '-r' missing");
+      if (!isnum (argv[i]))
+	err ("expected number as argument in '-r %s'", argv[i]);
+      if ((randswap = atoi (argv[i])) <= 0) 
+	err ("expected positive number in '-r %s'", argv[i]);
+    } else if (!strcmp (argv[i], "-s")) {
+      if (++i == argc) err ("argument to '-s' missing (try '-h')");
+      seed = parseu64 (argv[i], "-s");
+    } else if (parselopt (argv[i], &minclim, "min")) ;
+    else if (parselopt (argv[i], &initclim, "init")) ;
+    else if (parselopt (argv[i], &maxclim, "max")) ;
+    else if (*argv[i] == '-')
+      err ("invalid command line option '%s' (try '-h')", argv[i]);
+    else if (!fname && isnum (argv[i]))
+      err ("<file> file name can not be a positive number '%s'", argv[i]);
+    else if (fname && maxworkers2)
+      err ("too many arguments (including <file> and <workers>)");
+    else if (fname && !isnum (argv[i]))
+      err ("expected positive number for <workers> but got '%s'", argv[i]);
+    else if (fname) {
+      if ((maxworkers2 = atoi (argv[i])) <= 0)
+	err ("invalid number '%s' for <workers>", argv[i]);
+    } else if (!exists (argv[i])) err ("can not stat file '%s'", argv[i]);
+    else fname = argv[i];
+  }
+  if (maxworkers2) assert (!maxworkers), maxworkers = maxworkers2;
+  if (!fname) file = stdin, fname = "<stdin>", clf = 0;
+  else if (has (fname, ".gz")) file = cmd ("gunzip -c %s", fname), clf = 2;
+  else if (has (fname, ".xz")) file = cmd ("xz -d -c %s", fname), clf = 2;
+  else if (has (fname, ".bz2")) file = cmd ("bzcat %s", fname), clf = 2;
+  else if (has (fname, ".7z"))
+    file = cmd ("7z x -so %s 2>/dev/null", fname), clf = 2;
+  else file = fopen (fname, "r"), clf = 1;
+  if (!file) err ("can not read '%s'", fname);
+  lglbnr ("Treengeling Cube and Conquer SAT Solver", "c ", stdout);
+  msg ("verbose level %d", verbose);
+  msg ("will %sprint statistics for each solver instance",
+       showstats ? "" : "NOT ");
+  msg ("will %sprint satisfying assignment", nowitness ? "NOT " : "");
+  msg ("");
+  if (balance) msg ("splitting large nodes first ('-b' option)");
+  else msg ("splitting small nodes first (no '-b' option)");
+  if (asymmetric) msg ("asymmetric splitting ('--asymmetric')");
+  else msg ("symmetric splitting ('--symmetric')");
+  if (portfolio) msg ("portfolio option fuzzing enabled ('--portfolio'");
+  else msg ("portfolio option fuzzing disabled (no '--portfolio' option)");
+  if (fullint) msg ("full search/simplification round interval %d", fullint);
+  else msg ("no full search/simplification");
+
+  if (randswap) {
+    msg ("will swap %d nodes randomly during lookahead", randswap);
+    msg ("random seed %llu", (unsigned long long) seed);
+    mysrand (seed);
+  } else msg ("no randomization in lookahead");
+
+  msg ("");
+  ncores = getcores (1);
+
+  if (!maxworkers) {
+   maxworkers = CORES2WORKERS (ncores);
+   msg ("maximum %d workers (no '-t <worker>' option)", maxworkers);
+  } else if (maxworkers2)
+    assert (maxworkers2 == maxworkers),
+    msg ("maximum %d workers as specified ('%d')", maxworkers, maxworkers2);
+  else
+    msg ("maximum %d workers as specified ('-t %d')", maxworkers, maxworkers);
+
+  if (noparallel)
+    msg ("not using additional parallel solver instances ('--no-parallel')");
+  else if (maxworkers == 1) {
+    msg ("not using additional parallel solver instances ('-t 1')");
+    noparallel = 1;
+  } else {
+    msg ("using one worker for additional parallel solver instance");
+    maxworkers--;
+  }
+
+  if (!maxactive) {
+    maxactive = WORKERS2ACTIVE (maxworkers);
+    msg ("maximum of %d active nodes (no '-a <nodes>' option)", 
+         maxactive, maxactive);
+  } else 
+    msg ("maximum of %d active nodes as specified ('-a %d')",
+	 maxactive, maxactive);
+
+  if (branches >= 0) {
+    msg ("ratio of split nodes is %d%% as specified ('-b %d')",
+         branches, branches);
+  } else
+    msg ("default ratio of split nodes is %d%%", branches = DEFBRANCHES);
+
+  msg ("");
+  if (!hardlimbytes)  {
+    hardlimbytes = getotalmem (1);
+    msg ("hard memory limit of %d MB (no '-g' nor '-m' option)",
+         bytes2mb (hardlimbytes));
+  } else msg ("hard memory limit %d MB as specified", bytes2mb (hardlimbytes));
+  softlimbytes = (hardlimbytes + 2)/3;
+  msg ("soft memory limit of %d MB", bytes2mb (softlimbytes));
+
+  msg ("");
+  if (!minclim) {
+    minclim = MINCLIM;
+    msg ("default minimum conflict limit of %d conflicts", minclim);
+  } else
+    msg ("minimum conflict limit set to %d ('--min=%d')", minclim, minclim);
+
+  if (!initclim) {
+    initclim = INITCLIM;
+    msg ("default initial conflict limit of %d conflicts", initclim);
+  } else
+    msg ("initial conflict limit set to %d ('--init=%d')", 
+         initclim, initclim);
+
+  if (!maxclim) {
+    maxclim = MAXCLIM;
+    msg ("default maximum conflict limit of %d conflicts", maxclim);
+  } else
+    msg ("maximum conflict limit set to %d ('--max=%d')", maxclim, maxclim);
+
+  msg ("");
+  if (optimize < 0) {
+    optimize = OPTIMIZE;
+    msg ("default optimization level %d", optimize);
+  } else
+    msg ("optimization level %d as specified ('-O%d')", optimize, optimize);
+
+  msg ("");
+  setsighandlers ();
+
+  initroot ();
+
+  msg ("reading %s", fname);
+  parse (root);
+  if (clf == 1) fclose (file);
+  if (clf == 2) pclose (file);
+
+  if (!noparallel) startparallel (root);
+
+  msg ("simplifying root solver instance with optimization level %d", optimize);
+  startimer (&wct.simp);
+  res = lglsimp (root, optimize);
+  sec = stoptimer ();
+  js.cnt++, js.simp++;
+  propagations += lglgetprops (root);
+  assert (!lglgetdecs (root));
+  assert (!lglgetconfs (root));
+  msg ("root solver instance optimization with result %d took %.2f seconds",
+    res, sec);
+
+  tmp = 0;
+  if (!noparallel) {
+    tmp = joinparallel ();
+    if (!res && tmp) parallelwins (tmp);
+    releaseparallel ();
+  }
+
+  if (!res && tmp) res = tmp;
+  else if (res == 10) {
+    printf ("s SATISFIABLE\n");
+    if (!nowitness) fflush (stdout), witness (root);
+    fflush (stdout);
+  } else if (res == 20) {
+    printf ("s UNSATISFIABLE\n");
+    fflush (stdout);
+  } else {
+    assert (!res);
+    node = newnode (0, 0);
+    if (!noparallel) startparallel (node->lgl);
+    lglsetopt (node->lgl, "block", 0);
+
+    clim = initclim;
+    sumclims += clim;
+
+    report ();
+    if (!(res = flush ())) {
+      search ();
+      while (!(res = finish ())) {
+	incround ();
+	simp ();
+	if ((res = flush ())) break;
+	lookahead ();
+	split ();
+	if ((res = flush ())) break;
+	report ();
+	updateclim ();
+	search ();
+      }
+    }
+
+    if (!noparallel) joinparallel (), releaseparallel ();
+
+    msg ("");
+    msg ("cleaning up after %d rounds", round);
+    while (numnodes) delnode (nodes[0]);
+    while ((leaf = deqleaf ())) deleaf (leaf);
+  }
+
+  lglrelease (root);
+  resetsighandlers ();
+
+  stats ();
+  DEL (jobs, sizejobs);
+  DEL (nodes, sizenodes);
+  DEL (confstack, sizeconfstack);
+  msg ("");
+  msg ("result %d", res);
+
+  return res;
+}