diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..e9225ac
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,8 @@
+.vscode/
+__pycache__/
+*.a
+*.o
+makefile
+config.h
+xnfsat
+xnfsat_parallel
diff --git a/FILES b/FILES
new file mode 100644
index 0000000..9c94b2b
--- /dev/null
+++ b/FILES
@@ -0,0 +1,13 @@
+xnfsat          executable SAT solver
+xnfsat_parallel executable SAT solver simple portfolio version
+main.c          front-end, e.g. dimacs parser, connects to library
+libyals.a       actual library 
+yals.h          library include file
+yals.c          library implementation
+yils.h          internal API calls
+config.c        prints banner (includes configuration)
+config.h        automatically generated from './mkconfig.sh'
+makefile        instantiated from 'makfile.in' by './configure.sh'
+configure.sh    configure script (try './configure -h')
+mkconfig.sh     prints version and compile time information
+makefile.in     makefile template
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..df5b865
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2021
+Armin Biere, Johannes Kepler University
+Andreas Fröhlich
+Marijn Heule
+Lilian Liu
+Wojciech Nawrocki
+
+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..8dd748b
--- /dev/null
+++ b/README
@@ -0,0 +1,10 @@
+xnfSAT
+
+This is an SLS solver with XOR constraint support based on YalSAT.
+
+To build, run './configure.sh && make'. See also './configure.sh -h',
+particularly the usage of './configure.sh -g' to compile a version
+with debugging, checking and logging support.
+
+This will build both the library 'libyals.a' with its API in file 'yals.h'
+and the stand-alone SAT solver 'xnfsat'.
diff --git a/VERSION b/VERSION
new file mode 100644
index 0000000..48b92b9
--- /dev/null
+++ b/VERSION
@@ -0,0 +1 @@
+03v-xnfsat-fixed
diff --git a/cflags.h b/cflags.h
new file mode 100644
index 0000000..19126f8
--- /dev/null
+++ b/cflags.h
@@ -0,0 +1,2 @@
+#define YALS_CC "gcc (GCC) 10.2.0"
+#define YALS_CFLAGS "-Wall -Wextra -DNDEBUG -O3"
diff --git a/cnf2xnf/.gitignore b/cnf2xnf/.gitignore
new file mode 100644
index 0000000..ad3dd12
--- /dev/null
+++ b/cnf2xnf/.gitignore
@@ -0,0 +1,9 @@
+cnf2xnf
+xnf2cnf3
+xnf2cnf4
+xnf2cnf5
+xnf2cnf6
+xnf2cnf7
+xnf2cnf8
+extor
+makefile
diff --git a/cnf2xnf/README.md b/cnf2xnf/README.md
new file mode 100644
index 0000000..b436be9
--- /dev/null
+++ b/cnf2xnf/README.md
@@ -0,0 +1,14 @@
+This is a CNF to XNF extractor. To build, try
+
+    ./configure && make
+
+or even
+
+    ./configure && make test
+
+You can then for instance extract a CNF with cutting number 4 through
+
+    ./cnf2xnf4 cnfs/xor1.cnf cnfs/xor1.xnf
+
+Armin Biere
+Februrary 2021
diff --git a/cnf2xnf/cnf2xnf.c b/cnf2xnf/cnf2xnf.c
new file mode 100644
index 0000000..b8da9ee
--- /dev/null
+++ b/cnf2xnf/cnf2xnf.c
@@ -0,0 +1,1267 @@
+// Copyright (2021) Armin Biere, JKU LInz.
+
+#define VERSION "0.3"
+
+// *INDENT-OFF*
+
+static const char * usage =
+"usage: cnf2xnf [ <option> ... ] [ <input> [ <output> [ <extension> ] ] ]\n"
+"\n"
+"The '<option>' argument is one of the following:\n"
+"\n"
+"  --version        print version and exit\n"
+"  -h | --help      print this command line option summary\n"
+#ifndef LOGGING
+"  -q | --quiet     do not print verbose message\n"
+#endif
+"  -n | --no-write  dry run only\n"
+"\n"
+"  --no-compact     do not compact variable range\n"
+"  --no-eliminate   do not eliminate variables occurring in XORs only\n"
+"  --no-gates       do not extract gates\n"
+"\n"
+"The input CNF in DIMACS format is specified as '<input-cnf>' and\n"
+"the output file in XNF (CNF+XOR) format as '<output-xnf>'.  If these\n"
+"are missing we read from '<stdin>' and write from '<stdout>'.  You can\n"
+"also use the file '-' to force this.  Further if the file path is given\n"
+"and it has a suffix '.xz', '.gz' or '.bz2' then the file is assumed to\n"
+"be compressed and either compressed or decompressed with corresponding\n"
+"compression utilities 'xz', 'gunzip', and 'bunzip2'.\n";
+
+// *INDENT-ON*
+
+#include <assert.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+struct constraint
+{
+  bool garbage;
+  bool parity;
+  bool xor;
+  int size;
+  int literals[];
+};
+
+struct constraints
+{
+  struct constraint **begin, **end, **allocated;
+};
+
+struct literals
+{
+  int *begin, *end, *allocated;
+};
+
+#define SWAP(A,B) \
+do { \
+  typeof(A) TMP = (A); \
+  (A) = (B); \
+  (B) = TMP; \
+} while (0)
+
+#define SIZE(S) ((int)((S).end - (S).begin))
+#define FULL(S) ((S).end == (S).allocated)
+#define EMPTY(S) ((S).begin == (S).end)
+#define CLEAR(S) do { (S).end = (S).begin; } while (0)
+
+#define RESET(S,N) \
+do { \
+  assert ((N) <= SIZE (S) ); \
+  (S).end = (S).begin + (N); \
+} while (0)
+
+#define ENLARGE(S) \
+do { \
+  assert (FULL (S)); \
+  size_t OLD_SIZE = SIZE (S); \
+  size_t NEW_SIZE = OLD_SIZE ? 2*OLD_SIZE : 1; \
+  size_t NEW_BYTES = NEW_SIZE * sizeof *(S).begin; \
+  (S).begin = realloc ((S).begin, NEW_BYTES); \
+  if (!(S).begin) \
+    out_of_memory (); \
+  (S).end = (S).begin + OLD_SIZE; \
+  (S).allocated = (S).begin + NEW_SIZE; \
+} while (0)
+
+#define PUSH(S,E) \
+do { \
+  if (FULL (S)) \
+    ENLARGE (S); \
+  *(S).end++ = (E); \
+} while (0)
+
+#define REMOVE(S,E) \
+do { \
+  typeof ((S).begin) P = (S).begin, END = (S).end; \
+  while (assert (P != END), *P != (E)) \
+    P++; \
+  while (++P != END) \
+    P[-1] = P[0]; \
+  (S).end = P - 1; \
+} while (0)
+
+#define POP(S) \
+  (assert (!EMPTY (S)), *--(S).end)
+
+#define all_literals_in_constraint(L,C) \
+  int L, * L ## _PTR = (C)->literals, \
+         * L ## _END = L ## _PTR + (C)->size; \
+  (L ## _PTR != L ## _END) && (L = *L ## _PTR, true); \
+  ++L ## _PTR
+
+#define all_stack(T,E,S) \
+  T E, * E ## _PTR = (S).begin, * E ## _END = (S).end; \
+  (E ## _PTR != E ## _END) && (E = *E ## _PTR, true); \
+  ++E ## _PTR
+
+#define all_constraints(C,CS) \
+  struct constraint * C, ** C ## _PTR = (CS).begin, ** C ## _END = (CS).end; \
+  (C ## _PTR != C ## _END) && (C = *C ## _PTR, true); \
+  ++C ## _PTR
+
+#define all_literals(L) \
+  int L = -vars; L <= vars; L++
+
+#define all_variables(I) \
+  int I = 1; I <= vars; I++ 
+
+static int vars;
+static int mapped;
+static int reduced;
+static signed char *mark;
+static signed char *clausal;
+static struct literals literals;
+static struct literals schedule;
+static struct constraints xors;
+static struct constraints clauses;
+static struct constraints *occs;
+static struct constraints collect;
+static int original;
+static int * map;
+
+#ifndef LOGGING
+static bool quiet;
+#endif
+static bool extract_gates = true;
+static bool eliminate_xors = true;
+static bool compact_variables = true;
+
+static const char *do_not_write_output;
+
+static FILE *input_file;
+static FILE *output_file;
+static FILE *extend_file;
+static const char *input_path;
+static const char *output_path;
+static const char *extend_path;
+static int close_input;
+static int close_output;
+static int close_extend;
+
+static bool inconsistent;
+static int trivial;
+static int eliminated;
+static int substituted;
+static int extracted;
+static int equivalences;
+static int direct;
+static int gates;
+static int kept;
+
+static double
+percent (double a, double b)
+{
+  return b ? 100.0 * a / b : 0;
+}
+
+#include <sys/time.h>
+#include <sys/resource.h>
+
+static double
+timevoid (void)
+{
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  double 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 started = 0;
+
+static void
+start (void)
+{
+  started = timevoid ();
+}
+
+static double
+stop (void)
+{
+  return timevoid () - started;
+}
+
+static void die (const char *, ...) __attribute__((format (printf, 1, 2)));
+static void msg (const char *, ...) __attribute__((format (printf, 1, 2)));
+
+#ifdef LOGGING
+static void logging (const char *, ...)
+  __attribute__((format (printf, 1, 2)));
+static void logxor (struct constraint *, const char *, ...)
+  __attribute__((format (printf, 2, 3)));
+#endif
+
+static void
+die (const char *fmt, ...)
+{
+  fputs ("cnf2xnf: error: ", stderr);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  exit (1);
+}
+
+static void
+out_of_memory (void)
+{
+  die ("out-of-memory");
+}
+
+static void
+msg (const char *fmt, ...)
+{
+#ifndef LOGGING
+  if (quiet)
+    return;
+#endif
+  fputs ("c ", stdout);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stdout, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#ifdef LOGGING
+
+static void
+logging (const char *fmt, ...)
+{
+  fputs ("c LOG ", stdout);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stdout, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+static void
+logxor (struct constraint *x, const char *fmt, ...)
+{
+  fputs ("c LOG ", stdout);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stdout, fmt, ap);
+  va_end (ap);
+  printf (" size %d XOR", x->size);
+  bool first = true;
+  for (all_literals_in_constraint (idx, x))
+    printf ("%s%d", first ? " " : " + ", idx), first = false;
+  printf (" = %d\n", x->parity);
+  fflush (stdout);
+}
+
+#define LOG(...) do { logging(__VA_ARGS__); } while (0)
+#define LOGXOR(...) do { logxor(__VA_ARGS__); } while (0)
+
+#else
+
+#define LOG(...) do { } while (0)
+#define LOGXOR(...) do { } while (0)
+
+#endif
+
+static struct constraint *
+new_constraint (bool xor, bool parity, int size, int *literals)
+{
+  size_t header_bytes = sizeof (struct constraint);
+  size_t literals_bytes = size * sizeof (int);
+  struct constraint *res = malloc (header_bytes + literals_bytes);
+  if (!res)
+    out_of_memory ();
+  res->garbage = false;
+  res->xor = xor;
+  res->parity = parity;
+  res->size = size;
+  memcpy (res->literals, literals, literals_bytes);
+  return res;
+}
+
+static struct constraint *
+new_clause (int size, int *literals)
+{
+  return new_constraint (false, false, size, literals);
+}
+
+static struct constraint *
+new_xor (bool parity, int size, int *literals)
+{
+  return new_constraint (true, parity, size, literals);
+}
+
+static void
+connect_literal (int lit, struct constraint *c)
+{
+  PUSH (occs[lit], c);
+}
+
+static void
+disconnect_literal (int idx, struct constraint * c)
+{
+  struct constraints * cs = occs + idx;
+  REMOVE (*cs, c);
+}
+
+static void
+connect_constraint (struct constraint *c)
+{
+  for (all_literals_in_constraint (lit, c))
+    connect_literal (lit, c);
+}
+
+static void
+disconnect_constraint (struct constraint * c, int except)
+{
+  for (all_literals_in_constraint (lit, c))
+    if (lit != except)
+      disconnect_literal (lit, c);
+}
+
+static void
+parse (void)
+{
+  start ();
+  msg ("reading '%s'", input_path);
+
+  {
+    int ch = getc (input_file);
+    while ((ch == 'c'))
+      {
+	while ((ch = getc (input_file)) != '\n')
+	  if (ch == EOF)
+	    die ("unexpected end-of-file");
+	ch = getc (input_file);
+      }
+    ungetc (ch, input_file);
+  }
+
+  if (fscanf (input_file, "p cnf %d %d", &vars, &original) != 2 ||
+      vars < 0 || vars == INT_MAX || original < 0)
+    die ("invalid header");
+  msg ("parsed 'p cnf %d %d' header", vars, original);
+
+  occs = calloc (2u * vars + 1, sizeof *occs);
+  if (!occs)
+    out_of_memory ();
+  occs += vars;
+
+  map = calloc (2u * vars + 1, sizeof *map);
+  if (!map)
+    out_of_memory ();
+  map += vars;
+
+  mark = calloc ((vars + 1u), sizeof *mark);
+  if (!mark)
+    out_of_memory ();
+
+  clausal = calloc ((vars + 1u), sizeof *mark);
+  if (!clausal)
+    out_of_memory ();
+
+  int lit = 0, parsed = 0;
+  while (fscanf (input_file, "%d", &lit) == 1)
+    {
+      if (lit == INT_MIN || abs (lit) > vars)
+	die ("invalid literal '%d'", lit);
+      if (parsed == original)
+	die ("too many clauses");
+      if (lit)
+	PUSH (literals, lit);
+      else
+	{
+	  parsed++;
+	  size_t size = SIZE (literals);
+	  struct constraint *c = new_clause (size, literals.begin);
+	  connect_constraint (c);
+	  PUSH (clauses, c);
+	  CLEAR (literals);
+	}
+    }
+  if (lit)
+    die ("zero missing");
+  if (parsed != original)
+    die ("clause missing");
+  if (close_input == 1)
+    fclose (input_file);
+  if (close_input == 2)
+    pclose (input_file);
+  msg ("parsed %d clauses in %.2f seconds", parsed, stop ());
+}
+
+static bool
+parity_of_word (unsigned signs)
+{
+  return __builtin_popcount (signs) & 1;
+}
+
+static void
+mark_garbage (struct constraint * c)
+{
+  assert (!c->garbage);
+  c->garbage = true;
+  if (c->xor)
+    return;
+  assert (kept > 0);
+  kept--;
+}
+
+static void
+weaken_constraint (struct constraint * c)
+{
+  assert (c->size > 0);
+  mark_garbage (c);
+  if (!extend_file)
+    return;
+  fputc (c->xor ? 'x' : 'o', extend_file);
+  fputc (' ', extend_file);
+  if (c->xor && !c->parity)
+    fputc ('-', extend_file);
+  for (all_literals_in_constraint (lit, c))
+    fprintf (extend_file, "%d ", lit);
+  fputs ("0\n", extend_file);
+}
+
+static void
+make_pivot_first_literal (struct constraint * c, int pivot)
+{
+  int * begin = c->literals;
+#ifndef NDEBUG
+  const int * end = begin + c->size;
+#endif
+  int * p =  begin;
+  while (assert (p != end), *p != pivot)
+    p++;
+  if (p == begin)
+    return;
+  *p = begin[0];
+  begin[0] = pivot;
+}
+
+static void
+collect_constraint (struct constraint * c, int pivot)
+{
+  PUSH (collect, c);
+}
+
+static void
+extract_direct_encoding_from_base_clause (struct constraint *c)
+{
+  assert (!c->xor);
+  if (c->garbage)
+    return;
+  int size = c->size;
+  if (size < 2)
+    return;
+  if (size > 29)
+    return;
+  bool failed = false;
+  unsigned positive = 0;
+  int required = 1 << (size - 2);
+  assert (EMPTY (literals));
+  assert (EMPTY (collect));
+  for (all_literals_in_constraint (lit, c))
+    {
+      if (positive && lit > 0)
+	failed = true;
+      else
+	{
+	  int idx = abs (lit);
+	  if (mark[idx])
+	    failed = true;
+	  else if (SIZE (occs[lit]) < required)
+	    failed = true;
+	  else if (SIZE (occs[-lit]) < required)
+	    failed = true;
+	  else
+	    {
+	      PUSH (literals, idx);
+	      mark[idx] = 1;
+	      if (lit > 0)
+		positive++;
+	    }
+	}
+      if (failed)
+	break;
+    }
+  if (!failed)
+    {
+#ifdef LOGGING
+      printf ("c LOG potential base size %d clause", size);
+      for (all_literals_in_constraint (lit, c))
+	printf (" %d", lit);
+      printf ("\n");
+#endif
+      unsigned signs = positive;
+      do
+	{
+	  unsigned bit = 1;
+	  int min_lit = 0;
+	  int min_lit_occs = INT_MAX;
+	  for (all_stack (int, idx, literals))
+	    {
+	      int sign = (signs & bit) ? 1 : -1;
+	      int lit = sign * idx;
+	      int lit_occs = SIZE (occs[lit]);
+	      if (lit_occs < min_lit_occs)
+		{
+		  min_lit = lit;
+		  min_lit_occs = lit_occs;
+		}
+	      mark[idx] = sign;
+	      bit <<= 1;
+	    }
+	  assert (min_lit);
+	  assert (min_lit_occs < INT_MAX);
+	  assert (required <= min_lit_occs);
+
+	  bool found = false;
+	  for (all_constraints (d, occs[min_lit]))
+	    {
+	      if (d->size != size)
+		continue;
+	      found = true;
+	      for (all_literals_in_constraint (lit, d))
+		{
+		  int idx = abs (lit);
+		  int tmp = mark[idx];
+		  if (!tmp || (tmp > 0) != (lit > 0))
+		    {
+		      found = false;
+		      break;
+		    }
+		}
+	      if (found)
+		{
+#ifdef LOGGING
+		  printf ("c LOG matching size %d clause", size);
+		  for (all_literals_in_constraint (lit, d))
+		    printf (" %d", lit);
+		  printf ("\n");
+		  fflush (stdout);
+#endif
+		  collect_constraint (d, min_lit);
+		  break;
+		}
+	    }
+	  if (!found)
+	    {
+#ifdef LOGGING
+	      printf ("c LOG did not find matching size %d clause", size);
+	      for (all_stack (int, idx, literals))
+		{
+		  int sign = (signs & bit) ? 1 : -1;
+		  int lit = sign * idx;
+		  printf (" %d", lit);
+		}
+	      printf ("\n");
+	      fflush (stdout);
+#endif
+	      failed = true;
+	      break;
+	    }
+
+	  do
+	    signs++;
+	  while (parity_of_word (signs) != positive);
+	}
+      while (!failed && signs < (1 << size));
+    }
+  if (!failed)
+    {
+      const bool parity = !positive ^ (size & 1);
+      struct constraint *x = new_xor (parity, size, literals.begin);
+      LOGXOR (x, "new");
+      PUSH (xors, x);
+      extracted++;
+      if (size == 2)
+	equivalences++;
+      direct++;
+      assert (SIZE (collect) == (1 << (size - 1)));
+      for (all_constraints (d, collect))
+	if (!d->garbage)
+	  mark_garbage (d);
+    }
+  for (all_stack (int, idx, literals))
+      mark[idx] = 0;
+  CLEAR (literals);
+  CLEAR (collect);
+}
+
+static bool
+find_binary (int a, int b)
+{
+  for (all_constraints (c, occs[a]))
+    {
+      assert (!c->xor);
+      if (c->garbage)
+	continue;
+      if (c->size != 2)
+	continue;
+      int *lits = c->literals;
+      if (lits[0] != b && lits[1] != b)
+	continue;
+      collect_constraint (c, a);
+      return true;
+    }
+  return false;
+}
+
+static bool
+find_implications (int lhs, int rhs0, int rhs1)
+{
+  if (SIZE (occs[rhs0]) > SIZE (occs[rhs1]))
+    SWAP (rhs0, rhs1);
+  if (!find_binary (-lhs, rhs0))
+    return false;
+  if (!find_binary (-lhs, rhs1))
+    {
+      (void) POP (collect);
+      return false;
+    }
+  return true;
+}
+
+static bool
+find_ternary (int a, int b, int c)
+{
+  for (all_constraints (d, occs[a]))
+    {
+      if (d->garbage)
+	continue;
+      if (d->size != 3)
+	continue;
+      int *lits = d->literals;
+      if ((lits[0] == b || lits[1] == b || lits[2] == b) &&
+	  (lits[0] == c || lits[1] == c || lits[2] == c))
+	{
+	  collect_constraint (d, a);
+	  return true;
+	}
+    }
+  return false;
+}
+
+static bool
+find_and_gate (int a, int b, int c)
+{
+  if (!find_ternary (a, -b, -c))
+    return false;
+  if (find_implications (a, b, c))
+    return true;
+  (void) POP (collect);
+  return false;
+}
+
+static int gate[3];
+
+static bool
+find_xor_gate (int lhs, int rhs0, int rhs1)
+{
+  if (!find_binary (-lhs, rhs0))
+    return false;
+  if (!find_binary (-lhs, rhs1))
+    return false;
+  for (all_constraints (c, occs[-rhs0]))
+    {
+      assert (!c->xor);
+      if (c->garbage)
+	continue;
+      if (c->size != 3)
+	continue;
+      int saved = SIZE (collect);
+      int *lits = c->literals;
+      if (-rhs0 == lits[0] &&
+	  find_implications (-rhs0, -lits[1], -lits[2]) &&
+	  find_and_gate (-rhs1, lits[1], lits[2]))
+	{
+	  gate[0] = lhs;
+	  gate[1] = rhs0;
+	  gate[2] = rhs1;
+	  PUSH (literals, -lits[1]);
+	  PUSH (literals, -lits[2]);
+	  collect_constraint (c, -rhs0);
+	  return true;
+	}
+      RESET (collect, saved);
+    }
+  CLEAR (collect);
+  return false;
+}
+
+static void
+extract_aig_encoding_from_base_clause (struct constraint *c)
+{
+  assert (!c->xor);
+  if (c->garbage)
+    return;
+  if (c->size != 3)
+    return;
+  int *lits = c->literals;
+  if (find_xor_gate (lits[0], -lits[1], -lits[2]) ||
+      find_xor_gate (lits[1], -lits[0], -lits[2]) ||
+      find_xor_gate (lits[2], -lits[0], -lits[1]))
+    {
+      LOG ("matched AND gate base clause %d %d %d",
+	   lits[0], lits[1], lits[2]);
+      LOG ("top AND gate %d = %d & %d", gate[0], gate[1], gate[2]);
+      LOG ("2nd AND gate %d = %d & %d",
+	   -gate[1], literals.begin[0], literals.begin[1]);
+      LOG ("3rd AND gate %d = %d & %d",
+	   -gate[2], -literals.begin[0], -literals.begin[1]);
+      LOG ("found XOR gate %d = %d ^ %d",
+	   gate[0], literals.begin[0], literals.begin[1]);
+      if (SIZE (occs[gate[1]]) != 3)
+	LOG ("too many occurrences of %d", gate[1]);
+      else if (SIZE (occs[-gate[1]]) != 2)
+	LOG ("too many occurrences of %d", -gate[1]);
+      else if (SIZE (occs[gate[2]]) != 3)
+	LOG ("too many occurrences of %d", gate[2]);
+      else if (SIZE (occs[-gate[2]]) != 2)
+	LOG ("too many occurrences of %d", -gate[2]);
+      else
+	{
+	  LOG ("eliminating AND gate %d = %d & %d",
+	       -gate[1], literals.begin[0], literals.begin[1]);
+	  LOG ("eliminating AND gate %d = %d & %d",
+	       -gate[2], -literals.begin[0], -literals.begin[1]);
+	  collect_constraint (c, gate[0]);
+	  PUSH (literals, gate[0]);
+	  assert (SIZE (collect) == 9);
+	  assert (SIZE (literals) == 3);
+	  bool parity = 0;
+	  lits = literals.begin;
+	  SWAP (lits[0], lits[2]);
+	  SWAP (lits[1], lits[2]);
+	  for (int i = 0; i < 3; i++)
+	    {
+	      int lit = lits[i];
+	      if (lit < 0)
+		{
+		  lits[i] = -lit;
+		  parity = !parity;
+		}
+	    }
+	  struct constraint *x = new_xor (parity, 3, lits);
+	  LOGXOR (x, "new");
+	  PUSH (xors, x);
+	  extracted++;
+	  gates++;
+	  assert (SIZE (collect) == 9);
+	  {
+	    struct constraint ** cs = collect.begin;
+	    weaken_constraint (cs[7]);
+	    weaken_constraint (cs[2]);
+	    weaken_constraint (cs[3]);
+	    weaken_constraint (cs[4]);
+	    weaken_constraint (cs[5]);
+	    weaken_constraint (cs[6]);
+	    mark_garbage (cs[0]);
+	    mark_garbage (cs[1]);
+	    mark_garbage (cs[8]);
+	  }
+	}
+    }
+  CLEAR (collect);
+  CLEAR (literals);
+}
+
+static void
+extract (void)
+{
+  start ();
+  kept = SIZE (clauses);
+
+  for (all_constraints (c, clauses))
+    extract_direct_encoding_from_base_clause (c);
+  msg ("found %d directly encoded XORs", direct);
+
+  if (extract_gates)
+    {
+      for (all_constraints (c, clauses))
+	extract_aig_encoding_from_base_clause (c);
+      msg ("found %d gate encoded XORs", gates);
+    }
+
+  msg ("kept %d clauses %.0f%%", kept, percent (kept, original));
+  msg ("XORs/variable %.0f%%", percent (extracted, vars));
+  msg ("extracted %d XORs in %.2f seconds", extracted, stop ());
+  msg ("including %d equivalences (binary XORs) %.0f%%",
+       equivalences, percent (equivalences, extracted));
+}
+
+static int
+cmp_occs (const void * p, const void * q)
+{
+  const int a = * (int*) p, b = * (int *) q;
+  int res = SIZE (occs[b]) - SIZE (occs[a]);
+  if (res)
+    return res;
+  return b - a;
+}
+
+static void
+sort_schedule (void)
+{
+  qsort (schedule.begin, SIZE (schedule), sizeof (int), cmp_occs);
+}
+
+static void
+substitute (int pivot, struct constraint * c, struct constraint * d)
+{
+  LOGXOR (c, "substituting");
+  LOGXOR (d, "substituted");
+
+  for (all_literals_in_constraint (idx, c))
+    {
+      assert (!mark [idx]);
+      mark[idx] = 1;
+    }
+
+  for (all_literals_in_constraint (idx, d))
+    mark[idx]++;
+
+  assert (EMPTY (literals));
+  assert (mark[pivot] == 2);
+
+  for (all_literals_in_constraint (idx, c))
+    if (mark[idx] == 1)
+      PUSH (literals, idx);
+    else
+      assert (mark[idx] == 2);
+
+  for (all_literals_in_constraint (idx, d))
+    if (mark[idx] == 1)
+      PUSH (literals, idx);
+    else
+      assert (mark[idx] == 2);
+
+  {
+    const bool parity = c->parity ^ d->parity;
+    const int size = SIZE (literals);
+    if (size > 0)
+      {
+	struct constraint *x = new_xor (parity, size, literals.begin);
+	LOGXOR (x, "new");
+	PUSH (xors, x);
+	connect_constraint (x);
+      }
+    else if (parity)
+      {
+	assert (!inconsistent);
+	inconsistent = true;
+	msg ("derived inconsistent XOR constraint");
+      }
+    else
+      LOG ("substitution yields trivial XOR constraints");
+    CLEAR (literals);
+  }
+
+  for (all_literals_in_constraint (idx, c))
+    mark[idx] = 0;
+  for (all_literals_in_constraint (idx, d))
+    mark[idx] = 0;
+
+  LOGXOR (d, "disconnecting");
+  disconnect_constraint (d, pivot);
+
+  make_pivot_first_literal (d, pivot);
+  weaken_constraint (d);
+}
+
+static void
+eliminate_variable (int pivot)
+{
+  assert (!clausal[pivot]);
+
+  struct constraints * cs = occs + pivot;
+  if (EMPTY (*cs))
+    return;
+
+  LOG ("eliminating variable %d with %d occurrences", pivot, SIZE (*cs));
+  eliminated++;
+
+  struct constraint * c = 0;
+  for (all_constraints (d, *cs))
+    if (!c || c->size > d->size)
+      c = d;
+  assert (c);
+
+  for (all_constraints (d, *cs))
+    if (!inconsistent && c != d)
+      substitute (pivot, c, d);
+
+  disconnect_constraint (c, pivot);
+
+  make_pivot_first_literal (c, pivot);
+  weaken_constraint (c);
+
+  substituted++;
+
+  CLEAR (*cs);
+}
+
+static void
+eliminate (void)
+{
+  start ();
+
+  for (all_literals (lit))
+    CLEAR (occs[lit]);
+
+  for (all_constraints (c, clauses))
+    if (!c->garbage)
+      for (all_literals_in_constraint (lit, c))
+	clausal[abs (lit)] = 1;
+
+  for (all_constraints (c, xors))
+    {
+      assert (!c->garbage);
+      for (all_literals_in_constraint (lit, c))
+	PUSH (occs[abs (lit)], c);
+    }
+
+  for (all_variables (idx))
+    if (!clausal[idx] && !EMPTY (occs[idx]))
+      {
+	LOG ("scheduling %d with %d occurrences", idx, SIZE (occs[idx]));
+	PUSH (schedule, idx);
+      }
+
+  msg ("scheduled %d variable elimination candidates", SIZE (schedule));
+  sort_schedule ();
+
+  while (!EMPTY (schedule))
+    eliminate_variable (POP (schedule));
+
+  if (trivial)
+    msg ("substitution yielded %d trivial XORs", trivial);
+
+  msg ("eliminated %d variables in %.2f seconds", eliminated, stop ());
+}
+
+static void
+compact (void)
+{
+  if (compact_variables)
+    {
+      for (all_variables (idx))
+	assert (!mark[idx]);
+
+      for (all_constraints (c, clauses))
+	if (!c->garbage)
+	  for (all_literals_in_constraint (lit, c))
+	    mark[abs (lit)] = 1;
+
+      for (all_constraints (c, xors))
+	if (!c->garbage)
+	  for (all_literals_in_constraint (lit, c))
+	    mark[abs (lit)] = 1;
+
+      for (all_variables (idx))
+	if (mark[idx])
+	  {
+	    if (++reduced != idx)
+	      {
+		mapped++;
+		LOG ("mapping original variable %d to %d", idx, reduced);
+		if (extend_file)
+		  fprintf (extend_file, "x -%d %d 0\n", idx, reduced);
+	      }
+	    map[idx] = reduced;
+	    map[-idx] = -reduced;
+	  }
+
+      msg ("reduced %d original variables to %d variables %.0f%%",
+	   vars, reduced, percent (reduced, vars));
+      msg ("mapped %d variables of %d remaining variables %.0f%%",
+	   mapped, reduced, percent (mapped, reduced));
+    }
+  else
+    {
+      msg ("keeping original variable indices");
+      for (all_variables (idx))
+	map[idx] = ++reduced, map[-idx] = -reduced;
+    }
+}
+
+static const char *
+header (void)
+{
+  static char buffer[80];
+  sprintf (buffer, "p %cnf %d %d",
+	   extracted ? 'x' : 'c', reduced,
+	   kept + extracted - substituted - trivial);
+  return buffer;
+}
+
+static void
+write (void)
+{
+  start ();
+
+  msg ("writing %cNF to '%s'", extracted ? 'X' : 'C', output_path);
+
+  int wrote = 0;
+
+  if (inconsistent)
+    {
+      msg ("writing 'p cnf 0 1' header");
+      fputs ("p cnf 0 1\n0\n", output_file);
+      wrote = 1;
+    }
+  else
+    {
+      const char * h = header ();
+      msg ("writing '%s' header", h);
+      fputs (h, output_file);
+      fputc ('\n', output_file);
+
+      for (all_constraints (c, clauses))
+	if (!c->garbage)
+	  {
+	    assert (!c->xor);
+	    for (all_literals_in_constraint (lit, c))
+	      fprintf (output_file, "%d ", map[lit]);
+	    fputs ("0\n", output_file);
+	    wrote++;
+	  }
+
+      for (all_constraints (c, xors))
+	if (!c->garbage)
+	  {
+	    assert (c->xor);
+	    fputs ("x ", output_file);
+	    if (!c->parity)
+	      fputc ('-', output_file);
+	    for (all_literals_in_constraint (lit, c))
+	      fprintf (output_file, "%d ", map[lit]);
+	    fputs ("0\n", output_file);
+	    wrote++;
+	  }
+    }
+
+  if (close_output == 1)
+    fclose (output_file);
+  if (close_output == 2)
+    pclose (output_file);
+
+  msg ("wrote %d constraints in %.02f seconds", wrote, stop ());
+}
+
+static void
+release_constraints (struct constraints *cs)
+{
+  for (all_constraints (c, *cs))
+    free (c);
+  free (cs->begin);
+}
+
+static void
+reset (void)
+{
+  free (literals.begin);
+  free (collect.begin);
+  free (schedule.begin);
+
+  for (all_literals (lit))
+    free (occs[lit].begin);
+  occs -= vars;
+  free (occs);
+
+  map -= vars;
+  free (map);
+
+  free (mark);
+  free (clausal);
+
+  release_constraints (&clauses);
+  release_constraints (&xors);
+}
+
+static bool
+has_suffix (const char *str, const char *suffix)
+{
+  const size_t l = strlen (str), k = strlen (suffix);
+  return l >= k && !strcmp (str + l - k, suffix);
+}
+
+static void
+read_pipe (const char *fmt)
+{
+  char *cmd = malloc (strlen (fmt) + strlen (input_path));
+  if (!cmd)
+    out_of_memory ();
+  sprintf (cmd, fmt, input_path);
+  input_file = popen (cmd, "r");
+  close_input = 2;
+  free (cmd);
+}
+
+static FILE *
+write_pipe (const char *fmt)
+{
+  char *cmd = malloc (strlen (fmt) + strlen (output_path));
+  if (!cmd)
+    out_of_memory ();
+  sprintf (cmd, fmt, output_path);
+  FILE * file = popen (cmd, "w");
+  free (cmd);
+  return file;
+}
+
+int
+main (int argc, char **argv)
+{
+  for (int i = 1; i < argc; i++)
+    {
+      const char *arg = argv[i];
+      if (!strcmp (arg, "--version"))
+	fputs (VERSION "\n", stdout), exit (0);
+      else if (!strcmp (arg, "-h") || !strcmp (arg, "--help"))
+	fputs (usage, stdout), exit (0);
+#ifndef LOGGING
+      else if (!strcmp (arg, "-q") || !strcmp (arg, "--quiet"))
+	quiet = true;
+#endif
+      else if (!strcmp (arg, "-n") || !strcmp (arg, "--no-write"))
+	do_not_write_output = arg;
+      else if (!strcmp (arg, "--no-gates"))
+	extract_gates = false;
+      else if (!strcmp (arg, "--no-eliminate"))
+	eliminate_xors = false;
+      else if (!strcmp (arg, "--no-compact"))
+	compact_variables = false;
+      else if (arg[0] == '-' && arg[1])
+	die ("invalid option '%s' (try '-h')", arg);
+      else if (extend_path)
+	die ("too many files '%s', '%s' and '%s'",
+	     input_path, output_path, arg);
+      else if (output_path)
+        extend_path = arg;
+      else if (input_path)
+	output_path = arg;
+      else
+	input_path = arg;
+    }
+
+  if (output_path && do_not_write_output)
+    die ("can not use '%s' with output file '%s'",
+	 do_not_write_output, output_path);
+
+  if (input_path && output_path &&
+      !strcmp (input_path, output_path) && strcmp (input_path, "-"))
+    die ("identical input and output path '%s'", input_path);
+  if (input_path && extend_path &&
+      !strcmp (input_path, extend_path))
+    die ("identical input and extension path '%s'", input_path);
+  if (output_path && extend_path &&
+      !strcmp (output_path, extend_path))
+    die ("identical output and extension path '%s'", output_path);
+
+  if (!input_path || !strcmp (input_path, "-"))
+    input_path = "<stdin>", input_file = stdin, close_input = 0;
+  else if (has_suffix (input_path, ".gz"))
+    read_pipe ("gzip -c -d %s");
+  else if (has_suffix (input_path, ".bz2"))
+    read_pipe ("bzip2 -c -d %s");
+  else if (has_suffix (input_path, ".xz"))
+    read_pipe ("xz -c -d %s");
+  else
+    input_file = fopen (input_path, "r"), close_input = 1;
+  if (!input_file)
+    die ("can not read '%s'", input_path);
+
+  msg ("CNF2XNF XOR Extractor Version " VERSION);
+
+  parse ();
+
+  if (extend_path)
+    {
+      if (!strcmp (extend_path, "-"))
+	extend_path = "<stdout>", extend_file = stdout, close_extend = 0;
+      else if (has_suffix (extend_path, ".gz"))
+	extend_file = write_pipe ("gzip -c > %s"), close_extend = 2;
+      else if (has_suffix (extend_path, ".bz2"))
+	extend_file = write_pipe ("bzip2 -c > %s"), close_extend = 2;
+      else if (has_suffix (extend_path, ".xz"))
+	extend_file = write_pipe ("xz -c > %s"), close_extend = 2;
+      else
+	extend_file = fopen (extend_path, "w"), close_extend = 1;
+      if (!extend_file)
+	die ("can not write '%s'", extend_path);
+
+      msg ("writing extension stack to '%s'", extend_path);
+    }
+
+  extract ();
+  if (eliminate_xors && extracted)
+    eliminate ();
+
+  compact ();
+
+  if (extend_file)
+    {
+      if (close_extend == 1)
+	fclose (extend_file);
+      if (close_extend == 2)
+	pclose (extend_file);
+
+      msg ("closed extension file '%s'", extend_path);
+    }
+
+  if (!do_not_write_output)
+    {
+      if (!output_path || !strcmp (output_path, "-"))
+	output_path = "<stdout>", output_file = stdout, close_output = 0;
+      else if (has_suffix (output_path, ".gz"))
+	output_file = write_pipe ("gzip -c > %s"), close_output = 2;
+      else if (has_suffix (output_path, ".bz2"))
+	output_file = write_pipe ("bzip2 -c > %s"), close_output = 2;
+      else if (has_suffix (output_path, ".xz"))
+	output_file = write_pipe ("xz -c > %s"), close_output = 2;
+      else
+	output_file = fopen (output_path, "w"), close_output = 1;
+      if (!output_file)
+	die ("can not write '%s'", output_path);
+
+      write ();
+    }
+  else if (!inconsistent)
+    msg ("would write '%s'", header ());
+
+  reset ();
+
+  msg ("total running time of %.2f seconds", timevoid ());
+
+  return 0;
+}
diff --git a/cnf2xnf/cnfs/.gitignore b/cnf2xnf/cnfs/.gitignore
new file mode 100644
index 0000000..7d9ebaa
--- /dev/null
+++ b/cnf2xnf/cnfs/.gitignore
@@ -0,0 +1,3 @@
+*.xnf
+*.err
+*.log
diff --git a/cnf2xnf/cnfs/aig1.cnf b/cnf2xnf/cnfs/aig1.cnf
new file mode 100644
index 0000000..10ea88d
--- /dev/null
+++ b/cnf2xnf/cnfs/aig1.cnf
@@ -0,0 +1,10 @@
+p cnf 5 9
+-1 2 0
+-1 3 0
+1 -2 -3 0
+2 4 0
+2 5 0
+-2 -4 -5 0
+3 -4 0
+3 -5 0
+-3 4 5 0
diff --git a/cnf2xnf/cnfs/and1.cnf b/cnf2xnf/cnfs/and1.cnf
new file mode 100644
index 0000000..f29c42d
--- /dev/null
+++ b/cnf2xnf/cnfs/and1.cnf
@@ -0,0 +1,4 @@
+p cnf 3 3
+-1 2 0
+-1 3 0
+1 -2 -3 0
diff --git a/cnf2xnf/cnfs/false.cnf b/cnf2xnf/cnfs/false.cnf
new file mode 100644
index 0000000..1d89b30
--- /dev/null
+++ b/cnf2xnf/cnfs/false.cnf
@@ -0,0 +1,2 @@
+p cnf 0 1
+0
diff --git a/cnf2xnf/cnfs/missing1.cnf b/cnf2xnf/cnfs/missing1.cnf
new file mode 100644
index 0000000..d07f11e
--- /dev/null
+++ b/cnf2xnf/cnfs/missing1.cnf
@@ -0,0 +1,4 @@
+p cnf 3 3
+1 -2 -3 0
+-1 2 -3 0
+-1 -2 3 0
diff --git a/cnf2xnf/cnfs/missing2.cnf b/cnf2xnf/cnfs/missing2.cnf
new file mode 100644
index 0000000..13117a4
--- /dev/null
+++ b/cnf2xnf/cnfs/missing2.cnf
@@ -0,0 +1,5 @@
+p cnf 3 4
+1 2 3 0
+1 2 -3 0
+-1 2 -3 0
+-1 -2 3 0
diff --git a/cnf2xnf/cnfs/missing3.cnf b/cnf2xnf/cnfs/missing3.cnf
new file mode 100644
index 0000000..ca282d4
--- /dev/null
+++ b/cnf2xnf/cnfs/missing3.cnf
@@ -0,0 +1,9 @@
+p cnf 4 8
+1 2 3 4 0
+1 2 -3 -4 0
+1 2 3 -4 0
+-1 -2 -3 4 0
+-1 2 -3 4 0
+-1 2 3 -4 0
+-1 -2 3 4 0
+-1 -2 -3 -4 0
diff --git a/cnf2xnf/cnfs/mixed1.cnf b/cnf2xnf/cnfs/mixed1.cnf
new file mode 100644
index 0000000..e64e288
--- /dev/null
+++ b/cnf2xnf/cnfs/mixed1.cnf
@@ -0,0 +1,9 @@
+p cnf 5 8
+1 2 3 0
+1 -2 -3 0
+-1 -2 3 0
+-1 2 -3 0
+-3 -4 -5 0
+-3 4 5 0
+3 4 -5 0
+3 -4 -5 0
diff --git a/cnf2xnf/cnfs/mixed2.cnf b/cnf2xnf/cnfs/mixed2.cnf
new file mode 100644
index 0000000..52f3224
--- /dev/null
+++ b/cnf2xnf/cnfs/mixed2.cnf
@@ -0,0 +1,9 @@
+p cnf 5 8
+1 2 3 0
+1 -2 -3 0
+-1 2 3 0
+-1 2 -3 0
+-3 -4 -5 0
+-3 4 5 0
+3 4 -5 0
+3 -4 5 0
diff --git a/cnf2xnf/cnfs/regr1.cnf b/cnf2xnf/cnfs/regr1.cnf
new file mode 100644
index 0000000..56988f7
--- /dev/null
+++ b/cnf2xnf/cnfs/regr1.cnf
@@ -0,0 +1,8 @@
+p cnf 4 7
+1 2 0
+-3 1 0
+3 -1 0
+1 4 0
+-1 -4 0
+4 -2 0
+-4 2 0
diff --git a/cnf2xnf/cnfs/true.cnf b/cnf2xnf/cnfs/true.cnf
new file mode 100644
index 0000000..deab3c3
--- /dev/null
+++ b/cnf2xnf/cnfs/true.cnf
@@ -0,0 +1 @@
+p cnf 0 0
diff --git a/cnf2xnf/cnfs/unit1.cnf b/cnf2xnf/cnfs/unit1.cnf
new file mode 100644
index 0000000..7d5cc00
--- /dev/null
+++ b/cnf2xnf/cnfs/unit1.cnf
@@ -0,0 +1,7 @@
+p cnf 3 6
+1 -2 0
+-1 2 0
+-2 3 0
+2 -3 0
+-3 1 0
+3 -1 0
diff --git a/cnf2xnf/cnfs/unit3.cnf b/cnf2xnf/cnfs/unit3.cnf
new file mode 100644
index 0000000..e2d8dd7
--- /dev/null
+++ b/cnf2xnf/cnfs/unit3.cnf
@@ -0,0 +1,7 @@
+p cnf 3 6
+1 2 0
+-1 -2 0
+2 3 0
+-2 -3 0
+3 1 0
+-3 -1 0
diff --git a/cnf2xnf/cnfs/xor1.cnf b/cnf2xnf/cnfs/xor1.cnf
new file mode 100644
index 0000000..847ab01
--- /dev/null
+++ b/cnf2xnf/cnfs/xor1.cnf
@@ -0,0 +1,5 @@
+p cnf 3 4
+1 2 3 0
+1 -2 -3 0
+-1 2 -3 0
+-1 -2 3 0
diff --git a/cnf2xnf/cnfs/xor2.cnf b/cnf2xnf/cnfs/xor2.cnf
new file mode 100644
index 0000000..9c625c9
--- /dev/null
+++ b/cnf2xnf/cnfs/xor2.cnf
@@ -0,0 +1,5 @@
+p cnf 3 4
+-1 -3 2 0
+1 2 3 0
+-1 3 -2 0
+-2 1 -3 0
diff --git a/cnf2xnf/cnfs/xor3.cnf b/cnf2xnf/cnfs/xor3.cnf
new file mode 100644
index 0000000..82c1df5
--- /dev/null
+++ b/cnf2xnf/cnfs/xor3.cnf
@@ -0,0 +1,5 @@
+p cnf 3 4
+1 -3 2 0
+1 -2 3 0
+-1 3 2 0
+-2 -1 -3 0
diff --git a/cnf2xnf/cnfs/xor4.cnf b/cnf2xnf/cnfs/xor4.cnf
new file mode 100644
index 0000000..139748d
--- /dev/null
+++ b/cnf2xnf/cnfs/xor4.cnf
@@ -0,0 +1,9 @@
+p cnf 5 8
+1 2 3 0
+1 -2 -3 0
+-1 -2 3 0
+-1 2 -3 0
+-3 -4 -5 0
+-3 4 5 0
+3 4 -5 0
+3 -4 5 0
diff --git a/cnf2xnf/cnfs/xor5.cnf b/cnf2xnf/cnfs/xor5.cnf
new file mode 100644
index 0000000..df79d1e
--- /dev/null
+++ b/cnf2xnf/cnfs/xor5.cnf
@@ -0,0 +1,9 @@
+p cnf 4 8
+1 2 3 4 0
+1 2 -3 -4 0
+1 -2 3 -4 0
+1 -2 -3 4 0
+-1 2 -3 4 0
+-1 2 3 -4 0
+-1 -2 3 4 0
+-1 -2 -3 -4 0
diff --git a/cnf2xnf/configure b/cnf2xnf/configure
new file mode 100755
index 0000000..4644f1a
--- /dev/null
+++ b/cnf2xnf/configure
@@ -0,0 +1,34 @@
+#!/bin/sh
+usage () {
+cat<<EOF
+usage: configure [-g|--debug] [-h|--help] [-l|--log|--logging]
+EOF
+}
+die () {
+  echo "configure: error: $*" 1>&2
+}
+debug=no
+logging=no
+while [ $# -gt 0 ]
+do
+  case "$1" in
+    -h|--help) usage; exit 0;;
+    -g|--debug) debug=yes;;
+    -l|--log|--logging) logging=yes;;
+    -f*) options="$options $1";;
+    *) die "invalid option '$1' (try '-h')";;
+  esac
+  shift
+done
+COMPILE="gcc -Wall"
+if [ $debug = yes ]
+then
+  COMPILE="$COMPILE -ggdb3"
+else
+  COMPILE="$COMPILE -O3 -DNDEBUG"
+fi
+COMPILE="$COMPILE$options"
+[ $logging = yes ] && COMPILE="$COMPILE -DLOGGING"
+echo $COMPILE
+sed -e "s#@COMPILE@#$COMPILE#" makefile.in > makefile
+
diff --git a/cnf2xnf/extor.c b/cnf2xnf/extor.c
new file mode 100644
index 0000000..ba973bc
--- /dev/null
+++ b/cnf2xnf/extor.c
@@ -0,0 +1,580 @@
+// Copyright (2021) Armin Biere, JKU Linz.
+
+/*------------------------------------------------------------------------*/
+
+#define VERSION "0.0"
+
+// *INDENT-OFF*
+
+const char * usage = 
+"usage: extor [ <option> ... ] <extension> <witness>"
+"\n"
+"\nThe '<option>' argument is one of the following:\n"
+"\n"
+"  --version      print version and exit\n"
+"  -h | --help    print this command line option summary\n"
+"  -q | --quiet   do not print verbose message\n"
+"\n"
+""
+"The '<extension>' file is the reconstruction stack generated by\n"
+"'cnf2xor' if it is given a third file argument.  The '<witness>'\n"
+"file is expected to contain the output of a SAT solver following\n"
+"the SAT Competition format.  The tool will then parse the output\n"
+"and search for a 's SATISFIABLE' line and corresponding 'v ...'\n"
+"lines.  If no 's SATISFIABLE' line is found the tool simple exits\n"
+"after printing 's UNSATISFIABLE' if a such a line is found instead.\n"
+"Otherwise the 'v ...' lines are parsed and an assignment is extracted.\n"
+"This assignment is extended with the XNF extention stack in '<extension>'\n"
+"and printed also as 'v ...' lines to '<stdout>' after printing the\n"
+"'s SATISFIABLE'.  Accordingly the resulting output should be a witness\n"
+"for the original CNF.\n"
+;
+
+// *INDENT-ON*
+
+/*------------------------------------------------------------------------*/
+
+#include <assert.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/*------------------------------------------------------------------------*/
+
+#define SIZE(S) ((int)((S).end - (S).begin))
+#define FULL(S) ((S).end == (S).allocated)
+#define EMPTY(S) ((S).begin == (S).end)
+#define CLEAR(S) do { (S).end = (S).begin; } while (0)
+
+#define ENLARGE(S) \
+do { \
+  assert (FULL (S)); \
+  size_t OLD_SIZE = SIZE (S); \
+  size_t NEW_SIZE = OLD_SIZE ? 2*OLD_SIZE : 1; \
+  size_t NEW_BYTES = NEW_SIZE * sizeof *(S).begin; \
+  (S).begin = realloc ((S).begin, NEW_BYTES); \
+  if (!(S).begin) \
+    out_of_memory (); \
+  (S).end = (S).begin + OLD_SIZE; \
+  (S).allocated = (S).begin + NEW_SIZE; \
+} while (0)
+
+#define PUSH(S,E) \
+do { \
+  if (FULL (S)) \
+    ENLARGE (S); \
+  *(S).end++ = (E); \
+} while (0)
+
+#define all_literals(L,C) \
+  int L, * L ## _PTR = (C)->literals, \
+         * L ## _END = L ## _PTR + (C)->size; \
+  (L ## _PTR != L ## _END) && (L = *L ## _PTR, true); \
+  ++L ## _PTR
+
+#define all_constraints(C) \
+  struct constraint * C, ** C ## _PTR = (constraints).end, \
+                         ** C ## _BEGIN = (constraints).begin; \
+  (C ## _PTR-- != C ## _BEGIN) && (C = *C ## _PTR, true);
+
+/*------------------------------------------------------------------------*/
+
+struct literals
+{
+  int * begin, * end, * allocated;
+};
+
+struct constraint
+{
+  bool xor;
+  unsigned size:31;
+  int literals[];
+};
+
+struct constraints
+{
+  struct constraint ** begin, ** end, ** allocated;
+};
+
+/*------------------------------------------------------------------------*/
+
+static bool quiet;
+
+static const char * error_path;
+static const char * extension_path;
+static const char * witness_path;
+
+/*------------------------------------------------------------------------*/
+
+static FILE * extension_file;
+static FILE * witness_file;
+
+/*------------------------------------------------------------------------*/
+
+static int vars;
+static unsigned capacity;
+static signed char * values;
+static struct literals literals;
+static struct constraints constraints;
+
+/*------------------------------------------------------------------------*/
+
+static char buffer[80];
+static int size_buffer;
+
+/*------------------------------------------------------------------------*/
+
+static double
+percent (double a, double b)
+{
+  return b ? 100.0 * a / b : 0;
+}
+
+#include <sys/time.h>
+#include <sys/resource.h>
+
+static double
+timevoid (void)
+{
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  double 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 void die (const char *, ...) __attribute__((format (printf, 1, 2)));
+static void msg (const char *, ...) __attribute__((format (printf, 1, 2)));
+
+static void
+die (const char *fmt, ...)
+{
+  fputs ("extor: error: ", stderr);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  if (error_path)
+    fprintf (stderr, " in '%s'", error_path);
+  fputc ('\n', stderr);
+  exit (1);
+}
+
+static void
+out_of_memory (void)
+{
+  die ("out-of-memory");
+}
+
+static void
+msg (const char *fmt, ...)
+{
+  if (quiet)
+    return;
+  fputs ("c ", stdout);
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stdout, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void
+increase_capacity (unsigned new_vars)
+{
+  assert (0 < new_vars);
+  assert (new_vars < (1u<<30));
+  unsigned new_capacity = capacity ? 2u*capacity : 1;
+  while (new_capacity <= new_vars)
+    new_capacity *= 2;
+  const size_t bytes = 2u * new_capacity + 1;
+  signed char * new_values = malloc (bytes);
+  if (!new_values)
+    out_of_memory ();
+  memset (new_values, 1, new_capacity);
+  new_values += new_capacity;
+  memset (new_values, -1, new_capacity);
+  if (vars)
+    memcpy (new_values - vars, values - vars, 2u*vars + 1);
+  values -= capacity;
+  free (values);
+  values = new_values;
+  capacity = new_capacity;
+}
+
+static void
+increase_variables (int new_vars)
+{
+  assert (0 < new_vars);
+  if (new_vars < vars)
+    return;
+  if (new_vars >= capacity)
+    increase_capacity (new_vars);
+  vars = new_vars;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int
+next_char (FILE * file, size_t * lineno)
+{
+  int ch = getc (file);
+  if (ch == '\n')
+    *lineno += 1;
+  return ch;
+}
+
+static bool
+is_white_space (int ch)
+{
+  return ch == ' ' || ch == '\t' || ch == '\n';
+}
+
+static int
+parse_literal (FILE * file, 
+               bool skip_v_line_prefix_after_new_line,
+	       const char * context, size_t * lineno)
+{
+  int ch, previous;
+
+SKIP_WHITE_SPACE:
+
+  previous = 0;
+  while (is_white_space (ch = next_char (file, lineno)))
+    previous = ch;
+
+  if (ch == EOF)
+    die ("unexpected end-of-file after '%s' at line %zu",
+         context, *lineno);
+
+  if (skip_v_line_prefix_after_new_line && previous == '\n' && ch == 'v')
+    goto SKIP_WHITE_SPACE;
+
+  int sign = 1;
+  if (ch == '-')
+    {
+      sign = -1;
+      ch = next_char (file, lineno);
+    }
+
+  if (!isdigit (ch))
+    die ("expected digit after '%s' at line %zu",
+         context, *lineno - (ch == '\n'));
+
+  int idx = ch - '0';
+  while (isdigit (ch = next_char (file, lineno)))
+    {
+      if (INT_MAX/10 < idx)
+        die ("literal way too large after '%s' at line %zu",
+	     context, *lineno);
+      idx *= 10;
+      const int digit = ch - '0';
+      if (INT_MAX - digit < idx)
+        die ("literal too large after '%s' at line %zu",
+	     context, *lineno);
+      idx += digit;
+    }
+  if (idx)
+    increase_variables (idx);
+
+  const int res = sign * idx;
+
+  if (ch == EOF)
+    die ("unexpected end-of-line after '%d' at line %zu", res, *lineno);
+  if (!is_white_space (ch))
+    die ("expected white space after '%d' at line %zu", res, *lineno);
+
+  ungetc (ch, file);
+  if (ch == '\n')
+    *lineno -= 1;
+
+  return res;
+}
+
+static void
+parse_status (const char * str, FILE * file, size_t lineno)
+{
+  const char * p = str;
+  int ch = 0;
+  while (*p && *p == (ch = getc (file)))
+    assert (ch != '\n'), p++;
+
+  if (*p)
+    die ("invalid status line at %zu", lineno);
+
+  while ((ch = getc (file)) == ' ' || ch == '\t')
+    ;
+
+  if (ch != '\n')
+    die ("incomplete status line at %zu", lineno);
+
+  ungetc (ch, file);
+}
+
+static int
+parse_witness (void)
+{
+  msg ("parsing witness file '%s'", error_path = witness_path);
+  int res = 0, ch;
+  size_t lineno = 1;
+  for (;;)
+    {
+      ch = next_char (witness_file, &lineno);
+      if (ch == EOF)
+	break;
+      else if (ch == 'v')
+	{
+	  int lit;
+	  while ((lit = parse_literal (witness_file, true, "v", &lineno)))
+	    if (lit)
+	      values[lit] = 1, values[-lit] = -1;
+	}
+      else if (ch == 's')
+	{
+	  if (res)
+	    die ("second 's' line %zu", lineno);
+	  if ((ch = next_char (witness_file, &lineno)) == ' ')
+	    {
+	      if ((ch = next_char (witness_file, &lineno)) == 'S')
+		{
+		  parse_status ("ATISFIABLE", witness_file, lineno);
+		  msg ("found 's SATISFIABLE' at line %zu", lineno);
+		  res = 10;
+		}
+	      else if (ch == 'U')
+		{
+		  parse_status ("NSATISFIABLE", witness_file, lineno);
+		  msg ("found 's UNSATISFIABLE' at line %zu", lineno);
+		  res = 20;
+		}
+	      else
+		goto INVALID_STATUS_LINE;
+
+	      ch = next_char (witness_file, &lineno);
+	    }
+	  else
+	    {
+INVALID_STATUS_LINE:
+	      die ("invalid status line at line %zu",
+		   lineno - (ch == '\n'));
+	    }
+	}
+      else if (ch == '\n')
+	die ("invalid empty line %zu", lineno);
+      else if (ch != 'c')
+	die ("invalid line %zu", lineno);
+
+      while (ch != '\n' && ch != EOF)
+	ch = next_char (witness_file, &lineno);
+
+      lineno++;
+    }
+  error_path = 0;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void
+parse_extension (void)
+{
+  msg ("parsing extension file '%s'", error_path = extension_path);
+
+  size_t xor_constraints = 0;
+  size_t or_constraints = 0;
+  size_t lineno = 1;
+
+  for (;;)
+    {
+      int type = next_char (extension_file, &lineno);
+      if (type == '\n')
+	continue;
+      if (type == EOF)
+	break;
+      if (type != 'x' && type != 'o')
+	die ("invalid line %zu", lineno);
+      int lit;
+      const char context[2] = { type, 0 };
+      assert (EMPTY (literals));
+      while ((lit = parse_literal (extension_file, false, context, &lineno)))
+	PUSH (literals, lit);
+      const size_t size = SIZE (literals);
+      if (size >= (1u <<31))
+	die ("constraint at line %zu too large", lineno);
+      size_t literals_bytes = size * sizeof (int);
+      size_t bytes = sizeof (struct constraint) + literals_bytes;
+      struct constraint * c = malloc (bytes);
+      if (!c)
+	out_of_memory ();
+      PUSH (constraints, c);
+      c->xor = (type == 'x');
+      c->size = size;
+      memcpy (c->literals, literals.begin, literals_bytes);
+      CLEAR (literals);
+      if (type == 'x')
+	xor_constraints++;
+      else
+	or_constraints++;
+    }
+
+  const size_t constraints = xor_constraints + or_constraints;
+  msg ("parsed %zu lines (%zu XORs %.0f%%, %zu ORs %.0f%%)",
+       constraints,
+       xor_constraints, percent (xor_constraints, constraints),
+       or_constraints, percent (or_constraints, constraints));
+  error_path = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void
+extend_witness (void)
+{
+  msg ("maximum variable index %d", vars);
+  size_t flipped = 0;
+  for (all_constraints (c))
+    {
+      bool satisfied = false;
+      assert (c->size > 0);
+      if (c->xor)
+	{
+	  for (all_literals (lit, c))
+	    if (values[lit] > 0)
+	      satisfied = !satisfied;
+	}
+      else
+	{
+	  for (all_literals (lit, c))
+	    if (values[lit] > 0)
+	      satisfied = true;
+	}
+      if (satisfied)
+	continue;
+      int flip = c->literals[0];
+      values[flip] *= -1;
+      values[-flip] *= -1;
+      flipped++;
+    }
+  msg ("flipped %zu literals", flipped);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void
+flush_buffer (void)
+{
+  assert (size_buffer);
+  assert (size_buffer < sizeof buffer);
+  buffer[size_buffer] = 0;
+  fputs (buffer, stdout);
+  fputc ('\n', stdout);
+  size_buffer = 0;
+}
+
+static void
+print_value (int lit)
+{
+  if (!size_buffer)
+    buffer[size_buffer++] = 'v';
+  char tmp[32];
+  sprintf (tmp, " %d", lit);
+  size_t len = strlen (tmp);
+  if (size_buffer + len >= 76)
+    {
+      flush_buffer ();
+      buffer[size_buffer++] = 'v';
+    }
+  const char * p = tmp;
+  while (*p)
+    assert (size_buffer < sizeof buffer), buffer[size_buffer++] = *p++;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void
+reset (void)
+{
+  for (all_constraints (c))
+    free (c);
+  free (constraints.begin);
+
+  values -= capacity;
+  free (values);
+
+  free (literals.begin);
+}
+
+/*------------------------------------------------------------------------*/
+
+int
+main (int argc, char ** argv)
+{
+  for (int i = 1; i < argc; i++)
+    {
+      const char * arg = argv[i];
+      if (!strcmp (arg, "-h") || !strcmp (arg, "--help"))
+	fputs (usage, stdout), exit (0);
+      else if (!strcmp (arg, "--version"))
+	printf ("%s\n", VERSION), exit (0);
+      else if (!strcmp (arg, "-q") || !strcmp (arg, "--quiet"))
+	quiet = true;
+      else if (witness_path)
+	die ("too many file arguments '%s', '%s' and '%s'",
+	     extension_path, witness_path, arg);
+      else if (extension_path)
+	witness_path = arg;
+      else
+	extension_path = arg;
+    }
+
+  if (!witness_path)
+    die ("witness file missing (try '-h'))");
+
+  if (!extension_path)
+    die ("extension file missing (try '-h'))");
+
+  if (!(witness_file = fopen (witness_path, "r")))
+    die ("could not read witness file '%s'", witness_path);
+
+  if (!(extension_file = fopen (extension_path, "r")))
+    die ("could not read extension file '%s'", extension_path);
+
+  msg ("EXTOR witness XNF extender Version " VERSION);
+
+  int res = parse_witness ();
+  fclose (witness_file);
+
+  if (res == 10)
+    {
+      parse_extension ();
+      extend_witness ();
+    }
+  fclose (extension_file);
+
+  if (res == 10)
+    {
+      printf ("s SATISFIABLE\n");
+      for (int idx = 1; idx <= vars; idx++)
+	print_value (values[idx] <= 0 ? -idx : idx);
+      print_value (0);
+      flush_buffer ();
+    }
+  else if (res == 20)
+    printf ("s UNSATISFIABLE\n");
+
+  reset ();
+
+  msg ("extended witness in %.2f seconds", timevoid ());
+
+  return res;
+}
diff --git a/cnf2xnf/extract-xors-then-run-solver-and-extend-solution.sh b/cnf2xnf/extract-xors-then-run-solver-and-extend-solution.sh
new file mode 100755
index 0000000..dfe17b9
--- /dev/null
+++ b/cnf2xnf/extract-xors-then-run-solver-and-extend-solution.sh
@@ -0,0 +1,34 @@
+#!/bin/sh
+#tmp="/tmp/extor$$"
+#tmp="/tmp/extor"
+tmp=/tmp/
+trap "rm -f $tmp*" 2 3 9 15
+die () {
+  echo "error: $*" 1>&2
+  exit 1
+}
+[ $# -lt 1 ] && die "solver argument missing"
+[ $# -gt 2 ] && die "too many arguments"
+[ -x "$1" ] || die "can not execute '$1'"
+solver="$1"
+if [ $# = 1 ]
+then
+  cnf="-"
+elif [ -f "$2" ]
+then
+  cnf="$2"
+else
+  die "can not access '$2'"
+fi
+extracted=${tmp}extracted
+extension=${tmp}extension
+./cnf2xnf "$cnf" $extracted $extension
+witness=${tmp}witness
+case $solver in
+  yalsat*|xorsat*|*yalsat|*xorsat)options=" --witness";;
+esac
+$solver$options $extracted |tee -i $witness|sed -e '/^v/d;s/^s/c/'
+./extor $extension $witness
+status=$?
+#rm -f $tmp*
+exit $status
diff --git a/cnf2xnf/makefile.in b/cnf2xnf/makefile.in
new file mode 100644
index 0000000..7d75b01
--- /dev/null
+++ b/cnf2xnf/makefile.in
@@ -0,0 +1,24 @@
+all: cnf2xnf xnf2cnf3 xnf2cnf4 xnf2cnf5 xnf2cnf6 xnf2cnf7 xnf2cnf8 extor
+cnf2xnf: cnf2xnf.c makefile
+	@COMPILE@ -o $@ $<
+xnf2cnf3: xnf2cnf3.c makefile
+	@COMPILE@ -o $@ $<
+xnf2cnf4: xnf2cnf4.c makefile
+	@COMPILE@ -o $@ $<
+xnf2cnf5: xnf2cnf5.c makefile
+	@COMPILE@ -o $@ $<
+xnf2cnf6: xnf2cnf6.c makefile
+	@COMPILE@ -o $@ $<
+xnf2cnf7: xnf2cnf7.c makefile
+	@COMPILE@ -o $@ $<
+xnf2cnf8: xnf2cnf8.c makefile
+	@COMPILE@ -o $@ $<
+extor: extor.c makefile
+	@COMPILE@ -o $@ $<
+test: cnf2xnf
+	./testcnfs.sh
+indent:
+	indent cnf2xnf.c
+clean:
+	rm -f makefile cnf2xnf extor cnfs/*.xnf cnfs/*.log cnfs/*.err *~
+.PHONY: test indent clean
diff --git a/cnf2xnf/test.xnf b/cnf2xnf/test.xnf
new file mode 100644
index 0000000..01e78d8
--- /dev/null
+++ b/cnf2xnf/test.xnf
@@ -0,0 +1,2 @@
+p xnf 11 1
+x 1 2 3 4 5 6 7 8 9 10 11 0
diff --git a/cnf2xnf/testcnfs.sh b/cnf2xnf/testcnfs.sh
new file mode 100755
index 0000000..08050ba
--- /dev/null
+++ b/cnf2xnf/testcnfs.sh
@@ -0,0 +1,50 @@
+#!/bin/sh
+run () {
+  expected=$1
+  cnf=cnfs/$2.cnf
+  xnf=cnfs/$2.xnf
+  log=cnfs/$2.log
+  err=cnfs/$2.err
+  cmd="./cnf2xnf $cnf $xnf"
+  printf "$cmd # expected '$expected' XORs"
+  ./cnf2xnf $cnf $xnf 1>$log 2>$err
+  status=$?
+  if [ $status = 0 ]
+  then
+    extracted="`awk '/extracted/{print $3}' $log`"
+    if [ "$expected" = "$extracted" ]
+    then
+      echo " OK"
+    else
+      echo " but extracted '$extracted'"
+      echo "testcnfs.sh: error: '$cmd' FAILED"
+      exit 1
+    fi
+  else
+     echo " status '$status'"
+      echo "testcnfs.sh: error: '$cmd' FAILED"
+     exit 1
+  fi
+}
+
+run 0 true
+run 0 false
+
+run 1 xor1
+run 1 xor2
+run 1 xor3
+run 2 xor4
+run 1 xor5
+
+run 1 mixed1
+run 1 mixed2
+
+run 0 missing1
+run 0 missing2
+run 0 missing3
+
+run 0 and1
+
+run 1 aig1
+
+run 3 regr1
diff --git a/cnf2xnf/xnf2cnf3.c b/cnf2xnf/xnf2cnf3.c
new file mode 100644
index 0000000..faa704d
--- /dev/null
+++ b/cnf2xnf/xnf2cnf3.c
@@ -0,0 +1,134 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define POOL	1
+#define LINEAR	2
+
+#define DEFAULT	LINEAR
+
+void printCls (int* array, int size) {
+  for (int i = 0; i < size; i++)
+    printf ("%i ", array[i]);
+  printf ("0\n");
+}
+
+int printXOR (int* array, int size, int var, int mode) {
+  if (size <  1) {
+    printf ("0\n");
+    return var; }
+
+  if (size == 1) {
+    printf ("%i 0\n", -array[0]);
+    return var; }
+
+  if (size == 2) {
+    printf ("%i %i 0\n",  array[0], -array[1]);
+    printf ("%i %i 0\n", -array[0],  array[1]);
+    return var; }
+
+  if (size == 3) {
+    printf ("%i %i %i 0\n",  array[0],  array[1], -array[2]);
+    printf ("%i %i %i 0\n",  array[0], -array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0],  array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0], -array[1], -array[2]);
+    return var; }
+
+  printf ("%i %i %i 0\n",  array[0],  array[1], -var);
+  printf ("%i %i %i 0\n",  array[0], -array[1],  var);
+  printf ("%i %i %i 0\n", -array[0],  array[1],  var);
+  printf ("%i %i %i 0\n", -array[0], -array[1], -var);
+
+  if (mode == POOL) {
+    for (int i = 0; i < size - 2; i++) array[i] = array[i+2];
+    array[size - 2] = var;
+  }
+
+  if (mode == LINEAR) {
+    array[0] = var;
+    for (int i = 0; i < size - 2; i++) array[i+1] = array[i+2];
+  }
+
+  return printXOR (array, size - 1, var + 1, mode);
+}
+
+int main (int argc, char** argv) {
+  int nVar, nCls;
+
+  FILE* xnf = fopen (argv[1], "r");
+
+  int mode = DEFAULT;
+  if (argc > 2) {
+    if (argv[2][0] == '-' && argv[2][1] == 'l') mode = LINEAR;
+    if (argv[2][0] == '-' && argv[2][1] == 'p') mode = POOL; }
+
+  int tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+
+  int array[nVar];
+  int maxVar = nVar + 1;
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+
+    array[size++] = lit;
+
+    if (tmp == EOF) break;
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      if (size > 3) {
+      	maxVar += (size - 3);
+      }
+      if (size > 3) {
+      	nCls += (size - 2) * 4 - 1;
+      }
+    }
+  }
+  fclose (xnf);
+
+  printf ("p cnf %i %i\n", maxVar - 1, nCls);
+
+  xnf = fopen (argv[1], "r");
+  tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+  maxVar = nVar + 1;
+
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    if (tmp == EOF) break;
+
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+    if (tmp == EOF) break;
+
+    array[size++] = lit;
+    if (flag) array[0] = -lit;
+
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      maxVar = printXOR (array, size, maxVar, mode);
+    }
+    else {
+      printCls (array, size);
+    }
+  }
+  fclose (xnf);
+}
diff --git a/cnf2xnf/xnf2cnf4.c b/cnf2xnf/xnf2cnf4.c
new file mode 100644
index 0000000..0721d88
--- /dev/null
+++ b/cnf2xnf/xnf2cnf4.c
@@ -0,0 +1,148 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define POOL	1
+#define LINEAR	2
+
+#define DEFAULT	LINEAR
+
+void printCls (int* array, int size) {
+  for (int i = 0; i < size; i++)
+    printf ("%i ", array[i]);
+  printf ("0\n");
+}
+
+int printXOR (int* array, int size, int var, int mode) {
+  if (size <  1) {
+    printf ("0\n");
+    return var; }
+
+  if (size == 1) {
+    printf ("%i 0\n", -array[0]);
+    return var; }
+
+  if (size == 2) {
+    printf ("%i %i 0\n",  array[0], -array[1]);
+    printf ("%i %i 0\n", -array[0],  array[1]);
+    return var; }
+
+  if (size == 3) {
+    printf ("%i %i %i 0\n",  array[0],  array[1], -array[2]);
+    printf ("%i %i %i 0\n",  array[0], -array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0],  array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0], -array[1], -array[2]);
+    return var; }
+
+  if (size == 4) {
+    printf ("%i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3]);
+    return var; }
+
+  printf ("%i %i %i %i 0\n",  array[0],  array[1],  array[2], -var);
+  printf ("%i %i %i %i 0\n",  array[0],  array[1], -array[2],  var);
+  printf ("%i %i %i %i 0\n",  array[0], -array[1],  array[2],  var);
+  printf ("%i %i %i %i 0\n", -array[0],  array[1],  array[2],  var);
+  printf ("%i %i %i %i 0\n",  array[0], -array[1], -array[2], -var);
+  printf ("%i %i %i %i 0\n", -array[0],  array[1], -array[2], -var);
+  printf ("%i %i %i %i 0\n", -array[0], -array[1],  array[2], -var);
+  printf ("%i %i %i %i 0\n", -array[0], -array[1], -array[2],  var);
+
+  if (mode == POOL) {
+    for (int i = 0; i < size - 3; i++) array[i] = array[i+3];
+    array[size - 3] = var;
+  }
+
+  if (mode == LINEAR) {
+    array[0] = var;
+    for (int i = 0; i < size - 3; i++) array[i+1] = array[i+3];
+  }
+
+  return printXOR (array, size - 2, var + 1, mode);
+}
+
+int main (int argc, char** argv) {
+  int nVar, nCls;
+
+  FILE* xnf = fopen (argv[1], "r");
+
+  int mode = DEFAULT;
+  if (argc > 2) {
+    if (argv[2][0] == '-' && argv[2][1] == 'l') mode = LINEAR;
+    if (argv[2][0] == '-' && argv[2][1] == 'p') mode = POOL; }
+
+  int tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+
+  int array[nVar];
+  int maxVar = nVar + 1;
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+
+    array[size++] = lit;
+
+    if (tmp == EOF) break;
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      if (size > 4) {
+        maxVar += (size - 3)/2;
+      }
+      if (size > 4) {
+        nCls += (size - 2) * 4 - 1; }
+    }
+  }
+  fclose (xnf);
+
+  printf ("p cnf %i %i\n", maxVar - 1, nCls);
+
+  xnf = fopen (argv[1], "r");
+  tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+  maxVar = nVar + 1;
+
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    if (tmp == EOF) break;
+
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+    if (tmp == EOF) break;
+
+    array[size++] = lit;
+    if (flag) array[0] = -lit;
+
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      maxVar = printXOR (array, size, maxVar, mode);
+    }
+    else {
+      printCls (array, size);
+    }
+  }
+  fclose (xnf);
+}
diff --git a/cnf2xnf/xnf2cnf5.c b/cnf2xnf/xnf2cnf5.c
new file mode 100644
index 0000000..b9db425
--- /dev/null
+++ b/cnf2xnf/xnf2cnf5.c
@@ -0,0 +1,177 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define POOL	1
+#define LINEAR	2
+
+#define DEFAULT	LINEAR
+
+void printCls (int* array, int size) {
+  for (int i = 0; i < size; i++)
+    printf ("%i ", array[i]);
+  printf ("0\n");
+}
+
+int printXOR (int* array, int size, int var, int mode) {
+  if (size <  1) {
+    printf ("0\n");
+    return var; }
+
+  if (size == 1) {
+    printf ("%i 0\n", -array[0]);
+    return var; }
+
+  if (size == 2) {
+    printf ("%i %i 0\n",  array[0], -array[1]);
+    printf ("%i %i 0\n", -array[0],  array[1]);
+    return var; }
+
+  if (size == 3) {
+    printf ("%i %i %i 0\n",  array[0],  array[1], -array[2]);
+    printf ("%i %i %i 0\n",  array[0], -array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0],  array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0], -array[1], -array[2]);
+    return var; }
+
+  if (size == 4) {
+    printf ("%i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3]);
+    return var; }
+
+  if (size == 5) {
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4]);
+    return var; }
+
+  printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  var);
+  printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  var);
+  printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  var);
+  printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  var);
+  printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  var);
+  printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  var);
+  printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  var);
+  printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  var);
+  printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -var);
+  printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -var);
+  printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -var);
+  printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -var);
+  printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -var);
+  printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -var);
+  printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -var);
+  printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -var);
+
+  if (mode == POOL) {
+    for (int i = 0; i < size - 4; i++) array[i] = array[i+4];
+    array[size - 4] = var;
+  }
+
+  if (mode == LINEAR) {
+    array[0] = var;
+    for (int i = 0; i < size - 4; i++) array[i+1] = array[i+4];
+  }
+
+  return printXOR (array, size - 3, var + 1, mode);
+}
+
+int main (int argc, char** argv) {
+  int nVar, nCls;
+
+  FILE* xnf = fopen (argv[1], "r");
+
+  int mode = DEFAULT;
+  if (argc > 2) {
+    if (argv[2][0] == '-' && argv[2][1] == 'l') mode = LINEAR;
+    if (argv[2][0] == '-' && argv[2][1] == 'p') mode = POOL; }
+
+  int tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+
+  int array[nVar];
+  int maxVar = nVar + 1;
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+
+    array[size++] = lit;
+
+    if (tmp == EOF) break;
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      if (size > 5) {
+        maxVar += (size - 3)/3;
+      }
+      if (size > 5) {
+        nCls += (size - 3)/3 * 16;
+        nCls += (1<<((size % 3) + 2)) - 1;
+         }
+    }
+  }
+  fclose (xnf);
+
+  printf ("p cnf %i %i\n", maxVar - 1, nCls);
+
+  xnf = fopen (argv[1], "r");
+  tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+  maxVar = nVar + 1;
+
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    if (tmp == EOF) break;
+
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+    if (tmp == EOF) break;
+
+    array[size++] = lit;
+    if (flag) array[0] = -lit;
+
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      maxVar = printXOR (array, size, maxVar, mode);
+    }
+    else {
+      printCls (array, size);
+    }
+  }
+  fclose (xnf);
+}
diff --git a/cnf2xnf/xnf2cnf6.c b/cnf2xnf/xnf2cnf6.c
new file mode 100644
index 0000000..cb91545
--- /dev/null
+++ b/cnf2xnf/xnf2cnf6.c
@@ -0,0 +1,229 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define POOL	1
+#define LINEAR	2
+
+#define DEFAULT	LINEAR
+
+void printCls (int* array, int size) {
+  for (int i = 0; i < size; i++)
+    printf ("%i ", array[i]);
+  printf ("0\n");
+}
+
+int printXOR (int* array, int size, int var, int mode) {
+  if (size <  1) {
+    printf ("0\n");
+    return var; }
+
+  if (size == 1) {
+    printf ("%i 0\n", -array[0]);
+    return var; }
+
+  if (size == 2) {
+    printf ("%i %i 0\n",  array[0], -array[1]);
+    printf ("%i %i 0\n", -array[0],  array[1]);
+    return var; }
+
+  if (size == 3) {
+    printf ("%i %i %i 0\n",  array[0],  array[1], -array[2]);
+    printf ("%i %i %i 0\n",  array[0], -array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0],  array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0], -array[1], -array[2]);
+    return var; }
+
+  if (size == 4) {
+    printf ("%i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3]);
+    return var; }
+
+  if (size == 5) {
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4]);
+    return var; }
+
+  if (size == 6) {
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5]);
+    return var; }
+
+  printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  var);
+  printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  var);
+
+  if (mode == POOL) {
+    for (int i = 0; i < size - 5; i++) array[i] = array[i+5];
+    array[size - 5] = var;
+  }
+
+  if (mode == LINEAR) {
+    array[0] = var;
+    for (int i = 0; i < size - 5; i++) array[i+1] = array[i+5];
+  }
+
+  return printXOR (array, size - 4, var + 1, mode);
+}
+
+int main (int argc, char** argv) {
+  int nVar, nCls;
+
+  FILE* xnf = fopen (argv[1], "r");
+
+  int mode = DEFAULT;
+  if (argc > 2) {
+    if (argv[2][0] == '-' && argv[2][1] == 'l') mode = LINEAR;
+    if (argv[2][0] == '-' && argv[2][1] == 'p') mode = POOL; }
+
+  int tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+
+  int array[nVar];
+  int maxVar = nVar + 1;
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+
+    array[size++] = lit;
+
+    if (tmp == EOF) break;
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      if (size > 6) {
+        maxVar += (size - 3)/4;
+        //maxVar += size;
+      }
+      if (size > 6) {
+        nCls += (size - 3)/4 * 32;
+        nCls += (1<<(((size+1) % 4) + 2)) - 1;
+         }
+    }
+  }
+  fclose (xnf);
+
+  printf ("p cnf %i %i\n", maxVar - 1, nCls);
+
+  xnf = fopen (argv[1], "r");
+  tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+  maxVar = nVar + 1;
+
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    if (tmp == EOF) break;
+
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+    if (tmp == EOF) break;
+
+    array[size++] = lit;
+    if (flag) array[0] = -lit;
+
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      maxVar = printXOR (array, size, maxVar, mode);
+    }
+    else {
+      printCls (array, size);
+    }
+  }
+  fclose (xnf);
+}
diff --git a/cnf2xnf/xnf2cnf7.c b/cnf2xnf/xnf2cnf7.c
new file mode 100644
index 0000000..727621b
--- /dev/null
+++ b/cnf2xnf/xnf2cnf7.c
@@ -0,0 +1,328 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define POOL	1
+#define LINEAR	2
+
+#define DEFAULT	LINEAR
+
+void printCls (int* array, int size) {
+  for (int i = 0; i < size; i++)
+    printf ("%i ", array[i]);
+  printf ("0\n");
+}
+
+int printXOR (int* array, int size, int var, int mode) {
+  if (size <  1) {
+    printf ("0\n");
+    return var; }
+
+  if (size == 1) {
+    printf ("%i 0\n", -array[0]);
+    return var; }
+
+  if (size == 2) {
+    printf ("%i %i 0\n",  array[0], -array[1]);
+    printf ("%i %i 0\n", -array[0],  array[1]);
+    return var; }
+
+  if (size == 3) {
+    printf ("%i %i %i 0\n",  array[0],  array[1], -array[2]);
+    printf ("%i %i %i 0\n",  array[0], -array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0],  array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0], -array[1], -array[2]);
+    return var; }
+
+  if (size == 4) {
+    printf ("%i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3]);
+    return var; }
+
+  if (size == 5) {
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4]);
+    return var; }
+
+  if (size == 6) {
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5]);
+    return var; }
+
+  if (size == 7) {
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5],  array[6]);
+    return var; }
+
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4],  array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4], -array[5], -var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5],  var);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5],  var);
+
+  if (mode == POOL) {
+    for (int i = 0; i < size - 6; i++) array[i] = array[i+6];
+    array[size - 6] = var;
+  }
+
+  if (mode == LINEAR) {
+    array[0] = var;
+    for (int i = 0; i < size - 6; i++) array[i+1] = array[i+6];
+  }
+
+  return printXOR (array, size - 5, var + 1, mode);
+}
+
+int main (int argc, char** argv) {
+  int nVar, nCls;
+
+  FILE* xnf = fopen (argv[1], "r");
+
+  int mode = DEFAULT;
+  if (argc > 2) {
+    if (argv[2][0] == '-' && argv[2][1] == 'l') mode = LINEAR;
+    if (argv[2][0] == '-' && argv[2][1] == 'p') mode = POOL; }
+
+  int tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+
+  int array[nVar];
+  int maxVar = nVar + 1;
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+
+    array[size++] = lit;
+
+    if (tmp == EOF) break;
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      if (size > 7) {
+        maxVar += (size - 3)/5;
+        //maxVar += size;
+      }
+      if (size > 7) {
+        nCls += (size - 3)/5 * 64;
+        nCls += (1<<(((size+2) % 5) + 2)) - 1;
+         }
+    }
+  }
+  fclose (xnf);
+
+  printf ("p cnf %i %i\n", maxVar - 1, nCls);
+
+  xnf = fopen (argv[1], "r");
+  tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+  maxVar = nVar + 1;
+
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    if (tmp == EOF) break;
+
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+    if (tmp == EOF) break;
+
+    array[size++] = lit;
+    if (flag) array[0] = -lit;
+
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      maxVar = printXOR (array, size, maxVar, mode);
+    }
+    else {
+      printCls (array, size);
+    }
+  }
+  fclose (xnf);
+}
diff --git a/cnf2xnf/xnf2cnf8.c b/cnf2xnf/xnf2cnf8.c
new file mode 100644
index 0000000..f3896d3
--- /dev/null
+++ b/cnf2xnf/xnf2cnf8.c
@@ -0,0 +1,523 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define POOL	1
+#define LINEAR	2
+
+#define DEFAULT	LINEAR
+
+void printCls (int* array, int size) {
+  for (int i = 0; i < size; i++)
+    printf ("%i ", array[i]);
+  printf ("0\n");
+}
+
+int printXOR (int* array, int size, int var, int mode) {
+  if (size <  1) {
+    printf ("0\n");
+    return var; }
+
+  if (size == 1) {
+    printf ("%i 0\n", -array[0]);
+    return var; }
+
+  if (size == 2) {
+    printf ("%i %i 0\n",  array[0], -array[1]);
+    printf ("%i %i 0\n", -array[0],  array[1]);
+    return var; }
+
+  if (size == 3) {
+    printf ("%i %i %i 0\n",  array[0],  array[1], -array[2]);
+    printf ("%i %i %i 0\n",  array[0], -array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0],  array[1],  array[2]);
+    printf ("%i %i %i 0\n", -array[0], -array[1], -array[2]);
+    return var; }
+
+  if (size == 4) {
+    printf ("%i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3]);
+    printf ("%i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3]);
+    printf ("%i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3]);
+    return var; }
+
+  if (size == 5) {
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4]);
+    printf ("%i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4]);
+    return var; }
+
+  if (size == 6) {
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5]);
+    printf ("%i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5]);
+    return var; }
+
+  if (size == 7) {
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4],  array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4], -array[5], -array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5],  array[6]);
+    printf ("%i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5],  array[6]);
+    return var; }
+
+  if (size == 8) {
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4],  array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4], -array[5], -array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5],  array[6],  array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4],  array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4], -array[5],  array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5], -array[6], -array[7]);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5], -array[6], -array[7]);
+    return var; }
+
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4],  array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4], -array[5], -array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5],  array[6],  var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4],  array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4], -array[5],  array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3], -array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3], -array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3], -array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3], -array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3], -array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3], -array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3], -array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3], -array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3],  array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3],  array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3],  array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3],  array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3],  array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3],  array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3],  array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3],  array[4], -array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2], -array[3],  array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2],  array[3],  array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2],  array[3],  array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2],  array[3],  array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2], -array[3],  array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2], -array[3],  array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2], -array[3],  array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2],  array[3],  array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1],  array[2],  array[3], -array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0],  array[1], -array[2], -array[3], -array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1],  array[2], -array[3], -array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1],  array[2], -array[3], -array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n",  array[0], -array[1], -array[2],  array[3], -array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0],  array[1], -array[2],  array[3], -array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1],  array[2],  array[3], -array[4],  array[5], -array[6], -var);
+    printf ("%i %i %i %i %i %i %i %i 0\n", -array[0], -array[1], -array[2], -array[3], -array[4],  array[5], -array[6], -var);
+
+  if (mode == POOL) {
+    for (int i = 0; i < size - 7; i++) array[i] = array[i+7];
+    array[size - 7] = var;
+  }
+
+  if (mode == LINEAR) {
+    array[0] = var;
+    for (int i = 0; i < size - 7; i++) array[i+1] = array[i+7];
+  }
+
+  return printXOR (array, size - 6, var + 1, mode);
+}
+
+int main (int argc, char** argv) {
+  int nVar, nCls;
+
+  FILE* xnf = fopen (argv[1], "r");
+
+  int mode = DEFAULT;
+  if (argc > 2) {
+    if (argv[2][0] == '-' && argv[2][1] == 'l') mode = LINEAR;
+    if (argv[2][0] == '-' && argv[2][1] == 'p') mode = POOL; }
+
+  int tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+
+  int array[nVar];
+  int maxVar = nVar + 1;
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+
+    array[size++] = lit;
+
+    if (tmp == EOF) break;
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      if (size > 7) {
+        maxVar += (size - 3)/6;
+        //maxVar += size;
+      }
+      if (size > 7) {
+        nCls += (size - 3)/6 * 128;
+        nCls += (1<<(((size+3) % 6) + 2)) - 1;
+         }
+    }
+  }
+  fclose (xnf);
+
+  printf ("p cnf %i %i\n", maxVar - 1, nCls);
+
+  xnf = fopen (argv[1], "r");
+  tmp = fscanf (xnf, " p xnf %i %i ", &nVar, &nCls);
+  maxVar = nVar + 1;
+
+
+  while (1) {
+    int size = 0;
+    int lit;
+    tmp = fscanf (xnf, " x %i ", &lit);
+    if (tmp == EOF) break;
+
+    int flag = tmp;
+    if (flag == 0) {
+      tmp = fscanf (xnf, " %i ", &lit); }
+    if (tmp == EOF) break;
+
+    array[size++] = lit;
+    if (flag) array[0] = -lit;
+
+    while (1) {
+      tmp = fscanf (xnf, " %i ", &lit);
+      if (lit) array[ size++ ] = lit;
+      if (lit == 0 || tmp == EOF) break;
+    }
+    if (tmp == EOF) break;
+
+    if (flag == 1) {
+      maxVar = printXOR (array, size, maxVar, mode);
+    }
+    else {
+      printCls (array, size);
+    }
+  }
+  fclose (xnf);
+}
diff --git a/config.c b/config.c
new file mode 100644
index 0000000..99c5991
--- /dev/null
+++ b/config.c
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2021 xnfSAT Authors                                           */
+/*-------------------------------------------------------------------------*/
+
+#include "config.h"
+#include "cflags.h"
+
+#define YALSINTERNAL
+#include "yils.h"
+
+#include <stdio.h>
+
+#define MSG(STR) printf ("%s%s\n", prefix, (STR))
+
+void yals_banner (const char * prefix) {
+  MSG ("Version " YALS_VERSION " " YALS_ID);
+  MSG ("Copyright (C) 2021 xnfSAT Authors");
+  MSG ("Released " YALS_RELEASED);
+  MSG ("Compiled " YALS_COMPILED);
+  MSG (YALS_OS);
+  MSG ("CC " YALS_CC);
+  MSG ("CFLAGS " YALS_CFLAGS);
+}
+
+const char * yals_version () { return YALS_VERSION; }
diff --git a/configure.sh b/configure.sh
new file mode 100755
index 0000000..82ab689
--- /dev/null
+++ b/configure.sh
@@ -0,0 +1,61 @@
+#!/bin/sh
+usage () {
+cat << EOF
+usage: configure.sh [-h][-g][--no-mems][--no-double]
+
+-h   print this command line option summary
+
+-g   compile with debugging, checking and logging support
+     (compiles in '-c' and '-l' run time options for checking and logging)
+
+--no-mems     disable computation of memory accesses
+              (to measure the slow-down incurred by this feature)
+
+--no-stats    disable computation of increment/decrement stats
+
+-O            disables '-g' and enables '--no-mems --no-stats' and
+EOF
+}
+die () {
+  echo "*** configure.sh: $*" 1>&2
+  exit 1
+}
+opt=no
+mems=yes
+stats=yes
+debug=no
+while [ $# -gt 0 ]
+do
+  case $1 in
+    -h) usage; exit 0;;
+    --no-mems) mems=no;;
+    --no-stats) stats=no;;
+    -O) opt=yes;;
+    -g) debug=yes;;
+    *) die "invalid command line option '$1'";;
+  esac
+  shift
+done
+if [ $opt = yes ]
+then
+  debug=no
+  mems=no
+  stats=no
+fi
+CC=gcc
+if [ $debug = yes ]
+then
+  CFLAGS="-Wall -Wextra -g3"
+else
+  CFLAGS="-Wall -Wextra -DNDEBUG -O3"
+fi
+[ $mems = no ] && CFLAGS="$CFLAGS -DNYALSMEMS"
+[ $stats = no ] && CFLAGS="$CFLAGS -DNYALSTATS"
+LIBS="-lm"
+echo "$CC $CFLAGS $LIBS"
+rm -f makefile
+sed \
+  -e "s,@CC@,$CC," \
+  -e "s,@CFLAGS@,$CFLAGS," \
+  -e "s,@LIBS@,$LIBS," \
+makefile.in > makefile
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..86fb4c8
--- /dev/null
+++ b/main.c
@@ -0,0 +1,866 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2021 xnfSAT Authors                                           */
+/*-------------------------------------------------------------------------*/
+
+#include "yals.h"
+
+/*------------------------------------------------------------------------*/
+
+#define YALSINTERNAL
+#include "yils.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 <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdarg.h>
+
+/*------------------------------------------------------------------------*/
+#ifdef PALSAT
+#include <pthread.h>
+#include <sys/time.h>
+#endif
+/*------------------------------------------------------------------------*/
+
+#ifdef PALSAT
+#define THREADS 12
+typedef struct Worker { Yals * yals; pthread_t thread; } Worker;
+static Worker * worker;
+static int done, winner, threads = THREADS, threadset;
+struct { pthread_mutex_t done, msg, mem; } lock;
+static int waitall = 0;
+#else
+static Yals * yals;
+static int flipsset, memsset;
+static long long flips = -1, mems = -1;
+#endif
+static unsigned long long seed;
+static int seedset, closefile, verbose;
+static const char * filename;
+static FILE * file;
+static int V, C;
+
+struct { size_t allocated, max; } mem;
+
+/*------------------------------------------------------------------------*/
+#ifndef NDEBUG
+static int logging, checking;
+#endif
+/*------------------------------------------------------------------------*/
+
+#ifdef PALSAT
+#define YALS worker[0].yals
+#define WINNER worker[winner].yals
+#define NAME "PalSAT"
+#else
+#define YALS yals
+#define WINNER yals
+#define NAME "YalSAT"
+#endif
+
+static double average (double a, double b) { return b ? a/b : 0; }
+
+/*------------------------------------------------------------------------*/
+
+#ifdef PALSAT
+#define LOCK(MUTEX) \
+do { \
+  if (pthread_mutex_lock (&lock.MUTEX)) \
+    msg ("failed to lock '%s' mutex in '%s'", #MUTEX, __FUNCTION__); \
+} while (0)
+#define UNLOCK(MUTEX) \
+do { \
+  if (pthread_mutex_unlock (&lock.MUTEX)) \
+    msg ("failed to unlock '%s' mutex in '%s'", #MUTEX, __FUNCTION__); \
+} while (0)
+#else
+#define LOCK(MUTEX) do { } while (0)
+#define UNLOCK(MUTEX) do { } while (0)
+#endif
+
+/*------------------------------------------------------------------------*/
+
+static void die (const char * fmt, ...) {
+  va_list ap;
+#ifdef PALSAT
+  pthread_mutex_lock (&lock.msg);
+#endif
+  fflush (stdout);
+  printf ("*** error: ");
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+#ifdef PALSAT
+  pthread_mutex_unlock (&lock.msg);
+#endif
+  exit (1);
+}
+
+static void perr (const char * fmt, ...) {
+  va_list ap;
+#ifdef PALSAT
+  pthread_mutex_lock (&lock.msg);
+#endif
+  fflush (stdout);
+  printf ("*** parse error: ");
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+#ifdef PALSAT
+  pthread_mutex_unlock (&lock.msg);
+#endif
+  exit (1);
+}
+
+static void msg (const char * fmt, ...) {
+  va_list ap;
+#ifdef PALSAT
+  pthread_mutex_lock (&lock.msg);
+#endif
+  fflush (stdout);
+  fputs ("c ", stdout);
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  fflush (stdout);
+#ifdef PALSAT
+  pthread_mutex_unlock (&lock.msg);
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+#ifdef PALSAT
+
+static double start;
+
+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 () - start; }
+
+#else
+
+static double getime () { return yals_process_time (); }
+
+#endif
+/*------------------------------------------------------------------------*/
+
+#define INC(BYTES) \
+do { \
+  LOCK (mem); \
+  mem.allocated += (BYTES); \
+  if (mem.allocated > mem.max) mem.max = mem.allocated; \
+  UNLOCK (mem); \
+} while (0)
+
+#define DEC(BYTES) \
+do { \
+  LOCK (mem); \
+  assert (mem.allocated >= (BYTES)); \
+  mem.allocated -= (BYTES); \
+  UNLOCK (mem); \
+} while (0)
+
+static void * mymalloc (void * dummy, size_t bytes) {
+  void * res = malloc (bytes);
+  if (!res) die ("out of memory during 'malloc'");
+  (void) dummy;
+  INC (bytes);
+  return res;
+}
+
+static void myfree (void * dummy, void * ptr, size_t bytes) {
+  DEC (bytes);
+  free (ptr);
+}
+
+static void * myrealloc (void * dummy, void * ptr, size_t o, size_t n) {
+  void * res;
+  DEC (o);
+  res = realloc (ptr, n);
+  if (!res) die ("out of memory during 'realloc'");
+  INC (n);
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int hasuffix (const char * arg, const char * suffix) {
+  if (strlen  (arg) < strlen (suffix)) return 0;
+  if (strcmp (arg + strlen (arg) - strlen (suffix), suffix)) return 0;
+  return 1;
+}
+
+static int cmd (const char * arg, const char * suffix, const char * fmt) {
+  struct stat buf;
+  char * cmd;
+  int len;
+  if (!hasuffix (arg, suffix)) return 0;
+  if (stat (arg, &buf)) die ("can not stat file '%s'", arg);
+  len = strlen (fmt) + strlen (arg) + 1;
+  cmd = mymalloc (YALS, len);
+  sprintf (cmd, fmt, arg);
+  file = popen (cmd, "r");
+  myfree (YALS, cmd, len);
+  closefile = 2;
+  filename= arg;
+  return 1;
+}
+
+static unsigned long long atoull (const char * str) {
+  unsigned long long res = 0;
+  const char * p = str;
+  int ch;
+  while (isdigit (ch = *p++))
+    res = 10ull * res + (ch - '0');
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static char valine[76];
+static int nvaline;
+
+static void printvaline () {
+  fputc ('v', stdout);
+  assert (nvaline < sizeof valine);
+  fputs (valine, stdout);
+  fputc ('\n', stdout);
+  nvaline = 0;
+}
+
+static void printval (int lit) {
+  char buffer[32];
+  int len;
+  sprintf (buffer, " %d", lit);
+  len = strlen (buffer);
+  if (nvaline + len + 1 >= sizeof valine) printvaline ();
+  strcpy (valine + nvaline, buffer);
+  nvaline += len;
+  assert (nvaline < sizeof valine);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void stats () {
+#ifdef PALSAT
+  double t, w;
+  int i;
+  for (i = 0; i < threads; i++) {
+    Yals * y = worker[i].yals;
+    msg ("");
+    yals_msg (y, 0, "final worker %d minimum of %d unsatisfied clauses",
+      i, yals_minimum (y));
+    if (verbose) yals_stats (y);
+  }
+  msg ("");
+  w = getime ();
+  t = yals_process_time ();
+  msg ("total wall clock time of %.2f seconds", w);
+  msg ("total process time of %.2f seconds", t);
+  msg ("utilization %.1f%% for %d threads",
+    (w ? 100.0*t/w/(double)threads : 0), threads);
+#else
+  msg ("");
+  msg ("final minimum of %d unsatisfied clauses", yals_minimum (yals));
+  if (verbose) yals_stats (yals);
+  msg ("total process time of %.2f seconds", getime ());
+#endif
+  msg ("maximally allocated %.1f MB", mem.max/(double)(1<<20));
+}
+
+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 [yalsat] CAUGHT SIGNAL %d\nc\n", sig);
+  fflush (stdout);
+}
+
+static int catchedsig;
+
+static void catchsig (int sig) {
+  if (!catchedsig) {
+    fputs ("c s UNKNOWN\n", stdout);
+    fflush (stdout);
+    catchedsig = 1;
+    caughtsigmsg (sig);
+    stats ();
+    caughtsigmsg (sig);
+  }
+  resetsighandlers ();
+  raise (sig);
+}
+
+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 int isnum (const char * p) {
+  int ch;
+  if ((ch = *p) == '-') ch = *++p;
+  if (!isdigit (ch)) return 0;
+  while (isdigit (ch = *++p))
+    ;
+  return !ch;
+}
+
+static int isfile (const char * p) {
+  struct stat buf;
+  return !stat (p, &buf);
+}
+
+static int setopt (const char * name, int val) {
+  int res;
+#ifdef PALSAT
+  int i;
+  res = 0;
+  for (i = 0; i < threads; i++)
+    res = yals_setopt (worker[i].yals, name, val);
+#else
+  res = yals_setopt (yals, name, val);
+#endif
+  return res;
+}
+
+static int opt (const char * arg) {
+  int res = 0;
+  assert (arg[0] == '-');
+  if (arg[1] == '-') {
+    if (arg[2] == 'n' && arg[3] == 'o' && arg[4] == '-')
+      res = setopt (arg + 5, 0);
+    else {
+      int len = strlen (arg);
+      char * name = mymalloc (0, len - 1), * val;
+      strcpy (name, arg + 2);
+      for (val = name; *val && *val != '='; val++)
+        ;
+      if (!*val) res = setopt (name, 1);
+      else if (*val == '=') {
+        *val++ = 0;
+        if (isnum (val))
+          res = setopt (name, atoi (val));
+      }
+      myfree (0, name, len - 1);
+    }
+  }
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+#ifdef PALSAT
+
+static void lockmsg (void* dummy) {
+  (void) dummy;
+  pthread_mutex_lock (&lock.msg);
+}
+
+static void unlockmsg (void* dummy) {
+  (void) dummy;
+  pthread_mutex_unlock (&lock.msg);
+}
+
+/* Attempts to CAS done from 0 to r where r != 0. If suceeded,
+sets winner to w and returns 0. Otherwise, returns -1. */
+static int setdone (int w, int r) {
+  int res;
+  assert(r != 0);
+  LOCK (done);
+  if (r) { winner = w; done = r; }
+  res = winner;
+  winner = w;
+  UNLOCK (done);
+  return res;
+}
+
+static int workers_should_terminate (void * dummy) {
+  if (waitall) return 0;
+  int res;
+  (void) dummy;
+  LOCK (done);
+  res = done;
+  UNLOCK (done);
+  return res;
+}
+
+static void * run (void * p) {
+  Worker * w = p;
+  int res, widx = w - worker;
+  assert (0 <= widx), assert (widx < threads);
+  res = yals_sat (w->yals);
+  if (res) {
+    if (!setdone (widx, res)) {
+      msg ("worker %d wins with result %d", widx, res);
+    } else {
+      msg ("worker %d done with result %d", widx, res);
+    }
+  }
+  else msg ("worker %d returns with %d", widx, res);
+  return p;
+}
+
+static int palsat () {
+  int i;
+  for (i = 0; i < threads; i++)
+    if (pthread_create (&worker[i].thread, 0, run, worker + i))
+      die ("failed to created thread %d", i);
+    else msg ("created thread %d", i);
+  for (i = 0; i < threads; i++)
+    if (pthread_join (worker[i].thread, 0))
+      die ("failed to join thread %d", i);
+    else msg ("joined thread %d", i);
+  msg ("");
+  return done;
+
+}
+
+#endif
+/*------------------------------------------------------------------------*/
+
+#ifdef PALSAT
+static void initlocks () {
+  pthread_mutex_init (&lock.mem, 0);
+  pthread_mutex_init (&lock.msg, 0);
+  pthread_mutex_init (&lock.done, 0);
+}
+
+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 ("'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 {
+    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 '/proc/cpuinfo' on Intel");
+      }
+      useprocpuinfo = 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 %d workers", THREADS);
+    res = THREADS;
+  }
+
+  return res;
+}
+#endif
+
+static void usage () {
+#ifdef PALSAT
+  printf (
+    "usage: palsat [<option> ...] [<file> [<seed>]]\n");
+#else
+  printf (
+    "usage: yalsat [<option> ...] [<file> [<seed> [<flips> [<mems>]]]]\n");
+#endif
+  printf ("\n");
+  printf ("main options: \n");
+  printf ("\n");
+  printf ("-h          print this command line option summary\n");
+  printf ("--version   version number and exit\n");
+  printf ("\n");
+#ifdef PALSAT
+  printf ("-t <num>  number of worker threads (system default %d)\n",
+    getsystemcores (0));
+  printf ("--waitall wait for all threads to finish (for benchmarking)\n");
+  printf ("\n");
+#endif
+  printf ("-v     increase verbose level (see '--verbose')\n");
+  printf ("-n     do not print witness (see '--witness')\n");
+#ifndef NDEBUG
+  printf ("-l     enable internal logging (see '--logging')\n");
+  printf ("-c     enable internal checking (see '--checking')\n");
+#endif
+  printf ("\n");
+  printf ("--bfs  BFS (same as '--pick=1')\n");
+  printf ("--dfs  DFS (same as '--pick=2')\n");
+  printf ("--rfs  relaxed BFS (same as '--pick=3')\n");
+  printf ("--pfs  pseudo BFS (same as '--pick=-1')\n");
+  printf ("--ufs  uniform random search (same as '--pick=0')\n");
+  printf ("\n");
+  printf ("other options (also available through API): \n");
+  printf ("\n");
+  {
+    Yals * y = yals_new_with_mem_mgr (0, mymalloc, myrealloc, myfree);
+    yals_usage (y);
+    yals_del (y);
+  }
+  printf ("\n");
+  printf ("The long options are by default used as '--<name>=<val>'.\n");
+  printf ("Alternatively '--<name>' is the same as '--<name>=1' and\n");
+  printf ("further '--no-<name>' is the same as '--<name>=0'.\n");
+}
+
+static void version () { printf ("%s\n", yals_version ()); }
+
+int main (int argc, char** argv) {
+  int i, ch, sign, lit, res, m, n;
+  for (i = 1; i < argc; i++) {
+#ifdef PALSAT
+    if (!strcmp (argv[i], "-t")) { i++; continue; }
+#endif
+    if (!strcmp (argv[i], "-v")) { verbose++; continue; }
+    if (!strcmp (argv[i], "--version")) { version (); exit (0); }
+    if (!strcmp (argv[i], "-h")) { usage (); exit (0); }
+  }
+#ifdef PALSAT
+  printf ("c xnfSAT XNF Local Search Solver\n");
+  printf ("c Parallel Simple Portfolio Version\n");
+#else
+  printf ("c xnfSAT XNF Local Search Solver\n");
+  printf ("c Sequential Standalone Version\n");
+#endif
+  yals_banner ("c ");
+#ifdef PALSAT
+  for (i = 1; i < argc; i++) {
+    if (strcmp (argv[i], "-t")) continue;
+    if (++i == argc) die ("argument to '-t' missing (try '-h')");
+    if (threadset)
+      die ("multiple '-t' options: '-t %d' and '-t %s' (try '-h')",
+        threads, argv[i]);
+    if ((threads = atoi (argv[i])) < 1)
+      die ("invalid argument in '-t %s' (try '-h')", argv[i]);
+    threadset = 1;
+  }
+  initlocks ();
+  start = currentime ();
+  if (threadset)
+    msg ("using %d solver instances and %d worker threads ('-t %d')",
+      threads, threads, threads);
+  else  {
+    threads = getsystemcores (1);
+    msg ("using %d solver instances and %d worker threads (default)",
+      threads, threads);
+  }
+  msg ("creating %d solver instances", threads);
+  worker = mymalloc (0, threads * sizeof *worker);
+  for (i = 0; i < threads; i++) {
+    char prefix[80];
+    Yals * y = yals_new_with_mem_mgr (0, mymalloc, myrealloc, myfree);
+    yals_setmsglock (y, lockmsg, unlockmsg, 0);
+    yals_seterm (y, workers_should_terminate, 0);
+//    if (i % 4 == 3) yals_setopt (y, "toggleuniform", 1);
+    sprintf (prefix, "c %02d ", i);
+    yals_setprefix (y, prefix);
+    yals_setime (y, getime);
+    worker[i].yals = y;
+  }
+#else
+  yals = yals_new_with_mem_mgr (0, mymalloc, myrealloc, myfree);
+  yals_setprefix (yals, "c ");
+#endif
+  verbose = 0;
+  for (i = 1; i < argc; i++) {
+#ifdef PALSAT
+    if (!strcmp (argv[i], "-t")) { i++; assert (i < argc); continue; }
+    if (!strcmp (argv[i], "--waitall")) { waitall++; assert (i < argc); continue; }
+#endif
+    if (!strcmp (argv[i], "-v"))
+      setopt ("verbose", ++verbose);
+    else if (!strcmp (argv[i], "-n"))
+      setopt ("witness", 0);
+#ifndef NDEBUG
+    else if (!strcmp (argv[i], "-l"))
+      setopt ("logging", ++logging);
+    else if (!strcmp (argv[i], "-c"))
+      setopt ("checking", ++checking);
+#endif
+    else if (!strcmp (argv[i], "--bfs")) setopt ("pick", 1);
+    else if (!strcmp (argv[i], "--dfs")) setopt ("pick", 2);
+    else if (!strcmp (argv[i], "--rfs")) setopt ("pick", 3);
+    else if (!strcmp (argv[i], "--pfs")) setopt ("pick", -1);
+    else if (!strcmp (argv[i], "--ufs")) setopt ("pick", 0);
+    else if (isnum (argv[i])) {
+#ifdef PALSAT
+      if (seedset) die ("seed already set (try '-h')");
+#else
+      if (memsset) die ("more than three numbers (try '-h')");
+      else if (flipsset) mems = atoll (argv[i]), memsset = 1;
+      else if (seedset) flips = atoll (argv[i]), flipsset = 1;
+#endif
+      else seed = atoull (argv[i]), seedset = 1;
+    } else if (!strcmp (argv[i], "-")) {
+      if (filename)
+        die ("file '%s' and '-' specified (try '-h')", filename);
+      file = stdin, filename = "<stdin>";
+      assert (!closefile);
+    } else if (argv[i][0] == '-') {
+      if (!opt (argv[i]))
+        die ("invalid command line option '%s'", argv[i]);
+    } else if (!isfile (argv[i]))
+      die ("'%s' does not seem to be a file", argv[i]);
+    else if (cmd (argv[i], ".gz", "gunzip -c %s"))
+      ;
+    else if (cmd (argv[i], ".bz2", "bunzip -d -c %s"))
+      ;
+    else if (cmd (argv[i], ".xz", "xz -d -c %s"))
+      ;
+    else if (!(file = fopen (argv[i], "r")))
+      die ("can not read '%s'", argv[i]);
+    else
+      closefile = 1, filename = argv[i];
+  }
+  setsighandlers ();
+  verbose = yals_getopt (YALS, "verbose");
+  if (verbose) {
+#ifdef PALSAT
+    Yals * y = worker[0].yals;
+    yals_setprefix (y, "c ");
+    yals_showopts (y);
+    yals_setprefix (y, "c 00 ");
+#else
+    yals_showopts (yals);
+#endif
+  }
+#ifndef NDEBUG
+  logging = yals_getopt (YALS, "logging");
+  checking = yals_getopt (YALS, "checking");
+  if (logging && verbose < 2) setopt ("verbose", verbose = 2);
+#endif
+  if (seedset) {
+    msg ("using specified seed %llu", seed);
+    yals_srand (YALS, seed);
+  } else msg ("no seed specified (using default 0)");
+#ifdef PALSAT
+  {
+    unsigned long long newseed = seed;
+    for (i = 1; i < threads; i++) {
+      newseed *= 1103515245;
+      newseed += 12345;
+      yals_srand (worker[i].yals, newseed);
+      msg ("worker %d uses seed %llu", i, newseed);
+    }
+  }
+#else
+  if (flipsset) msg ("using specified flips limit %lld", flips);
+  else msg ("no flips limit set (by default)");
+  if (memsset) msg ("using specified mems limit %lld", mems);
+  else msg ("no mems limit set (by default)");
+#endif
+  if (!file) file = stdin, filename = "<stdin>";
+  msg ("parsing '%s'", filename);
+HEADER:
+  ch = getc (file);
+  if (ch == 'c') {
+    while ((ch = getc (file)) != '\n')
+      if (ch == EOF) perr ("end-of-file in comment");
+    goto HEADER;
+  }
+  if (ch != 'p') perr ("expected 'p' or 'c'");
+  ungetc (ch, file);
+  if (fscanf (file, "p cnf %d %d", &m, &n) != 2 || m < 0 || n < 0) {
+    if (fscanf (file, "xnf %d %d", &m, &n) != 2 || m < 0 || n < 0)
+      perr ("invalid header");
+  }
+  msg ("parsed header 'p c/xnf %d %d'", m, n);
+  V = m, C = n;
+  msg ("clause variable ratio %.2f", average (C,V));
+  lit = 0;
+BODY:
+  ch = getc (file);
+  if (ch == EOF) {
+    if (n >= 1) perr ("one clause missing");
+    if (n > 0) perr ("clauses missing");
+    if (lit) perr ("zero sentinel missing at end-of-file");
+    goto DONE;
+  }
+  if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') goto BODY;
+  if (ch == 'c') {
+    while ((ch = getc (file)) != '\n')
+      if (ch == EOF) perr ("end-of-file in comment");
+    goto BODY;
+  }
+  if (ch == 'x') {
+#ifdef PALSAT
+    int i;
+    for (i = 0; i < threads; i++) {
+      yals_begin_xor_clause(worker[i].yals);
+    }
+#else
+    yals_begin_xor_clause(yals);
+#endif
+    goto BODY;
+  }
+  if (ch == '-') {
+    ch = getc (file);
+    if (ch == '0') perr ("expected non-zero digit");
+    sign = -1;
+  } else sign = 1;
+  if (!isdigit (ch)) perr ("expected digit");
+  lit = ch - '0';
+  while (isdigit (ch = getc (file)))
+    lit = 10*lit + (ch - '0');
+  if (ch != EOF && ch != ' ' && ch != '\r' && ch != '\n')
+    perr ("expected space or new-line");
+  if (lit > V) perr ("maximum variable index exceeded");
+  if (!n) perr ("too many clauses");
+  lit *= sign;
+  if (!lit) n--;
+#ifdef PALSAT
+  {
+    int i;
+    for (i = 0; i < threads; i++)
+      yals_add (worker[i].yals, lit);
+  }
+#else
+  yals_add (yals, lit);
+#endif
+  goto BODY;
+DONE:
+  if (closefile == 1) fclose (file);
+  if (closefile == 2) pclose (file);
+  msg ("finished parsing after %.2f seconds",  getime ());
+  msg ("allocated %.1f MB after parsing", mem.allocated/(double)(1<<20));
+#ifdef PALSAT
+  res = palsat ();
+#else
+  if (flipsset) yals_setflipslimit (yals, flips);
+  if (memsset) yals_setmemslimit (yals, mems);
+  res = yals_sat (yals);
+  msg ("");
+#endif
+  if (res != 20) {
+    if (res == 10) fputs ("s SATISFIABLE\n", stdout);
+    else fputs ("s CURRENT BEST\n", stdout);
+    if (yals_getopt (WINNER, "witness")) {
+      fflush (stdout);
+      for (i = 1; i <= V; i++) {
+        lit = (yals_deref (WINNER, i) > 0) ? i : -i;
+        printval (lit);
+      }
+      printval (0);
+      if (nvaline) printvaline ();
+    }
+  } else fputs ("s UNSATISFIABLE\n", stdout);
+  fflush (stdout);
+  resetsighandlers ();
+  stats ();
+#ifdef PALSAT
+  for (i = 0; i < threads; i++) yals_del (worker[i].yals);
+  myfree (0, worker, threads * sizeof *worker);
+#else
+  yals_del (yals);
+#endif
+  msg ("");
+  msg ("%s returns with exit code %d", NAME, res);
+  return res;
+}
diff --git a/makefile.in b/makefile.in
new file mode 100644
index 0000000..1498528
--- /dev/null
+++ b/makefile.in
@@ -0,0 +1,28 @@
+MAKEFLAGS=-j $(if $(CORES),$(CORES),1)
+CC=@CC@
+CFLAGS=@CFLAGS@
+LIBS=@LIBS@
+all: xnfsat xnfsat_parallel libyals.a
+xnfsat: main.o libyals.a makefile
+	$(CC) $(CFLAGS) -o $@ main.o -L. -lyals $(LIBS)
+xnfsat_parallel: pain.o libyals.a makefile
+	$(CC) $(CFLAGS) -o $@ pain.o -L. -lyals $(LIBS) -pthread
+libyals.a: yals.o config.o
+	ar rc $@ yals.o config.o
+	ranlib $@
+main.o: main.c yals.h yils.h makefile
+	$(CC) $(CFLAGS) -c main.c
+pain.o: main.c yals.h yils.h makefile
+	$(CC) $(CFLAGS) -DPALSAT -o $@ -pthread -c main.c
+yals.o: yals.c yals.h yils.h makefile
+	$(CC) $(CFLAGS) -c yals.c
+config.o: config.c config.h cflags.h yils.h makefile
+	$(CC) $(CFLAGS) $(CFLAGS) -c config.c
+config.h: VERSION yals.c yals.h yils.h main.c
+	rm -f $@; ./mkconfig.sh >$@
+cflags.h: makefile
+	rm -f $@
+	echo '#define YALS_CC "$(shell $(CC) --version|head -1)"' >>$@
+	echo '#define YALS_CFLAGS "$(CFLAGS)"' >>$@
+clean:
+	rm -f yalsat *.a *.o makefile config.h cflags.h
diff --git a/mkconfig.sh b/mkconfig.sh
new file mode 100755
index 0000000..9f8db4e
--- /dev/null
+++ b/mkconfig.sh
@@ -0,0 +1,20 @@
+#!/bin/sh
+
+die () {
+   echo "*** mkconfig: $*" 1>&2
+   exit 1
+}
+
+[ -f makefile ] || die "can not find 'makefile'"
+
+cat<<EOF
+/**************************************************************/
+/* Automatically generated by './mkconfig.sh'.  Do note edit! */
+/**************************************************************/
+EOF
+
+echo "#define YALS_OS \"`uname -srmn`\""
+echo "#define YALS_COMPILED \"`date`\""
+echo "#define YALS_RELEASED \"Mon Mar 29 04:24:00 PM EDT 2021\""
+echo "#define YALS_VERSION \"03v\""
+echo "#define YALS_ID \"3fbd7e675d25772a9f8c4bdb0f90d4ee6d64dea3\""
diff --git a/yals.c b/yals.c
new file mode 100644
index 0000000..0ac042a
--- /dev/null
+++ b/yals.c
@@ -0,0 +1,3896 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2021 xnfSAT Authors                                           */
+/*-------------------------------------------------------------------------*/
+
+#include "yals.h"
+#include <stdbool.h>
+
+/*------------------------------------------------------------------------*/
+
+#define YALSINTERNAL
+#include "yils.h"
+
+/*------------------------------------------------------------------------*/
+
+#include <assert.h>
+#include <ctype.h>
+#include <limits.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+
+#include <stdlib.h>
+
+#if defined(__linux__)
+#include <fpu_control.h>	// Set FPU to double precision on Linux.
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#define YALS_INT64_MAX		(0x7fffffffffffffffll)
+#define YALS_DEFAULT_PREFIX	"c "
+
+/*------------------------------------------------------------------------*/
+
+#define NEWN(P,N) \
+  do { (P) = yals_malloc (yals, (N)*sizeof *(P)); } while (0)
+
+#define DELN(P,N) \
+  do { yals_free (yals, (P), (N)*sizeof *(P)); } while (0)
+
+#define CLEARN(P,N) \
+  do { memset((P), 0, (N)*sizeof *(P)); } while (0)
+
+#define RSZ(P,O,N) \
+do { \
+  (P) = yals_realloc (yals, (P), (O)*sizeof *(P), (N)*sizeof *(P)); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define STACK(T) \
+  struct { T * start; T * top; T * end; }
+
+#define INIT(S) \
+  do { (S).start = (S).top = (S).end = 0; } while (0)
+
+#define SIZE(S) \
+  ((S).end - (S).start)
+
+#define COUNT(S) \
+  ((S).top - (S).start)
+
+#define EMPTY(S) \
+  ((S).top == (S).start)
+
+#define FULL(S) \
+  ((S).top == (S).end)
+
+#define CLEAR(S) \
+  do { (S).top = (S).start; } while (0)
+
+#define ENLARGE(S) \
+do { \
+  size_t OS = SIZE (S); \
+  size_t OC = COUNT (S); \
+  size_t NS = OS ? 2*OS : 1; \
+  assert (OC <= OS); \
+  RSZ ((S).start, OS, NS); \
+  (S).top = (S).start + OC; \
+  (S).end = (S).start + NS; \
+} while (0)
+
+#define FIT(S) \
+do { \
+  size_t OS = SIZE (S); \
+  size_t NS = COUNT (S); \
+  RSZ ((S).start, OS, NS); \
+  (S).top = (S).start + NS; \
+  (S).end = (S).start + NS; \
+} while (0)
+
+#define RESET(S,N) \
+do { \
+  assert ((N) <= SIZE (S) ); \
+  (S).top = (S).start + (N); \
+} while (0)
+
+#define PUSH(S,E) \
+do { \
+  if (FULL(S)) ENLARGE (S); \
+  *(S).top++ = (E); \
+} while (0)
+
+#define POP(S) \
+  (assert (!EMPTY (S)), *--(S).top)
+
+#define TOP(S) \
+  (assert (!EMPTY (S)), (S).top[-1])
+
+#define PEEK(S,P) \
+  (assert ((P) < COUNT(S)), (S).start[(P)])
+
+#define POKE(S,P,E) \
+  do { assert ((P) < COUNT(S)); (S).start[(P)] = (E); } while (0)
+
+#define RELEASE(S) \
+do { \
+  size_t N = SIZE (S); \
+  DELN ((S).start, N); \
+  INIT (S); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+typedef unsigned Word;
+
+#define LD_BITS_PER_WORD	5
+#define BITS_PER_WORD		(8*sizeof (Word))
+#define BITMAPMASK		(BITS_PER_WORD - 1)
+
+#define WORD(BITS,N,IDX) \
+  ((BITS)[ \
+    assert ((IDX) >= 0), \
+    assert (((IDX) >> LD_BITS_PER_WORD) < (N)), \
+    ((IDX) >> LD_BITS_PER_WORD)])
+
+#define BIT(IDX) \
+  (((Word)1u) << ((IDX) & BITMAPMASK))
+
+#define GETBIT(BITS,N,IDX) \
+  (WORD(BITS,N,IDX) & BIT(IDX))
+
+#define SETBIT(BITS,N,IDX) \
+  do { WORD(BITS,N,IDX) |= BIT(IDX); } while (0)
+
+#define CLRBIT(BITS,N,IDX) \
+  do { WORD(BITS,N,IDX) &= ~BIT(IDX); } while (0)
+
+#define NOTBIT(BITS,N,IDX) \
+  do { WORD(BITS,N,IDX) ^= BIT(IDX); } while (0)
+
+/*------------------------------------------------------------------------*/
+
+#define MIN(A,B) (((A) < (B)) ? (A) : (B))
+#define MAX(A,B) (((A) > (B)) ? (A) : (B))
+#define ABS(A) (((A) < 0) ? (assert ((A) != INT_MIN), -(A)) : (A))
+
+#define SWAP(T,A,B) \
+  do { T TMP = (A); (A) = (B); (B) = (TMP); } while (0)
+
+/*------------------------------------------------------------------------*/
+#ifndef NDEBUG
+#define LOG(ARGS...) \
+do { \
+  if (!yals->opts.logging.val) break; \
+  yals_log_start (yals, ##ARGS); \
+  yals_log_end (yals); \
+} while (0)
+#define LOGLITS(LITS,ARGS...) \
+do { \
+  const int * P; \
+  if (!yals->opts.logging.val) break; \
+  yals_log_start (yals, ##ARGS); \
+  fprintf (yals->out, " clause :"); \
+  for (P = (LITS); *P; P++) \
+    fprintf (yals->out, " %d", *P); \
+  yals_log_end (yals); \
+} while (0)
+#define LOGCIDX(CIDX,ARGS...) \
+do { \
+  const int * LITS; \
+  if ((CIDX) >= yals->nclauses) \
+    LITS = yals_xlits(yals, (CIDX) - yals->nclauses); \
+  else \
+    LITS = yals_lits (yals, (CIDX)); \
+  const int * P; \
+  if (!yals->opts.logging.val) break; \
+  yals_log_start (yals, ##ARGS); \
+  if ((CIDX) >= yals->nclauses) \
+    fprintf (yals->out, " XOR clause %d :", (CIDX) - yals->nclauses); \
+  else \
+    fprintf (yals->out, " OR clause %d :", (CIDX)); \
+  for (P = (LITS); *P; P++) \
+    fprintf (yals->out, " %d", *P); \
+  yals_log_end (yals); \
+} while (0)
+#else
+#define LOG(ARGS...) do { } while (0)
+#define LOGLITS(ARGS...) do { } while (0)
+#define LOGCIDX(ARGS...) do { } while (0)
+#endif
+/*------------------------------------------------------------------------*/
+
+#define LENSHIFT	6
+#define MAXLEN		((1<<LENSHIFT)-1)
+#define LENMASK		MAXLEN
+
+/*------------------------------------------------------------------------*/
+
+enum ClausePicking {
+  PSEUDO_BFS_CLAUSE_PICKING = -1,
+  RANDOM_CLAUSE_PICKING = 0,
+  BFS_CLAUSE_PICKING = 1,
+  DFS_CLAUSE_PICKING = 2,
+  RELAXED_BFS_CLAUSE_PICKING = 3,
+  UNFAIR_BFS_CLAUSE_PICKING = 4,
+};
+
+/*------------------------------------------------------------------------*/
+
+#define OPTSTEMPLATE \
+  OPT (best,0,0,1,"always pick best assignment during restart"); \
+  OPT (breakzero,0,0,1,"always use break zero literal if possible"); \
+  OPT (cached,1,0,1,"use cached assignment during restart"); \
+  OPT (cachedinv,0,0,1,"use inverse minimum for selecting cached assignments"); \
+  OPT (cacheduni,0,0,1,"pick random cached assignment uniformly"); \
+  OPT (cachemax,(1<<10),0,(1<<20),"max cache size of saved assignments"); \
+  OPT (cachemin,1,0,(1<<10),"minimum cache size of saved assignments"); \
+  OPT (cb,250,50,2000,"the break parameter c_b, times a 100 (range 0.5-20.0)"); \
+  OPT (correct,1,0,1,"correct CB value depending on maximum length"); \
+  OPT (crit,1,0,1,"dynamic break values (using critical lits)"); \
+  OPT (defrag,1,0,1,"defragemtation of unsat queue"); \
+  OPT (fixed,4,0,INT_MAX,"fixed default strategy frequency (1=always)"); \
+  OPT (geomfreq,66,0,100,"geometric picking first frequency (percent)"); \
+  OPT (hitlim,-1,-1,INT_MAX,"minimum hit limit"); \
+  OPT (keep,0,0,1,"keep assignment during restart"); \
+  OPT (minchunksize,(1<<8),2,(1<<20),"minium queue chunk size"); \
+  OPT (pick,4,-1,4,"-1=pbfs,0=rnd,1=bfs,2=dfs,3=rbfs,4=ubfs"); \
+  OPT (pol,-1,-1,1,"negative=-1 positive=1 or random=0 polarity"); \
+  OPT (prep,1,0,1,"preprocessing through unit propagation"); \
+  OPT (rbfsrate,10,1,INT_MAX,"relaxed BFS rate"); \
+  OPT (reluctant,1,0,1,"reluctant doubling of restart interval"); \
+  OPT (restart,100000,0,INT_MAX,"basic (inner) restart interval"); \
+  OPT (restartouter,0,0,1,"enable restart outer"); \
+  OPT (restartouterfactor,100,1,INT_MAX,"outer restart interval factor"); \
+  OPT (setfpu,1,0,1,"set FPU to use double precision on Linux"); \
+  OPT (termint,1000,0,INT_MAX,"termination call back check interval"); \
+  OPT (toggleuniform,0,0,1,"toggle uniform strategy"); \
+  OPT (unfairfreq,50,0,100,"unfair picking first frequency (percent)"); \
+  OPT (uni,-1,-1,1,"weighted=0,uni=1,antiuni=-1 clause weights"); \
+  OPT (unipick,-1,-1,4,"clause picking strategy for uniform formulas"); \
+  OPT (unirestarts,0,0,INT_MAX,"max number restarts for uniform formulas"); \
+  OPT (verbose,0,0,2,"set verbose level"); \
+  OPT (weight,5,1,7,"[DISABLED] maximum clause weight"); \
+  OPT (weight2,200,0,1000,"clause weight times 100 for clause len == 2"); \
+  OPT (weight3,300,0,1000,"clause weight times 100 for clause len == 3"); \
+  OPT (weight4,300,0,1000,"clause weight times 100 for clause len == 4"); \
+  OPT (weight5,300,0,1000,"clause weight times 100 for clause len == 5"); \
+  OPT (weight6,300,0,1000,"clause weight times 100 for clause len == 6"); \
+  OPT (weight7,300,0,1000,"clause weight times 100 for clause len == 7"); \
+  OPT (weight8,300,0,1000,"clause weight times 100 for clause len >= 8"); \
+  OPT (witness,0,0,1,"print witness"); \
+  OPT (xorweight,500,0,1000,"constant weight of XOR clauses for weighted break, times a 100 (range 0.0-10.0)"); \
+  OPT (maxorigvar,0,0,INT_MAX,"index (inclusive) of maximum original (non-auxilliary) variable in CNF-encoded XNF"); \
+  OPTSTEMPLATENDEBUG
+
+#ifndef NDEBUG
+#define OPTSTEMPLATENDEBUG \
+  OPT (logging, 0, 0, 1, "set logging level"); \
+  OPT (checking, 0, 0, 1, "set checking level");
+#else
+#define OPTSTEMPLATENDEBUG
+#endif
+
+#define OPT(NAME,DEFAULT,MIN,MAX,DESCRIPTION) Opt NAME
+
+/*------------------------------------------------------------------------*/
+
+#define STRATSTEMPLATE \
+  STRAT (cached,0); \
+  STRAT (correct,0); \
+  STRAT (pol,0); \
+  STRAT (uni,0); \
+  STRAT (weight,0);
+
+#define STRAT(NAME,ENABLED) int NAME
+
+/*------------------------------------------------------------------------*/
+
+#ifndef NYALSMEMS
+#define ADD(NAME,NUM) \
+do { \
+  yals->stats.mems.all += (NUM); \
+  yals->stats.mems.NAME += (NUM); \
+} while (0)
+#else
+#define ADD(NAME,NUM) do { } while (0)
+#endif
+
+#define INC(NAME) ADD (NAME, 1)
+
+/*------------------------------------------------------------------------*/
+
+#define assert_valid_occs(OCCS) \
+  do { assert (0 <= OCCS), assert (OCCS < yals->noccs); } while (0)
+
+#define assert_valid_idx(IDX) \
+  do { assert (0 <= IDX), assert (IDX < yals->nvars); } while (0)
+
+#define assert_valid_cidx(CIDX) \
+  do { assert (0 <= CIDX), assert (CIDX < yals->nclauses); } while (0)
+
+#define assert_valid_xcidx(CIDX) \
+  do { assert (0 <= CIDX), assert (CIDX < yals->nxclauses); } while (0)
+
+#define assert_valid_len(LEN) \
+  do { assert (0 <= LEN), assert (LEN <= MAXLEN); } while (0)
+
+#define assert_valid_pos(POS) \
+  do { \
+    assert (0 <= POS), assert (POS < COUNT (yals->unsat.stack)); \
+} while (0)
+
+/*------------------------------------------------------------------------*/
+
+typedef struct RDS { unsigned u, v; } RDS;
+
+typedef struct RNG { unsigned z, w; } RNG;
+
+typedef struct Mem {
+  void * mgr;
+  YalsMalloc malloc;
+  YalsRealloc realloc;
+  YalsFree free;
+} Mem;
+
+typedef struct Strat { STRATSTEMPLATE } Strat;
+
+typedef struct Stats {
+  int best, worst, last, tmp, maxstacksize;
+  int64_t flips, bzflips, hits, unsum;
+  struct {
+    struct { int64_t count; } outer;
+    struct { int64_t count, maxint; } inner;
+  } restart;
+  struct { struct { int chunks, lnks; } max; int64_t unfair; } queue;
+  struct { int64_t inserted, replaced, skipped; } cache;
+  struct { int64_t search, neg, falsepos, truepos; } sig;
+  struct { int64_t def, rnd; } strat;
+  struct { int64_t best, cached, keep, pos, neg, rnd; } pick;
+  struct { int64_t count, moved; } defrag;
+  struct { size_t current, max; } allocated;
+  struct { volatile double total, defrag, restart, entered; } time;
+#ifdef __GNUC__
+  volatile int flushing_time;
+#endif
+#ifndef NYALSMEMS
+  struct { long long all, crit, lits, occs, read, update, weight; } mems;
+#endif
+#ifndef NYALSTATS
+  int64_t * inc, * dec, broken, made; int nincdec;
+  struct { unsigned min, max; } wb;
+#endif
+} Stats;
+
+typedef struct Limits {
+#ifndef NYALSMEMS
+  int64_t mems;
+#endif
+  int64_t flips;
+  struct {
+    struct { int64_t lim, interval; } outer;
+    struct { int64_t lim; union { int64_t interval; RDS rds; }; } inner;
+  } restart;
+  struct { int min; } report;
+  int term;
+} Limits;
+
+typedef struct Lnk {
+  int cidx;
+  struct Lnk * prev, * next;
+} Lnk;
+
+typedef union Chunk {
+  struct { int size; union Chunk * next; };
+  Lnk lnks[1];					// actually of 'size'
+} Chunk;
+
+typedef struct Queue {
+  int count, chunksize, nchunks, nlnks, nfree;
+  Lnk * first, * last, * free;
+  Chunk * chunks;
+} Queue;
+
+typedef struct Exp {
+  struct { STACK(double) two, cb; } table;
+  struct { unsigned two, cb; } max;
+  struct { double two, cb; } eps;
+} Exp;
+
+typedef struct Opt { int val, def, min, max; } Opt;
+
+typedef struct Opts { char * prefix; OPTSTEMPLATE } Opts;
+
+typedef struct Callbacks {
+  double (*time)(void);
+  struct { void * state; int (*fun)(void*); } term;
+  struct { void * state; void (*lock)(void*); void (*unlock)(void*); } msg;
+} Callbacks;
+
+typedef unsigned char U1;
+typedef unsigned short U2;
+typedef unsigned int U4;
+
+typedef struct FPU {
+#ifdef __linux__
+  fpu_control_t control;
+#endif
+  int saved;
+} FPU;
+
+struct Yals {
+  RNG rng;
+  FILE * out;
+  struct { int usequeue; Queue queue; STACK(int) stack; } unsat;
+  int nvars;
+  // Stores offsets into `occs` of literals. See `yals_(x)refs`
+  int * refs;
+  // Number of times each var is flipped
+  int64_t * flips;
+  STACK(signed char) mark;
+  // Whether the current parsing clause is trivial (contains x and -x)
+  int trivial;
+  // Whether the formula is false (contains empty clause)
+  int mt;
+  // During parsing of a XOR clause, its parity. Unused elsewhere
+  int xorParity;
+  int uniform, pick;
+  // The working assignment, a bitfield
+  Word * vals;
+  Word * best, * tmp;
+  // Parts of the assignment forced by unit propagation. See `yals_set_units`
+  // `clear` has 0s for vars which must be false
+  Word * clear;
+  // `set` has 1s for vars which must be true
+  Word * set;
+  // Number of machine words required to store the assignment
+  int nvarwords;
+  // Clause database. Effectively just the parsed DIMACS input
+  STACK(int) cdb;
+  // XOR clause database. Like `cdb`, but only variable indices are stored - not literals
+  STACK(int) xcdb;
+  // PEEK(xparitydb, cidx) is the parity of the cidx-th XOR clause. That is,
+  // - 0 iff the clause is true when an odd number of *variables* in it are
+  // - 1 iff even number
+  // TODO(WN): bitfield would do
+  STACK(int) xparitydb;
+  // Trail includes all the unit clauses
+  STACK(int) trail;
+  STACK(int) phases;
+  // During parsing, the clause being parsed. Not used elsewhere
+  STACK(int) clause;
+  // During parsing, whether the current clause is OR (0) or XOR (1)
+  int isXor;
+  STACK(int) mins;
+  // Bytes needed per-OR-clause to count satisfied lits.
+  int satcntbytes;
+  // For the cidx-th OR clause, satcntN[cidx] is the number of SAT literals in it
+  union { U1 * satcnt1; U2 * satcnt2; U4 * satcnt4; };
+  // For the cidx-th XOR clause, xorsat[cidx] is 1 iff that clause is SAT
+  // TODO(WN): bitfield would do
+  U1 * xorsat;
+  // Variable occurrences in clauses. See `yals_(x)occs`
+  // Format:
+  // flatten([ [ (clause idx << MAXLEN | clause length) for OR clauses in which `x` occurs ] ++ [ -1 ] ++
+  //           [ (clause idx << MAXLEN | clause length) for OR clauses in which `-x` occurs ] ++ [ -1 ] ++
+  //           [ (clause idx << MAXLEN | clause length) for XOR clauses in which `x` occurs ] ++ [ -1 ] for x in variables ])
+  int * occs;
+  // Number of total occurrences of literals in OR clauses
+  int noccs;
+  // Number of total occurrences of literals in XOR clauses
+  int nxoccs;
+  float * weights;
+  float xorweight;
+  int * pos;
+  // lits[n] is the position in cdb of the n-th OR clause
+  int * lits;
+  // xlits[n] is the position in xcdb of the n-th XOR clause
+  int * xlits;
+  Lnk ** lnk;
+  int * crit; float * weightedbreak;
+  float * xweightedbreak;
+  // Number of OR clauses
+  int nclauses;
+  // Number of XOR clauses
+  int nxclauses;
+  // Number of binary/ternary OR clauses
+  int nbin, ntrn;
+  // Min/max lengths of any OR clause
+  int minlen, maxlen;
+  double avglen;
+  // These three fields are used in `yals_pick_literal`
+  // How many clauses flipping a literal would break
+  STACK(float) breaks;
+  STACK(double) scores;
+  STACK(int) cands;
+  STACK(Word*) cache; int cachesizetarget; STACK(Word) sigs;
+  STACK(int) minlits;
+  Callbacks cbs;
+  Limits limits;
+  Strat strat;
+  Stats stats;
+  Opts opts;
+  Mem mem;
+  FPU fpu;
+  Exp exp;
+};
+
+/*------------------------------------------------------------------------*/
+
+const char * yals_default_prefix () { return YALS_DEFAULT_PREFIX; }
+
+/*------------------------------------------------------------------------*/
+
+static void yals_msglock (Yals * yals) {
+  if (yals->cbs.msg.lock) yals->cbs.msg.lock (yals->cbs.msg.state);
+}
+
+static void yals_msgunlock (Yals * yals) {
+  if (yals->cbs.msg.unlock) yals->cbs.msg.unlock (yals->cbs.msg.state);
+}
+
+void yals_abort (Yals * yals, const char * fmt, ...) {
+  va_list ap;
+  yals_msglock (yals);
+  fflush (yals->out);
+  fprintf (stderr, "%s*** libyals abort: ", yals->opts.prefix);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  yals_msgunlock (yals);
+  abort ();
+}
+
+void yals_exit (Yals * yals, int exit_code, const char * fmt, ...) {
+  va_list ap;
+  yals_msglock (yals);
+  fflush (yals->out);
+  fprintf (stderr, "%s*** libyals exit: ", yals->opts.prefix);
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+  fputc ('\n', stderr);
+  fflush (stderr);
+  yals_msgunlock (yals);
+  exit (exit_code);
+}
+
+void yals_warn (Yals * yals, const char * fmt, ...) {
+  va_list ap;
+  yals_msglock (yals);
+  fprintf (yals->out, "%sWARNING ", yals->opts.prefix);
+  va_start (ap, fmt);
+  vfprintf (yals->out, fmt, ap);
+  va_end (ap);
+  fputc ('\n', yals->out);
+  fflush (yals->out);
+  yals_msgunlock (yals);
+}
+
+void yals_msg (Yals * yals, int level, const char * fmt, ...) {
+  va_list ap;
+  if (level > 0 && (!yals || yals->opts.verbose.val < level)) return;
+  yals_msglock (yals);
+  fprintf (yals->out, "%s", yals->opts.prefix);
+  va_start (ap, fmt);
+  vfprintf (yals->out, fmt, ap);
+  va_end (ap);
+  fputc ('\n', yals->out);
+  fflush (yals->out);
+  yals_msgunlock (yals);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_set_fpu (Yals * yals) {
+#ifdef __linux__
+  fpu_control_t control;
+  _FPU_GETCW (yals->fpu.control);
+  control = yals->fpu.control;
+  control &= ~_FPU_EXTENDED;
+  control &= ~_FPU_SINGLE;
+  control |= _FPU_DOUBLE;
+  _FPU_SETCW (control);
+  yals_msg (yals, 1, "set FPU mode to use double precision");
+#endif
+  yals->fpu.saved = 1;
+}
+
+static void yals_reset_fpu (Yals * yals) {
+  (void) yals;
+  assert (yals->fpu.saved);
+#ifdef __linux__
+  _FPU_SETCW (yals->fpu.control);
+  yals_msg (yals, 1, "reset FPU to original double precision mode");
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+#ifndef NDEBUG
+
+static void yals_log_start (Yals * yals, const char * fmt, ...) {
+  va_list ap;
+  yals_msglock (yals);
+  assert (yals->opts.logging.val);
+  fputs ("c [LOGYALS] ", yals->out);
+  va_start (ap, fmt);
+  vfprintf (yals->out, fmt, ap);
+  va_end (ap);
+}
+
+static void yals_log_end (Yals * yals) {
+  (void) yals;
+  assert (yals->opts.logging.val);
+  fputc ('\n', yals->out);
+  fflush (yals->out);
+  yals_msgunlock (yals);
+}
+
+#endif
+/*------------------------------------------------------------------------*/
+
+static double yals_avg (double a, double b) { return b ? a/b : 0; }
+
+static double yals_pct (double a, double b) { return b ? 100.0 * a / b : 0; }
+
+double yals_process_time () {
+  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 yals_time (Yals * yals) {
+  if (yals && yals->cbs.time) return yals->cbs.time ();
+  else return yals_process_time ();
+}
+
+static void yals_flush_time (Yals * yals) {
+  double time, entered;
+#ifdef __GNUC__
+  int old;
+  // begin{atomic}
+  old = __sync_val_compare_and_swap (&yals->stats.flushing_time, 0, 42);
+  assert (old == 0 || old == 42);
+  if (old) return;
+  //
+  // TODO I still occasionally have way too large kflips/sec if interrupted
+  // and I do not know why?  Either there is a bug in flushing or there is
+  // still a data race here and I did not apply this CAS sequence correctly.
+  //
+#endif
+  time = yals_time (yals);
+  entered = yals->stats.time.entered;
+  yals->stats.time.entered = time;
+  assert (time >= entered);
+  time -= entered;
+  yals->stats.time.total += time;
+#ifdef __GNUC__
+  old = __sync_val_compare_and_swap (&yals->stats.flushing_time, 42, 0);
+  assert (old == 42);
+  (void) old;
+  // end{atomic}
+#endif
+}
+
+double yals_sec (Yals * yals) {
+  yals_flush_time (yals);
+  return yals->stats.time.total;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_inc_allocated (Yals * yals, size_t bytes) {
+  yals->stats.allocated.current += bytes;
+  if (yals->stats.allocated.current > yals->stats.allocated.max)
+    yals->stats.allocated.max = yals->stats.allocated.current;
+}
+
+static void yals_dec_allocated (Yals * yals, size_t bytes) {
+  assert (yals->stats.allocated.current >= bytes);
+  yals->stats.allocated.current -= bytes;
+}
+
+void * yals_malloc (Yals * yals, size_t bytes) {
+  void * res;
+  if (!bytes) return 0;
+  res = yals->mem.malloc (yals->mem.mgr, bytes);
+  if (!res) yals_abort (yals, "out of memory in 'yals_malloc'");
+  yals_inc_allocated (yals, bytes);
+  memset (res, 0, bytes);
+  return res;
+}
+
+void yals_free (Yals * yals, void * ptr, size_t bytes) {
+  assert (!ptr == !bytes);
+  if (!ptr) return;
+  yals_dec_allocated (yals, bytes);
+  yals->mem.free (yals->mem.mgr, ptr, bytes);
+}
+
+void * yals_realloc (Yals * yals, void * ptr, size_t o, size_t n) {
+  char * res;
+  assert (!ptr == !o);
+  if (!n) { yals_free (yals, ptr, o); return 0; }
+  if (!o) return yals_malloc (yals, n);
+  yals_dec_allocated (yals, o);
+  res = yals->mem.realloc (yals->mem.mgr, ptr, o, n);
+  if (n && !res) yals_abort (yals, "out of memory in 'yals_realloc'");
+  yals_inc_allocated (yals, n);
+  if (n > o) memset (res + o, 0, n - o);
+  return res;
+}
+
+size_t yals_max_allocated (Yals * yals) {
+  return yals->stats.allocated.max;
+}
+
+/*------------------------------------------------------------------------*/
+
+static char * yals_strdup (Yals * yals, const char * str) {
+  assert (str);
+  return strcpy (yals_malloc (yals, strlen (str) + 1), str);
+}
+
+static void yals_strdel (Yals * yals, char * str) {
+  assert (str);
+  yals_free (yals, str, strlen (str) + 1);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_rds (RDS * r) {
+  if ((r->u & -r->u) == r->v) r->u++, r->v = 1; else r->v *= 2;
+}
+
+/*------------------------------------------------------------------------*/
+
+void yals_srand (Yals * yals, unsigned long long seed) {
+  unsigned z = seed >> 32, w = seed;
+  if (!z) z = ~z;
+  if (!w) w = ~w;
+  yals->rng.z = z, yals->rng.w = w;
+  yals_msg (yals, 2, "setting random seed %llu", seed);
+}
+
+static unsigned yals_rand (Yals * yals) {
+  unsigned res;
+  yals->rng.z = 36969 * (yals->rng.z & 65535) + (yals->rng.z >> 16);
+  yals->rng.w = 18000 * (yals->rng.w & 65535) + (yals->rng.w >> 16);
+  res = (yals->rng.z << 16) + yals->rng.w;
+  return res;
+}
+
+static unsigned yals_rand_mod (Yals * yals, unsigned mod) {
+  unsigned res;
+  assert (mod >= 1);
+  if (mod <= 1) return 0;
+  res = yals_rand (yals);
+  res %= mod;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+// `*yals_refs(yals, lit)` is the offset of `lit` into `occs`
+static int * yals_refs (Yals * yals, int lit) {
+  int idx = ABS (lit);
+  assert_valid_idx (idx);
+  assert (yals->refs);
+  return yals->refs + 3*idx + (lit < 0);
+}
+
+static int * yals_xrefs (Yals * yals, int idx) {
+  assert_valid_idx (idx);
+  assert (yals->refs);
+  return yals->refs + 3*idx + 2;
+}
+
+// OR clauses in which `lit` occurs
+static int * yals_occs (Yals * yals, int lit) {
+  INC (occs);
+  int occs = *yals_refs (yals, lit);
+  assert_valid_occs (occs);
+  return yals->occs + occs;
+}
+
+// XOR clauses in which `idx` occurs
+static int * yals_xoccs (Yals * yals, int idx) {
+  INC (occs);
+  int xoccs = *yals_xrefs (yals, idx);
+  assert_valid_occs (xoccs);
+  return yals->occs + xoccs;
+}
+
+static int yals_val (Yals * yals, int lit) {
+  int idx = ABS (lit), res = !GETBIT (yals->vals, yals->nvarwords, idx);
+  if (lit > 0) res = !res;
+  return res;
+}
+
+static int yals_best (Yals * yals, int lit) {
+  int idx = ABS (lit), res = !GETBIT (yals->best, yals->nvarwords, idx);
+  if (lit > 0) res = !res;
+  return res;
+}
+
+static float yals_weighted_break (Yals * yals, int lit) {
+  int idx = ABS (lit);
+  assert (yals->crit);
+  assert_valid_idx (idx);
+  return yals->weightedbreak[2*idx + (lit < 0)];
+}
+
+static float yals_xweighted_break (Yals * yals, int idx) {
+  assert (yals->crit);
+  assert_valid_idx (idx);
+  return yals->xweightedbreak[idx];
+}
+
+static void yals_inc_weighted_break (Yals * yals, int lit, float w) {
+  int idx = ABS (lit), pos;
+  assert (yals->crit);
+  assert_valid_idx (idx);
+  pos = 2*idx + (lit < 0);
+  yals->weightedbreak[pos] += w;
+  assert (yals->weightedbreak[pos] >= w);
+  INC (weight);
+}
+
+static void yals_inc_xweighted_break (Yals * yals, int idx, float w) {
+  assert (yals->crit);
+  assert_valid_idx (idx);
+  yals->xweightedbreak[idx] += w;
+  assert (yals->xweightedbreak[idx] >= w);
+  INC (weight);
+}
+
+static void yals_dec_weighted_break (Yals * yals, int lit, float w) {
+  int idx = ABS (lit), pos;
+  assert (yals->crit);
+  assert_valid_idx (idx);
+  pos = 2*idx + (lit < 0);
+  assert (yals->weightedbreak[pos] >= w);
+  yals->weightedbreak[pos] -= w;
+  INC (weight);
+}
+
+static void yals_dec_xweighted_break (Yals * yals, int idx, float w) {
+  assert (yals->crit);
+  assert_valid_idx (idx);
+  assert (yals->xweightedbreak[idx] >= w);
+  yals->xweightedbreak[idx] -= w;
+  INC (weight);
+}
+
+static unsigned yals_satcnt (Yals * yals, int cidx) {
+  assert_valid_cidx (cidx);
+  if (yals->satcntbytes == 1) return yals->satcnt1[cidx];
+  if (yals->satcntbytes == 2) return yals->satcnt2[cidx];
+  return yals->satcnt4[cidx];
+}
+
+static void yals_setsatcnt (Yals * yals, int cidx, unsigned satcnt) {
+  assert_valid_cidx (cidx);
+  if (yals->satcntbytes == 1) {
+    assert (satcnt < 256);
+    yals->satcnt1[cidx] = satcnt;
+  } else if (yals->satcntbytes == 2) {
+    assert (satcnt < 65536);
+    yals->satcnt2[cidx] = satcnt;
+  } else {
+    yals->satcnt4[cidx] = satcnt;
+  }
+}
+
+static unsigned yals_incsatcnt (Yals * yals, int cidx, int lit, int len) {
+  unsigned res;
+  assert_valid_cidx (cidx);
+  assert_valid_len (len);
+  if (yals->satcntbytes == 1) {
+    res = yals->satcnt1[cidx]++;
+    assert (yals->satcnt1[cidx]);
+  } else if (yals->satcntbytes == 2) {
+    res = yals->satcnt2[cidx]++;
+    assert (yals->satcnt2[cidx]);
+  } else {
+    res = yals->satcnt4[cidx]++;
+    assert (yals->satcnt4[cidx]);
+  }
+#ifndef NYALSTATS
+  assert (res + 1 <= yals->maxlen);
+  yals->stats.inc[res]++;
+#endif
+  if (yals->crit) {
+    if (res == 1) yals_dec_weighted_break (yals, yals->crit[cidx], yals->weights[len]); // TODO avoid mem on yals->weights if uniform weights
+    else if (!res) yals_inc_weighted_break (yals, lit, yals->weights[len]);
+    yals->crit[cidx] ^= lit;
+    assert (res || yals->crit[cidx] == lit);
+  }
+  return res;
+}
+
+static unsigned yals_decsatcnt (Yals * yals, int cidx, int lit, int len) {
+  unsigned res;
+  assert_valid_cidx (cidx);
+  assert_valid_len (len);
+  if (yals->satcntbytes == 1) {
+    assert (yals->satcnt1[cidx]);
+    res = --yals->satcnt1[cidx];
+  } else if (yals->satcntbytes == 2) {
+    assert (yals->satcnt2[cidx]);
+    res = --yals->satcnt2[cidx];
+  } else {
+    assert (yals->satcnt4[cidx]);
+    res = --yals->satcnt4[cidx];
+  }
+#ifndef NYALSTATS
+  assert (res + 1 <= yals->maxlen);
+  yals->stats.dec[res + 1]++;
+#endif
+  if (yals->crit) {
+    int other = yals->crit[cidx] ^ lit;
+    yals->crit[cidx] = other;
+    if (res == 1) yals_inc_weighted_break (yals, other, yals->weights[len]); // TODO avoid mem on yals->weights if uniform weights
+    else if (!res) yals_dec_weighted_break (yals, lit, yals->weights[len]);
+    assert (res || !yals->crit[cidx]);
+  }
+  return res;
+}
+
+static U1 yals_xorsat (Yals * yals, int cidx) {
+  assert_valid_xcidx(cidx);
+  return yals->xorsat[cidx];
+}
+
+static void yals_setxorsat (Yals * yals, int cidx, U1 xorsat) {
+  assert_valid_xcidx (cidx);
+  yals->xorsat[cidx] = xorsat;
+}
+
+static U1 yals_flipxorsat (Yals * yals, int cidx) {
+  assert_valid_xcidx (cidx);
+  yals->xorsat[cidx] ^= 1;
+  return yals->xorsat[cidx];
+}
+
+// Returns the literals for the cidx-th OR clause
+static int * yals_lits (Yals * yals, int cidx) {
+  INC (lits);
+  assert_valid_cidx (cidx);
+  return yals->cdb.start + yals->lits[cidx];
+}
+
+// Returns the variable indices for the cidx-th XOR clause
+static int * yals_xlits (Yals * yals, int cidx) {
+  INC (lits);
+  assert_valid_xcidx (cidx);
+  return yals->xcdb.start + yals->xlits[cidx];
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_report (Yals * yals, const char * fmt, ...) {
+  double t, f;
+  va_list ap;
+  assert (yals->opts.verbose.val);
+  yals_msglock (yals);
+  f = yals->stats.flips;
+  t = yals_sec (yals);
+  fprintf (yals->out, "%s", yals->opts.prefix);
+  va_start (ap, fmt);
+  vfprintf (yals->out, fmt, ap);
+  va_end (ap);
+  fprintf (yals->out,
+    " : best %d (tmp %d), kflips %.0f, %.2f sec, %.2f kflips/sec\n",
+    yals->stats.best, yals->stats.tmp, f/1e3, t, yals_avg (f/1e3, t));
+  fflush (yals->out);
+  yals_msgunlock (yals);
+}
+
+static int yals_nunsat (Yals * yals) {
+  if (yals->unsat.usequeue) return yals->unsat.queue.count;
+  else return COUNT (yals->unsat.stack);
+}
+
+static void yals_save_new_minimum (Yals * yals) {
+  int nunsat = yals_nunsat (yals);
+  size_t bytes = yals->nvarwords * sizeof (Word);
+  if (yals->stats.worst < nunsat) yals->stats.worst = nunsat;
+  if (yals->stats.tmp > nunsat) {
+    LOG ("minimum %d is best assignment since last restart", nunsat);
+    memcpy (yals->tmp, yals->vals, bytes);
+    yals->stats.tmp = nunsat;
+  }
+  if (yals->stats.best < nunsat) return;
+  if (yals->stats.best == nunsat) {
+    LOG ("minimum %d matches previous overall best assignment", nunsat);
+    yals->stats.hits++;
+    return;
+  }
+  LOG ("minimum %d with new best overall assignment", nunsat);
+  yals->stats.best = nunsat;
+  yals->stats.hits = 1;
+  memcpy (yals->best, yals->vals, bytes);
+  if (yals->opts.verbose.val >= 2 ||
+      (yals->opts.verbose.val >= 1 && nunsat <= yals->limits.report.min/2)) {
+    yals_report (yals, "new minimum");
+    yals->limits.report.min = nunsat;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Checks the global invariant:
+// - all unsat clauses are in the unsat queue/stack
+// - the unsat queue/stack is well-formed
+static void yals_check_global_invariant (Yals * yals) {
+#ifndef NDEBUG
+  int cidx, lit, nunsat = 0;
+  const int * p;
+  assert (BITS_PER_WORD == (1 << LD_BITS_PER_WORD));
+  if (!yals->opts.checking.val) return;
+  for (cidx = 0; cidx < yals->nclauses; cidx++) {
+    unsigned sat;
+    for (p = yals_lits (yals, cidx), sat = 0; (lit = *p); p++)
+      if (yals_val (yals, lit)) sat++;
+    assert (yals_satcnt (yals, cidx) == sat);
+    if (!sat) nunsat++;
+    if (yals->unsat.usequeue) {
+      if (sat) continue;
+      Lnk * l = yals->lnk[cidx];
+      assert (l);
+      assert (l->cidx == cidx);
+    } else {
+      int pos = yals->pos[cidx];
+      if (sat) assert (pos < 0);
+      else {
+        assert_valid_pos (pos);
+        assert (PEEK (yals->unsat.stack, pos) == cidx);
+      }
+    }
+  }
+  for (cidx = 0; cidx < yals->nxclauses; cidx++) {
+    U1 sat = *(yals->xparitydb.start + cidx);
+    for (p = yals_xlits(yals, cidx); (lit = *p); p++) {
+      sat ^= yals_val(yals, lit);
+    }
+    assert (yals_xorsat(yals, cidx) == sat);
+    if (!sat) nunsat++;
+    if (yals->unsat.usequeue) {
+      if (sat) continue;
+      Lnk * l = yals->lnk[cidx + yals->nclauses];
+      assert (l);
+      assert (l->cidx == cidx + yals->nclauses);
+    } else {
+      int pos = yals->pos[cidx + yals->nclauses];
+      if (sat) assert (pos < 0);
+      else {
+        assert_valid_pos (pos);
+        assert (PEEK (yals->unsat.stack, pos) == cidx + yals->nclauses);
+      }
+    }
+  }
+  assert (nunsat == yals_nunsat (yals));
+#endif
+  (void) yals;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_enqueue_lnk (Yals * yals, Lnk * l) {
+  Lnk * last = yals->unsat.queue.last;
+  if (last) last->next = l;
+  else yals->unsat.queue.first = l;
+  yals->unsat.queue.last = l;
+  l->prev = last;
+  l->next = 0;
+}
+
+static void yals_dequeue_lnk (Yals * yals, Lnk * l) {
+  Lnk * prev = l->prev, * next = l->next;
+  if (prev) {
+    assert (yals->unsat.queue.first);
+    assert (yals->unsat.queue.last);
+    assert (prev->next == l);
+    prev->next = next;
+  } else {
+    assert (yals->unsat.queue.first == l);
+    yals->unsat.queue.first = next;
+  }
+  if (next) {
+    assert (yals->unsat.queue.first);
+    assert (yals->unsat.queue.last);
+    assert (next->prev == l);
+    next->prev = prev;
+  } else {
+    assert (yals->unsat.queue.last == l);
+    yals->unsat.queue.last = prev;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+static const char * yals_pick_to_str (Yals * yals) {
+  switch (yals->pick) {
+    case BFS_CLAUSE_PICKING:
+      return "clause by BFS strategy";
+    case RELAXED_BFS_CLAUSE_PICKING:
+      return "clause by relaxed BFS strategy";
+    case DFS_CLAUSE_PICKING:
+      return "clause by DFS strategy";
+    case PSEUDO_BFS_CLAUSE_PICKING:
+      return "clause by pseudo BFS strategy";
+    case UNFAIR_BFS_CLAUSE_PICKING:
+      return "clause by unfair BFS strategy";
+    case RANDOM_CLAUSE_PICKING:
+    default:
+      assert (yals->pick == RANDOM_CLAUSE_PICKING);
+      return "uniformly random clause";
+  }
+}
+
+static int yals_pick_clause (Yals * yals) {
+  int cidx, nunsat = yals_nunsat (yals);
+  assert (nunsat > 0);
+ int iter = 2;
+ while (iter-- > 0) {
+  if (yals->unsat.usequeue) {
+    Lnk * lnk;
+    if (yals->pick == BFS_CLAUSE_PICKING) {
+      lnk = yals->unsat.queue.first;
+    } else if (yals->pick == RELAXED_BFS_CLAUSE_PICKING) {
+      lnk = yals->unsat.queue.first;
+      while (lnk->next && !yals_rand_mod (yals, yals->opts.rbfsrate.val))
+        lnk = lnk->next;
+    } else if (yals->pick == UNFAIR_BFS_CLAUSE_PICKING) {
+      lnk = yals->unsat.queue.first;
+      cidx = lnk->cidx;
+      if (yals->unsat.queue.count > 1 &&
+          yals_rand_mod (yals, 100) < (cidx >= yals->nclauses ? 50 : 50)
+          ) {
+      
+//      if (yals->unsat.queue.count > 1 &&
+//          yals_rand_mod (yals, 100) >= yals->opts.unfairfreq.val) {
+        //lnk = yals->unsat.queue.first;
+        yals_dequeue_lnk (yals, lnk);
+        yals_enqueue_lnk (yals, lnk);
+        yals->stats.queue.unfair++;
+      }
+      lnk = yals->unsat.queue.first;
+    } else {
+      assert (yals->pick == DFS_CLAUSE_PICKING);
+      lnk = yals->unsat.queue.last;
+    }
+    assert (lnk);
+    cidx = lnk->cidx;
+  } else {
+    int cpos;
+    if (yals->pick == PSEUDO_BFS_CLAUSE_PICKING) {
+      cpos = yals->stats.flips % nunsat;
+    } else {
+      assert (yals->pick == RANDOM_CLAUSE_PICKING);
+      cpos = yals_rand_mod (yals, nunsat);
+    }
+    cidx = PEEK (yals->unsat.stack, cpos);
+    assert (yals->pos[cidx] == cpos);
+  }
+  if (cidx >= yals->nclauses) {
+    assert_valid_xcidx(cidx - yals->nclauses);
+    LOG ("picking %s out of %d", yals_pick_to_str (yals), nunsat);
+    assert (!yals_xorsat(yals, cidx - yals->nclauses));
+    LOGCIDX(cidx, "picked");
+  } else {
+    assert_valid_cidx (cidx);
+    LOG ("picking %s out of %d", yals_pick_to_str (yals), nunsat);
+    assert (!yals_satcnt (yals, cidx));
+    LOGCIDX (cidx, "picked");
+  }
+
+  if (cidx <= yals->nclauses) break;
+ }
+  return cidx;
+}
+
+/*------------------------------------------------------------------------*/
+
+static float yals_dynamic_weighted_break (Yals * yals, int lit) {
+  float res = yals_weighted_break (yals, -lit) + yals_xweighted_break(yals, ABS(lit));
+  //printf ("%d\n", res);
+  //if (res/2 % 2 == 1) exit(0);
+  LOG ("literal %d results in weighted break %u", lit, res);
+  return res;
+}
+
+#define ACCU(SUM,INC) \
+do { \
+  if (UINT_MAX - (INC) < (SUM)) (SUM) = UINT_MAX; else (SUM) += (INC); \
+} while (0)
+/*
+static unsigned yals_compute_weighted_break (Yals * yals, int lit) {
+  unsigned wb, b, w, cnt;
+  const int * p, * occs;
+  int occ, cidx, len;
+
+  assert (!yals_val (yals, lit));
+  wb = b = 0;
+  occs = yals_occs (yals, -lit);
+  for (p = occs ; (occ = *p) >= 0; p++) {
+    len = occ & LENMASK;
+    cidx = occ >> LENSHIFT;
+    cnt = yals_satcnt (yals, cidx);
+    if (cnt != 1) continue;
+    w = yals->weights [len];		  // TODO remove mem for uniform
+    assert (0 < w && w <= yals->strat.weight);
+    ACCU (wb, w);
+    b++;
+  }
+#ifndef NDEBUG
+  unsigned or_clauses_wb = wb;
+  int nOrClauses = (int)(p - occs);
+#endif
+
+  // NOTE: we assume that any given variable appears in one XOR clause at most once
+  occs = yals_xoccs(yals, ABS(lit));
+  for (p = occs; (occ = *p) >= 0; p++) {
+    cidx = occ >> LENSHIFT;
+    if (!yals_xorsat(yals, cidx)) continue;
+    w = yals->xorweight;
+    assert (0 < w && w <= yals->strat.weight);
+    ACCU (wb, w);
+    b++;
+  }
+
+#ifndef NDEBUG
+  assert(!yals->crit || wb - or_clauses_wb == yals_xweighted_break(yals, ABS(lit)));
+
+  int nXorClauses = (int)(p - occs);
+
+  LOG ("literal %d breaks %u clauses out of %d OR, %d XOR results in weighted break %u",
+    lit, b, nOrClauses, nXorClauses, wb);
+#endif
+
+  ADD (read, p - occs);
+
+  return wb;
+}*/
+
+static float yals_determine_weighted_break (Yals * yals, int lit) {
+  float res;
+  //if (yals->crit)
+  res = yals_dynamic_weighted_break (yals, lit);
+  //else res = yals_compute_weighted_break (yals, lit);
+#ifndef NYALSTATS
+  if (yals->stats.wb.max < res) yals->stats.wb.max = res;
+  if (yals->stats.wb.min > res) yals->stats.wb.min = res;
+#endif
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static double
+yals_compute_score_from_weighted_break (Yals * yals, float w) {
+
+  double s;
+
+/*
+  if (yals->strat.correct)
+    s = (w < yals->exp.max.cb) ?
+          PEEK (yals->exp.table.cb, (unsigned)w) : yals->exp.eps.cb;
+  else
+    s = (w < yals->exp.max.two) ?
+          PEEK (yals->exp.table.two, (unsigned)w) : yals->exp.eps.two;
+
+  assert (s);
+*/
+  double s_hi, s_lo;
+
+  s_hi = (w < yals->exp.max.cb) ?
+          PEEK (yals->exp.table.cb, (unsigned)w) : yals->exp.eps.cb;
+  unsigned w_rem = (unsigned)((w - (unsigned)w) * 100);
+  s_lo = (w_rem < yals->exp.max.two) ?
+          PEEK (yals->exp.table.two, w_rem) : yals->exp.eps.two;
+  
+  s = s_hi * s_lo;
+
+  LOG ("weighted break %f gives score %g", w, s);
+
+  return s;
+}
+
+static int yals_pick_by_score (Yals * yals) {
+  double s, lim, sum;
+  const double * q;
+  const int * p;
+  int res;
+
+  assert (!EMPTY (yals->scores));
+  assert (COUNT (yals->scores) == COUNT (yals->cands));
+
+  sum = 0;
+  for (q = yals->scores.start; q < yals->scores.top; q++)
+    sum += *q;
+
+  assert (sum > 0);
+  lim = (yals_rand (yals) / (1.0 + (double) UINT_MAX))*sum;
+  assert (lim < sum);
+
+  LOG ("random choice %g mod %g", lim, sum);
+
+  p = yals->cands.start;	assert (p < yals->cands.top);
+  res = *p++;
+
+  q = yals->scores.start;	assert (q < yals->scores.top);
+  s = *q++;			assert (s > 0);
+
+  while (p < yals->cands.top && s <= lim) {
+    lim -= s;
+    res = *p++;			assert (q < yals->scores.top);
+    s = *q++;			assert (s > 0);
+  }
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int yals_pick_literal (Yals * yals, int cidx) {
+  const int pick_break_zero = yals->opts.breakzero.val;
+  const int * p, * lits;
+  int lit, zero;
+  float w;
+  double s;
+
+  assert (EMPTY (yals->breaks));
+  assert (EMPTY (yals->cands));
+
+  zero = 0;
+
+  // Gather candidates for flipping together with break(..) values
+  if (cidx >= yals->nclauses) { // XOR clause
+    lits = yals_xlits(yals, cidx - yals->nclauses);
+    for (p = lits; (lit = *p); p++) {
+      // The literal to be flipped is always assumed to be false in the assignment
+      if (yals_val(yals, lit)) lit = -lit;
+      w = yals_determine_weighted_break(yals, lit);
+
+      LOG("literal %d weighted break %f", lit, w);
+      if (pick_break_zero && !w) {
+        if (!zero++) CLEAR (yals->cands);
+        PUSH (yals->cands, lit);
+      } else if (!zero) {
+        PUSH (yals->breaks, w);
+        PUSH (yals->cands, lit);
+      }
+    }
+  } else { // OR clause
+    lits = yals_lits (yals, cidx);
+    for (p = lits; (lit = *p); p++) {
+      w = yals_determine_weighted_break (yals, lit);
+      LOG ("literal %d weighted break %f", lit, w);
+      if (pick_break_zero && !w) {
+        if (!zero++) CLEAR (yals->cands);
+        PUSH (yals->cands, lit);
+      } else if (!zero) {
+        PUSH (yals->breaks, w);
+        PUSH (yals->cands, lit);
+      }
+    }
+  }
+
+  if (zero) {
+
+    yals->stats.bzflips++;
+    assert (zero == COUNT (yals->cands));
+    lit = yals->cands.start[yals_rand_mod (yals, zero)];
+    LOG ("picked random break zero literal %d out of %d", lit, zero);
+
+  } else {
+
+    const float * wbs = yals->breaks.start;
+    const unsigned n = COUNT (yals->breaks);
+    unsigned i;
+
+    assert (EMPTY (yals->scores));
+
+    for (i = 0; i < n; i++) {
+      w = wbs[i];
+      s = yals_compute_score_from_weighted_break (yals, w);
+      LOG ("literal %d weighted break %f score %g", lits[i], w, s);
+      PUSH (yals->scores, s);
+    }
+    lit = yals_pick_by_score (yals);
+
+#ifndef NDEBUG
+    for (i = 0; i < n; i++) {
+      int tmp = lits[i];
+      if (tmp != lit) continue;
+      s = yals->scores.start[i];
+      w = wbs[i];
+      break;
+    }
+#endif
+    LOG ("picked literal %d weighted break %f score %g", lit, w, s);
+
+    CLEAR (yals->scores);
+  }
+  
+  CLEAR (yals->cands);
+  CLEAR (yals->breaks);
+
+  return lit;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_flip_value_of_lit (Yals * yals, int lit) {
+  int idx = ABS (lit);
+  LOG ("flipping %d", lit);
+  NOTBIT (yals->vals, yals->nvarwords, idx);
+  yals->flips[idx]++;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_flush_queue (Yals * yals) {
+  int count = 0;
+  Lnk * p;
+  assert (yals->unsat.usequeue);
+  for (p = yals->unsat.queue.first; p; p = p->next) {
+    int cidx = p->cidx;
+    if (cidx >= yals->nclauses)
+      assert_valid_xcidx(cidx - yals->nclauses);
+    else
+      assert_valid_cidx (cidx);
+    assert (yals->lnk[cidx] == p);
+    yals->lnk[cidx] = 0;
+    count++;
+  }
+  yals->unsat.queue.first = yals->unsat.queue.last = 0;
+  LOG ("flushed %d queue elements", count);
+  assert (count == yals->unsat.queue.count);
+  yals->unsat.queue.count = 0;
+}
+
+static void yals_release_lnks (Yals * yals) {
+  int chunks = 0, lnks = 0;
+  Chunk * q, * n;
+  assert (yals->unsat.usequeue);
+  for (q = yals->unsat.queue.chunks; q; q = n) {
+    n = q->next;
+    chunks++, lnks += q->size - 1;
+    DELN (&q->lnks, q->size);
+  }
+  LOG ("released %d links in %d chunks", lnks, chunks);
+  assert (yals->unsat.queue.nchunks == chunks);
+  assert (yals->unsat.queue.nlnks == lnks);
+  yals->unsat.queue.chunks = 0;
+  yals->unsat.queue.free = 0;
+  yals->unsat.queue.nfree = 0;
+  yals->unsat.queue.chunksize = 0;
+  yals->unsat.queue.nchunks = 0;
+  yals->unsat.queue.nlnks = 0;
+}
+
+static void yals_reset_unsat_queue (Yals * yals) {
+  assert (yals->unsat.usequeue);
+  yals_flush_queue (yals);
+  yals_release_lnks (yals);
+}
+
+static void yals_defrag_queue (Yals * yals) {
+  const int count = yals->unsat.queue.count;
+  const int size = MAX(2*(count + 1), yals->opts.minchunksize.val);
+  Lnk * p, * first, * free, * prev = 0;
+  double start = yals_time (yals);
+  const Lnk * q;
+  Chunk * c;
+  assert (count);
+  yals->stats.defrag.count++;
+  yals->stats.defrag.moved += count;
+  LOG ("defragmentation chunk of size %d moving %d", size, count);
+  NEWN (p, size);
+  c = (Chunk*) p;
+  c->size = size;
+  first = c->lnks + 1;
+  for (q = yals->unsat.queue.first, p = first; q; q = q->next, p++) {
+    *p = *q;
+    p->prev = prev;
+    if (prev) prev->next = p;
+    prev = p;
+  }
+  assert (prev);
+  prev->next = 0;
+  free = p;
+  yals_reset_unsat_queue (yals);
+  assert (prev);
+  yals->unsat.queue.first = first;
+  yals->unsat.queue.last = prev;
+  yals->unsat.queue.count = count;
+  for (p = yals->unsat.queue.first; p; p = p->next) {
+    int cidx = p->cidx;
+    if (cidx >= yals->nclauses)
+      assert_valid_xcidx(cidx - yals->nclauses);
+    else
+      assert_valid_cidx (cidx);
+    assert (!yals->lnk[cidx]);
+    yals->lnk[cidx] = p;
+    assert (!p->next || p->next == p + 1);
+  }
+  assert (free < c->lnks + size);
+  yals->unsat.queue.nfree = (c->lnks + size) - free;
+  assert (yals->unsat.queue.nfree > 0);
+  prev = 0;
+  for (p = c->lnks + size-1; p >= free; p--) p->next = prev, prev = p;
+  yals->unsat.queue.free = free;
+  assert (!c->next);
+  yals->unsat.queue.chunks = c;
+  yals->unsat.queue.nchunks = 1;
+  yals->unsat.queue.nlnks = size - 1;
+  assert (yals->stats.queue.max.lnks >= yals->unsat.queue.nlnks);
+  assert (yals->stats.queue.max.chunks >= yals->unsat.queue.nchunks);
+  yals->stats.time.defrag += yals_time (yals) - start;
+}
+
+
+static int yals_need_to_defrag_queue (Yals * yals) {
+  if (!yals->opts.defrag.val) return 0;
+  if (!yals->unsat.queue.count) return 0;
+  if (yals->unsat.queue.nlnks <= yals->opts.minchunksize.val) return 0;
+  if (yals->unsat.queue.count > yals->unsat.queue.nfree/4) return 0;
+  return 1;
+}
+
+static void yals_dequeue_queue (Yals * yals, int cidx) {
+  Lnk * l;
+  assert (yals->unsat.usequeue);
+  assert (yals->unsat.queue.count > 0);
+  yals->unsat.queue.count--;
+  l = yals->lnk[cidx];
+  assert (l);
+  assert (l->cidx == cidx);
+  yals->lnk[cidx] = 0;
+  yals_dequeue_lnk (yals, l);
+  l->next = yals->unsat.queue.free;
+  yals->unsat.queue.free = l;
+  yals->unsat.queue.nfree++;
+  assert (yals->unsat.queue.nlnks ==
+          yals->unsat.queue.nfree + yals->unsat.queue.count);
+  if (yals_need_to_defrag_queue (yals)) yals_defrag_queue (yals);
+}
+
+static void yals_dequeue_stack (Yals * yals, int cidx) {
+  int cpos = yals->pos[cidx], didx;
+  assert (!yals->unsat.usequeue);
+  assert_valid_pos (cpos);
+  assert (PEEK (yals->unsat.stack, cpos) == cidx);
+  didx = POP (yals->unsat.stack);
+  if (didx >= yals->nclauses)
+    assert_valid_xcidx(didx - yals->nclauses);
+  else
+    assert_valid_cidx (didx);
+  if (didx != cidx) {
+    assert (yals->pos[didx] == COUNT (yals->unsat.stack));
+    POKE (yals->unsat.stack, cpos, didx);
+    yals->pos[didx] = cpos;
+  }
+  yals->pos[cidx] = -1;
+}
+
+static void yals_dequeue (Yals * yals, int cidx) {
+  if (cidx >= yals->nclauses) { // XOR clause
+    LOG ("dequeue XOR %d", cidx - yals->nclauses);
+    assert_valid_xcidx(cidx - yals->nclauses);
+  } else {
+    LOG ("dequeue OR %d", cidx);
+    assert_valid_cidx (cidx);
+  }
+  if (yals->unsat.usequeue) yals_dequeue_queue (yals, cidx);
+  else yals_dequeue_stack (yals, cidx);
+}
+
+static void yals_new_chunk (Yals * yals) {
+  Lnk * p, * first, * prev = 0;
+  Chunk * c;
+  int size;
+  size = yals->unsat.queue.chunksize;
+  assert (size >= yals->opts.minchunksize.val);
+  LOG ("new chunk of size %d", size);
+  NEWN (p, size);
+  c = (Chunk*) p;
+  c->size = size;
+  first = c->lnks + 1;
+  for (p = c->lnks + size-1; p >= first; p--) p->next = prev, prev = p;
+  yals->unsat.queue.nfree += size-1;
+  yals->unsat.queue.free = first;
+  c->next = yals->unsat.queue.chunks;
+  yals->unsat.queue.chunks = c;
+  yals->unsat.queue.nlnks += size - 1;
+  if (yals->stats.queue.max.lnks < yals->unsat.queue.nlnks)
+    yals->stats.queue.max.lnks = yals->unsat.queue.nlnks;
+  if (yals->stats.queue.max.chunks < ++yals->unsat.queue.nchunks)
+    yals->stats.queue.max.chunks = yals->unsat.queue.nchunks;
+}
+
+static void yals_larger_new_chunk (Yals * yals) {
+  if (!yals->unsat.queue.chunksize)
+    yals->unsat.queue.chunksize = yals->opts.minchunksize.val;
+  else yals->unsat.queue.chunksize *= 2;
+  yals_new_chunk (yals);
+}
+
+static Lnk * yals_new_lnk (Yals * yals) {
+  Lnk * res = yals->unsat.queue.free;
+  if (!res) {
+    yals_larger_new_chunk (yals);
+    res = yals->unsat.queue.free;
+  }
+  yals->unsat.queue.free = res->next;
+  assert (yals->unsat.queue.nfree);
+  yals->unsat.queue.nfree--;
+  return res;
+}
+
+static void yals_enqueue_queue (Yals * yals, int cidx) {
+  Lnk * res;
+  assert (yals->unsat.usequeue);
+  res = yals_new_lnk (yals);
+  assert (!yals->lnk[cidx]);
+  yals->lnk[cidx] = res;
+  res->cidx = cidx;
+  yals_enqueue_lnk (yals, res);
+  yals->unsat.queue.count++;
+  assert (yals->unsat.queue.count > 0);
+  assert (yals->unsat.queue.nlnks ==
+          yals->unsat.queue.nfree + yals->unsat.queue.count);
+}
+
+static void yals_enqueue_stack (Yals * yals, int cidx) {
+  int size;
+  assert (!yals->unsat.usequeue);
+  assert (yals->pos[cidx] < 0);
+  yals->pos[cidx] = COUNT (yals->unsat.stack);
+  PUSH (yals->unsat.stack, cidx);
+  if (yals->stats.maxstacksize < (size = SIZE (yals->unsat.stack)))
+    yals->stats.maxstacksize = size;
+}
+
+static void yals_enqueue (Yals * yals, int cidx) {
+  if (cidx >= yals->nclauses) { // XOR clause
+    LOG ("enqueue XOR %d", cidx - yals->nclauses);
+    assert_valid_xcidx(cidx - yals->nclauses);
+  } else {
+    LOG ("enqueue OR %d", cidx);
+    assert_valid_cidx (cidx);
+  }
+
+  if (yals->unsat.usequeue) yals_enqueue_queue (yals, cidx);
+  else yals_enqueue_stack (yals, cidx);
+}
+
+static void yals_reset_unsat_stack (Yals * yals) {
+  assert (!yals->unsat.usequeue);
+  while (!EMPTY (yals->unsat.stack)) {
+    int cidx = POP (yals->unsat.stack);
+    if (cidx >= yals->nclauses)
+      assert_valid_xcidx (cidx - yals->nclauses);
+    else
+      assert_valid_cidx (cidx);
+    assert (yals->pos[cidx] == COUNT (yals->unsat.stack));
+    yals->pos[cidx] = -1;
+  }
+  RELEASE (yals->unsat.stack);
+}
+
+static void yals_reset_unsat (Yals * yals) {
+  if (yals->unsat.usequeue) yals_reset_unsat_queue (yals);
+  else yals_reset_unsat_stack (yals);
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_make_clauses_after_flipping_lit (Yals * yals, int lit) {
+  const int * p, * occs;
+  int cidx, len, occ;
+#if !defined(NDEBUG) || !defined(NYALSTATS)
+  int made = 0;
+#endif
+  assert (yals_val (yals, lit));
+  occs = yals_occs (yals, lit);
+  for (p = occs; (occ = *p) >= 0; p++) {
+    len = occ & LENMASK;
+    cidx = occ >> LENSHIFT;
+    if (yals_incsatcnt (yals, cidx, lit, len)) continue;
+    yals_dequeue (yals, cidx);
+    LOGCIDX (cidx, "made");
+#if !defined(NDEBUG) || !defined(NYALSTATS)
+    made++;
+#endif
+  }
+
+  LOG ("flipping %d has made %d OR clauses", lit, made);
+#ifndef NYALSMEMS
+  {
+    int updated = p - occs;
+    ADD (update, updated);
+    if (yals->crit) ADD (crit, updated);
+  }
+#endif
+#ifndef NYALSTATS
+  yals->stats.made += made;
+#endif
+}
+
+static void yals_break_clauses_after_flipping_lit (Yals * yals, int lit) {
+  const int * p, * occs;
+  int occ, cidx, len;
+#if !defined(NDEBUG) || !defined(NYALSTATS)
+  int broken = 0;
+#endif
+  occs = yals_occs (yals, -lit);
+  for (p = occs; (occ = *p) >= 0; p++) {
+    len = occ & LENMASK;
+    cidx = occ >> LENSHIFT;
+    if (yals_decsatcnt (yals, cidx, -lit, len)) continue;
+    yals_enqueue (yals, cidx);
+    LOGCIDX (cidx, "broken");
+#if !defined(NDEBUG) || !defined(NYALSTATS)
+    broken++;
+#endif
+  }
+
+  LOG ("flipping %d has broken %d OR clauses", lit, broken);
+#ifndef NYALSMEMS
+  {
+    int updated = p - occs;
+    ADD (update, updated);
+    if (yals->crit) ADD (crit, updated);
+  }
+#endif
+#ifndef NYALSTATS
+  yals->stats.broken += broken;
+#endif
+}
+
+static void yals_check_xweighted_breaks(Yals * yals) {
+#ifndef NDEBUG
+  if (!yals->opts.checking.val) return;
+  if (!yals->crit) return;
+
+  float d, f, w1, w2, xw;
+  for (int lit = 1; lit < yals->nvars; lit++) {
+    // printf("checking xweightedbreak for lit %d\n", lit);
+    if (yals_val(yals, lit)) {
+      d = yals_dynamic_weighted_break(yals, -lit);
+      f = yals_compute_weighted_break(yals, -lit);
+    } else {
+      d = yals_dynamic_weighted_break(yals, lit);
+      f = yals_compute_weighted_break(yals, lit);
+    }
+    // w1 = yals_weighted_break(yals, -lit);
+    // w2 = yals_weighted_break(yals, lit);
+    // xw = yals_xweighted_break(yals, lit);
+    // printf("dynamic: %d, from scratch: %d\n", d, f);
+    // printf("weightedbreak: %d %d, xweightedbreak: %d\n\n", w1, w2, xw);
+    assert(d == f);
+  }
+#endif
+}
+
+static void yals_flip_xclauses_after_flipping_lit(Yals * yals, int lit) {
+  const int * p, * occs, * q;
+  int cidx, occ;
+  int tmp_lit;
+#if !defined(NDEBUG) || !defined(NYALSTATS)
+  int made = 0;
+  int broken = 0;
+#endif
+
+  // NOTE: we assume that any given variable appears in one XOR clause at most once
+  // Otherwise, we'd have to loop once to compute which clauses flipped and again
+  // to compute made, broken
+  occs = yals_xoccs (yals, ABS(lit));
+  for (p = occs; (occ = *p) >= 0; p++) {
+    cidx = occ >> LENSHIFT;
+    if (yals_flipxorsat(yals, cidx)) {
+      yals_dequeue(yals, yals->nclauses + cidx);
+      LOGCIDX (yals->nclauses + cidx, "made");
+      if (yals->crit) {
+        for (q = yals_xlits(yals, cidx); (tmp_lit = *q); q++) {
+          yals_inc_xweighted_break(yals, tmp_lit, yals->xorweight);
+        }
+      }
+#if !defined(NDEBUG) || !defined(NYALSTATS)
+      made++;
+#endif
+    } else {
+      yals_enqueue(yals, yals->nclauses + cidx);
+      LOGCIDX (yals->nclauses + cidx, "broken");
+      if (yals->crit) {
+        for (q = yals_xlits(yals, cidx); (tmp_lit = *q); q++) {
+          yals_dec_xweighted_break(yals, tmp_lit, yals->xorweight);
+        }
+      }
+#if !defined(NDEBUG) || !defined(NYALSTATS)
+      broken++;
+#endif
+    }
+  }
+
+#ifndef NYALSMEMS
+  {
+    int updated = p - occs;
+    ADD (update, updated);
+    if (yals->crit) ADD (crit, updated);
+  }
+#endif
+
+  LOG ("flipping %d has made %d, broken %d XOR clauses", lit, made, broken);
+#ifndef NYALSTATS
+  yals->stats.made += made;
+  yals->stats.broken += broken;
+#endif
+}
+
+static void yals_update_minimum (Yals * yals) {
+  yals_save_new_minimum (yals);
+  LOG ("now %d clauses unsatisfied", yals_nunsat (yals));
+  yals_check_xweighted_breaks (yals);
+  yals_check_global_invariant (yals);
+}
+
+static void yals_flip (Yals * yals) {
+  int cidx = yals_pick_clause (yals);
+  int lit = yals_pick_literal (yals, cidx);
+  yals->stats.flips++;
+  yals->stats.unsum += yals_nunsat (yals);
+  yals_flip_value_of_lit (yals, lit);
+  yals_make_clauses_after_flipping_lit (yals, lit);
+  yals_break_clauses_after_flipping_lit (yals, lit);
+  yals_flip_xclauses_after_flipping_lit (yals, lit);
+  yals_update_minimum (yals);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Preprocess the formula via unit propagation
+static void yals_preprocess (Yals * yals) {
+  int nvars = yals->nvars, lit, other, next, occ, w0, w1;
+  int * p, * c, * q, oldnlits, newnlits, satisfied, nsat, xnsat, nstr;
+  // For each literal l, watches[l] is a stack of clauses
+  // in which l is watched
+  STACK(int) * watches, * s;
+  // The truth assignment to literals
+  signed char * vals;
+
+  FIT (yals->cdb);
+  FIT (yals->xcdb);
+
+  NEWN (vals, 2*nvars);
+  vals += nvars;
+
+  NEWN (watches, 2*nvars);
+  watches += nvars;
+
+  // Initialize watched literals for OR clauses
+  for (c = yals->cdb.start; c < yals->cdb.top; c++) {
+    occ = c - yals->cdb.start;
+    assert (occ >= 0);
+    if (!(w0 = *c)) continue;
+    if (!(w1 = *++c)) continue;
+    LOGLITS (c - 1, "watching %d and %d in", w0, w1);
+    PUSH (watches[w0], occ);
+    PUSH (watches[w1], occ);
+    while (*++c)
+      ;
+  }
+
+  // Propagate units found in the initial formula
+  for (next = 0; !yals->mt && next < COUNT (yals->trail); next++) {
+    lit = PEEK (yals->trail, next);
+    LOG ("propagating %d", lit);
+    if (vals[lit] > 0) continue;
+    if (vals[lit] < 0) {
+      LOG ("inconsistent units %d and %d", -lit, lit);
+      yals->mt = 1;
+    } else {
+      // Assign `lit`
+      assert (!vals[lit]);
+      vals[lit] = 1;
+      assert (!vals[-lit]);
+      vals[-lit] = -1;
+
+      // Process OR clauses in which the negation of `lit` is watched
+      s = watches - lit;
+      for (p = s->start; !yals->mt && p < s->top; p++) {
+        occ = *p;
+        assert (occ >= 0);
+        c = yals->cdb.start + occ;
+        assert (c < yals->cdb.top);
+        if (c[1] != -lit) SWAP (int, c[0], c[1]);
+        assert (c[1] == -lit);
+        if (vals[w0 = c[0]] > 0) continue;
+        for (q = c + 2; (other = *q); q++)
+          if (vals[other] >= 0) break;
+        if (other) {
+          SWAP (int, c[1], *q);
+          LOGLITS (c, "watching %d instead of %d in", other, lit);
+          PUSH (watches[other], occ);
+        } else if (!vals[w0]) {
+          LOGLITS (c, "found new unit %d in", w0);
+          PUSH (yals->trail, w0);
+        } else {
+          assert (vals[w0] < 0);
+          LOGLITS (c, "found inconsistent");
+          yals->mt = 1;
+        }
+      }
+      RELEASE (*s);
+    }
+  }
+  FIT (yals->trail);
+  yals_msg (yals, 1,
+    "found %d units during unit propagation",
+    COUNT (yals->trail));
+
+  for (lit = -nvars; lit < nvars; lit++) RELEASE (watches[lit]);
+  watches -= nvars;
+  DELN (watches, 2*nvars);
+  oldnlits = COUNT (yals->cdb) + COUNT(yals->xcdb);
+
+  if (yals->mt) goto DONE;
+
+  // Remove satisfied OR clauses and falsified literals from OR clauses
+  nstr = nsat = 0;
+  q = yals->cdb.start;
+  for (c = q; c < yals->cdb.top; c++) {
+    satisfied = 0;
+    for (p = c; (lit = *p); p++)
+      if (vals[lit] > 0) satisfied = 1;
+    if (!satisfied) {
+      for (p = c; (lit = *p); p++) {
+        if (vals[lit] < 0) {
+          nstr++;
+          continue;
+        }
+        assert (!vals[lit]);
+        *q++ = lit;
+      }
+      assert (q >= yals->cdb.start + 2);
+      assert (q[-1]); assert (q[-2]);
+      *q++ = 0;
+    } else nsat++;
+    c = p;
+  }
+  yals->cdb.top = q;
+  FIT (yals->cdb);
+  newnlits = COUNT (yals->cdb);
+  assert (newnlits <= oldnlits);
+
+  // Remove satisfied XOR clauses or report conflict
+  xnsat = 0;
+  q = yals->xcdb.start;
+  int cidx = 0;
+  int ccidx = 0;
+  for (c = q; c < yals->xcdb.top; c++) {
+    satisfied = PEEK(yals->xparitydb, cidx);
+    int hasBlank = 0;
+    for (p = c; (lit = *p); p++) {
+      if (!vals[lit]) {
+        hasBlank = 1;
+        break;
+      }
+      satisfied ^= (vals[lit] == 1 ? 1 : 0);
+    }
+    // if all literals are assigned, XOR clause must be satisfied
+    if (!hasBlank) {
+      if (!satisfied) {
+        yals->mt = 1;
+        goto DONE;
+      }
+      xnsat++;
+    } else {
+      // copy XOR clauses
+      for (p = c; (lit = *p); p++) {
+        if (vals[lit] != 0) { // `lit` was assigned, flip parity if 1 and remove it from clause
+          if (vals[lit] > 0) {
+            POKE(yals->xparitydb, cidx, PEEK(yals->xparitydb, cidx) ^ 1);
+          }
+          nstr++;
+          continue;
+        }
+        *q++ = lit;
+      }
+      POKE(yals->xparitydb, ccidx, PEEK(yals->xparitydb, cidx));
+      ccidx++;
+      assert (q >= yals->xcdb.start + 1);
+      assert (q[-1]);
+      *q++ = 0;
+    }
+    c = p;
+    cidx++;
+  }
+  yals->xcdb.top = q;
+  FIT (yals->xcdb);
+  yals->xparitydb.top = yals->xparitydb.start + ccidx;
+  FIT (yals->xparitydb);
+  assert(COUNT (yals->xparitydb) == cidx - xnsat);
+  newnlits += COUNT(yals->xcdb);
+  assert(newnlits <= oldnlits);
+
+  yals_msg (yals, 1, "removed %d satisfied OR clauses", nsat);
+  yals_msg (yals, 1, "removed %d satisfied XOR clauses", xnsat);
+  yals_msg (yals, 1, "removed %d unit literal occurrences", nstr);
+  yals_msg (yals, 1,
+    "literal stack reduced by %d to %d from% d",
+    oldnlits - newnlits, newnlits, oldnlits);
+
+DONE:
+
+  vals -= nvars;
+  DELN (vals, 2*nvars);
+}
+
+/*------------------------------------------------------------------------*/
+
+static Word yals_primes[] = {
+  2000000011u, 2000000033u, 2000000063u, 2000000087u, 2000000089u,
+  2000000099u, 2000000137u, 2000000141u, 2000000143u, 2000000153u,
+  2000000203u, 2000000227u, 2000000239u, 2000000243u, 2000000269u,
+  2000000273u, 2000000279u, 2000000293u, 2000000323u, 2000000333u,
+  2000000357u, 2000000381u, 2000000393u, 2000000407u, 2000000413u,
+  2000000441u, 2000000503u, 2000000507u, 2000000531u, 2000000533u,
+  2000000579u, 2000000603u, 2000000609u, 2000000621u, 2000000641u,
+  2000000659u, 2000000671u, 2000000693u, 2000000707u, 2000000731u,
+};
+
+#define NPRIMES (sizeof(yals_primes)/sizeof(unsigned))
+
+static Word yals_sig (Yals * yals) {
+  unsigned i = 0, j;
+  Word res = 0;
+  for (j = 0; j < yals->nvarwords; j++) {
+    res += yals_primes[i++] * yals->vals[j];
+    if (i == NPRIMES) i = 0;
+  }
+  return res;
+}
+
+static unsigned yals_gcd (unsigned a, unsigned b) {
+  while (b) {
+    unsigned r = a % b;
+    a = b, b = r;
+  }
+  return a;
+}
+
+static void yals_cache_assignment (Yals * yals) {
+  int min, other_min, cachemax, cachemin, cachemincount, cachemaxcount;
+  unsigned start, delta, i, j, ncache, rpos;
+  Word sig, other_sig, * other_vals;
+  size_t bytes;
+#ifndef NDEBUG
+  int count;
+#endif
+
+  if (!yals->opts.cachemin.val) return;
+  sig = yals_sig (yals);
+  ncache = COUNT (yals->cache);
+  for (i = 0; i < ncache; i++) {
+    other_sig = PEEK (yals->sigs, i);
+    yals->stats.sig.search++;
+    if (other_sig != sig) { yals->stats.sig.neg++; continue; }
+    other_vals = PEEK (yals->cache, i);
+    for (j = 0; j < yals->nvarwords; j++)
+      if (other_vals[j] != yals->tmp[j]) break;
+    if (j == yals->nvarwords) {
+      yals_msg (yals, 2, "current assigment already in cache");
+      yals->stats.cache.skipped++;
+      yals->stats.sig.truepos++;
+      return;
+    }
+    yals->stats.sig.falsepos++;
+  }
+
+  cachemin = INT_MAX, cachemax = -1;
+  cachemaxcount = cachemincount = 0;
+  for (j = 0; j < ncache; j++) {
+    other_min = PEEK (yals->mins, j);
+    if (other_min < cachemin) cachemin = other_min, cachemincount = 0;
+    if (other_min > cachemax) cachemax = other_min, cachemaxcount = 0;
+    if (other_min == cachemin) cachemincount++;
+    if (other_min == cachemax) cachemaxcount++;
+  }
+  yals_msg (yals, 2,
+    "cache of size %d minimum %d (%d = %.0f%%) maximum %d (%d = %.0f%%)",
+    ncache,
+    cachemin, cachemincount, yals_pct (cachemincount, ncache),
+    cachemax, cachemaxcount, yals_pct (cachemaxcount, ncache));
+
+  min = yals->stats.tmp;
+  assert (min <= yals_nunsat (yals));
+  bytes = yals->nvarwords * sizeof (Word);
+  if (!yals->cachesizetarget) {
+    yals->cachesizetarget = yals->opts.cachemin.val;
+    assert (yals->cachesizetarget);
+    yals_msg (yals, 2,
+      "initial cache size target of %d",
+      yals->cachesizetarget);
+  }
+
+  if (ncache < yals->cachesizetarget) {
+PUSH_ASSIGNMENT:
+    yals_msg (yals, 2,
+      "pushing current assigment with minimum %d in cache as assignment %d",
+      min, ncache);
+    NEWN (other_vals, yals->nvarwords);
+    memcpy (other_vals, yals->tmp, bytes);
+    PUSH (yals->cache, other_vals);
+    PUSH (yals->sigs, sig);
+    PUSH (yals->mins, min);
+    yals->stats.cache.inserted++;
+  } else {
+    assert (ncache == yals->cachesizetarget);
+    if (ncache == 1) start = delta = 0;
+    else {
+      start = yals_rand_mod (yals, ncache);
+      delta = yals_rand_mod (yals, ncache - 1) + 1;
+      while (yals_gcd (ncache, delta) != 1)
+        delta--;
+    }
+    rpos = ncache;
+    j = start;
+#ifndef NDEBUG
+    count = 0;
+#endif
+    do {
+      other_min = PEEK (yals->mins, j);
+      assert (other_min >= cachemin);
+      assert (other_min <= cachemax);
+      if (other_min == cachemax && other_min > min) rpos = j;
+      j += delta;
+      if (j >= ncache) j -= ncache, assert (j < ncache);
+#ifndef NDEBUG
+      count++;
+#endif
+    } while (j != start);
+    assert (count == ncache);
+
+    if (rpos < ncache) {
+      assert (min < cachemax);
+      assert (PEEK (yals->mins, rpos) == cachemax);
+      yals_msg (yals, 2,
+        "replacing cached %d (minimum %d) better minimum %d",
+        rpos, cachemax, min);
+      other_vals = PEEK (yals->cache, rpos);
+      memcpy (other_vals, yals->tmp, bytes);
+      POKE (yals->mins, rpos, min);
+      POKE (yals->sigs, rpos, sig);
+      yals->stats.cache.replaced++;
+    } else if (min > cachemax ||
+               (cachemin < cachemax && min == cachemax)) {
+DO_NOT_CACHE_ASSSIGNEMNT:
+      yals_msg (yals, 2,
+        "local minimum %d not cached needs %d",
+        min, cachemax-1);
+      yals->stats.cache.skipped++;
+    } else {
+      assert (min == cachemin);
+      assert (min == cachemax);
+      assert (min == yals->stats.best);
+      if (yals->cachesizetarget < yals->opts.cachemax.val) {
+        yals->cachesizetarget *= 2;
+        if (yals->cachesizetarget < ncache) {
+          yals->cachesizetarget = ncache;
+          goto DO_NOT_CACHE_ASSSIGNEMNT;
+        }
+        yals_msg (yals, 2,
+          "new cache size target of %d",
+          yals->cachesizetarget);
+        goto PUSH_ASSIGNMENT;
+      } else goto DO_NOT_CACHE_ASSSIGNEMNT;
+    }
+  }
+}
+
+static void yals_remove_trailing_bits (Yals * yals) {
+  unsigned i;
+  Word mask;
+  if (!yals->nvarwords) return;
+  i = yals->nvars & BITMAPMASK;
+  mask = ((Word)1) << (i + 1);
+  yals->vals[yals->nvarwords-1] &= mask - 1;
+}
+
+// Sets literals in the assignment forced by unit propagation
+static void yals_set_units (Yals * yals) {
+  const Word * eow, * c, * s;
+  Word * p = yals->vals, tmp;
+  eow = p + yals->nvarwords;
+  c = yals->clear;
+  s = yals->set;
+  while (p < eow) {
+    tmp = *p;
+    tmp &= *c++;
+    tmp |= *s++;
+    *p++ = tmp;
+  }
+  assert (s == yals->set + yals->nvarwords);
+  assert (c == yals->clear + yals->nvarwords);
+}
+
+static void yals_setphases (Yals * yals) {
+  int i, idx, lit;
+  yals_msg (yals, 1,
+    "forcing %d initial phases", (int) COUNT (yals->phases));
+  for (i = 0; i < COUNT (yals->phases); i++) {
+    lit = PEEK (yals->phases, i);
+    assert (lit);
+    idx = ABS (lit);
+    if (idx >= yals->nvars) {
+      LOG ("skipping setting phase of %d", lit);
+      continue;
+    }
+    LOG ("setting phase of %d", lit);
+    if (lit > 0) SETBIT (yals->vals, yals->nvarwords, idx);
+    else CLRBIT (yals->vals, yals->nvarwords, idx);
+  }
+  RELEASE (yals->phases);
+}
+
+static void yals_pick_assignment (Yals * yals, int initial) {
+  int idx, pos, neg, i, nvars = yals->nvars, ncache;
+  size_t bytes = yals->nvarwords * sizeof (Word);
+  const int vl = 1 + !initial;
+  if (!initial && yals->opts.best.val) {
+    yals->stats.pick.best++;
+    yals_msg (yals, vl, "picking previous best assignment");
+    memcpy (yals->vals, yals->best, bytes);
+  } else if (!initial && yals->opts.keep.val) {
+    yals->stats.pick.keep++;
+    yals_msg (yals, vl, "picking current assignment (actually keeping it)");
+  } else if (!initial &&
+             yals->strat.cached &&
+             (ncache = COUNT (yals->cache)) > 0) {
+    if (!yals->opts.cacheduni.val)  {
+      assert (EMPTY (yals->cands));
+      assert (EMPTY (yals->scores));
+      for (i = 0; i < ncache; i++) {
+        int min = PEEK (yals->mins, i);
+        assert (min >= 0);
+        PUSH (yals->cands, i);
+        if (yals->opts.cachedinv.val)
+            PUSH (yals->scores, 1.0/min);
+        else
+            PUSH (yals->scores, min);
+      }
+      pos = yals_pick_by_score (yals);
+      CLEAR (yals->scores);
+      CLEAR (yals->cands);
+    } else pos = yals_rand_mod (yals, ncache);
+    yals->stats.pick.cached++;
+    yals_msg (yals, vl,
+      "picking cached assignment %d with minimum %d",
+      pos, PEEK (yals->mins, pos));
+    memcpy (yals->vals, PEEK (yals->cache, pos), bytes);
+  } else if (yals->strat.pol < 0) {
+    yals->stats.pick.neg++;
+    yals_msg (yals, vl, "picking all negative assignment");
+    memset (yals->vals, 0, bytes);
+  } else if (yals->strat.pol > 0) {
+    yals->stats.pick.pos++;
+    yals_msg (yals, vl, "picking all positive assignment");
+    memset (yals->vals, 0xff, bytes);
+  } else {
+    yals->stats.pick.rnd++;
+    yals_msg (yals, vl, "picking new random assignment");
+    for (i = 0; i < yals->nvarwords; i++)
+      yals->vals[i] = yals_rand (yals);
+  }
+  yals_remove_trailing_bits (yals);
+  if (initial) yals_setphases (yals);
+  yals_set_units (yals);
+  if (yals->opts.verbose.val <= 2) return;
+  pos = neg = 0;
+  for (idx = 1; idx < nvars; idx++)
+    if (GETBIT (yals->vals, yals->nvarwords, idx)) pos++;
+  neg = nvars - pos;
+  yals_msg (yals, vl,
+    "new full assignment %d positive %d negative", pos, neg);
+}
+
+static void yals_log_assignment (Yals * yals) {
+#ifndef NDEBUG
+  int idx;
+  if (!yals->opts.logging.val) return;
+  for (idx = 1; idx < yals->nvars; idx++) {
+    int lit = yals_val (yals, idx) ? idx : -idx;
+    LOG ("assigned %d", lit);
+  }
+#endif
+}
+
+static float yals_len_to_weight (Yals * yals, int len) {
+  // const int uni = yals->strat.uni;
+  // const int weight = yals->strat.weight;
+  const float weight2 = (float)yals->opts.weight2.val / 100.0;
+  const float weight3 = (float)yals->opts.weight3.val / 100.0;
+  const float weight4 = (float)yals->opts.weight4.val / 100.0;
+  const float weight5 = (float)yals->opts.weight5.val / 100.0;
+  const float weight6 = (float)yals->opts.weight6.val / 100.0;
+  const float weight7 = (float)yals->opts.weight7.val / 100.0;
+  const float weight8 = (float)yals->opts.weight8.val / 100.0;
+  float w;
+
+//  if (uni > 0) w = weight;
+//  else if (uni < 0) w = MIN (len, weight);
+//  else w = MAX (weight - len, 1);
+  if (len == 2)
+    w = weight2;
+  else if (len == 3)
+    w = weight3;
+  else if (len == 4)
+    w = weight4;
+  else if (len == 5)
+    w = weight5;
+  else if (len == 6)
+    w = weight6;
+  else if (len == 7)
+    w = weight7;
+  else
+    w = weight8;
+
+  return w;
+}
+
+static void yals_update_sat_and_unsat (Yals * yals) {
+  int lit, cidx, len, cappedlen, crit;
+  const int * lits, * p;
+  unsigned satcnt;
+  yals_log_assignment (yals);
+  yals_reset_unsat (yals);
+  for (len = 1; len <= MAXLEN; len++)
+    yals->weights[len] = yals_len_to_weight (yals, len);
+  yals->xorweight = ((float)yals->opts.xorweight.val / 100.0f);
+  if (yals->crit) {
+    memset (yals->weightedbreak, 0, 2*yals->nvars*sizeof(float));
+    memset (yals->xweightedbreak, 0, yals->nvars*sizeof(float));
+  }
+  for (cidx = 0; cidx < yals->nclauses; cidx++) {
+    satcnt = 0;
+    lits = yals_lits (yals, cidx);
+    crit = 0;
+    for (p = lits; (lit = *p); p++) {
+      if (!yals_val (yals, lit)) continue;
+      crit ^= lit;
+      satcnt++;
+    }
+
+    if (yals->crit) yals->crit[cidx] = crit;
+    len = p - lits;
+    cappedlen = MIN (len, MAXLEN);
+    LOGCIDX (cidx,
+       "sat count %u length %d weight %u for",
+       satcnt, len, yals->weights[cappedlen]);
+    yals_setsatcnt (yals, cidx, satcnt);
+    if (!satcnt) {
+      yals_enqueue (yals, cidx);
+      LOGCIDX (cidx, "broken");
+    } else if (yals->crit && satcnt == 1)
+      yals_inc_weighted_break (yals, yals->crit[cidx], yals->weights[cappedlen]); // TODO avoid mem on yals->weights if uniform weights
+  }
+
+  for (cidx = 0; cidx < yals->nxclauses; cidx++) {
+    lits = yals_xlits(yals, cidx);
+    U1 sat = *(yals->xparitydb.start + cidx);
+    for (p = lits; (lit = *p); p++) {
+      sat ^= yals_val(yals, lit);
+    }
+    yals_setxorsat(yals, cidx, sat);
+    if (!sat) {
+      yals_enqueue (yals, yals->nclauses + cidx);
+      LOGCIDX (yals->nclauses + cidx, "broken");
+    } else if (yals->crit) {
+      for (p = lits; (lit = *p); p++) {
+        // In a satisfied XOR clause, every literal is critical
+        yals_inc_xweighted_break(yals, lit, yals->xorweight);
+      }
+    }
+  }
+  yals_check_xweighted_breaks (yals);
+  yals_check_global_invariant (yals);
+}
+
+// Precomputes exponential/power literal weighing functions
+static void yals_init_weight_to_score_table (Yals * yals) {
+  double cb, invcb, score, eps;
+  const double start = 1e150;
+  int maxlen = yals->maxlen;
+  unsigned i;
+
+  // probSAT SC'13 values:
+  //     if (maxlen <= 3) cb = 2.5;	// from Adrian's thesis ...
+  //else if (maxlen <= 4) cb = 2.85;
+  //else if (maxlen <= 5) cb = 3.7;
+  //else if (maxlen <= 6) cb = 5.1;
+  //else                  cb = 5.4;
+
+  cb = (double)yals->opts.cb.val / 100.0;
+
+  yals_msg (yals, 1,
+    "exponential base cb = %f for maxlen %d",
+    cb, maxlen);
+
+  eps = 0;
+  invcb = 1.0 / pow(cb, 0.01);
+  score = start;
+  for (i = 0; score && i < 100000; i++) {
+    //LOG ("exp2(-%d) = %g", i, score);
+    PUSH (yals->exp.table.two, score);
+    eps = score;
+    score *= invcb;
+  }
+  assert (eps > 0);
+  assert (i == COUNT (yals->exp.table.two));
+  yals->exp.max.two = i;
+  yals->exp.eps.two = eps;
+  yals_msg (yals, 1, "exp2(<= %d) = %g", -i, eps);
+
+  invcb = 1.0 / cb;
+  assert (invcb < 1.0);
+  score = start;
+  eps = 0.0;
+  for (i = 0; score && i < 1000000; i++) {
+    //LOG ("pow(%f,-%d) = %g", cb, i, score);
+    PUSH (yals->exp.table.cb, score);
+    eps = score;
+    score *= invcb;
+  }
+  assert (eps > 0);
+  assert (i == COUNT (yals->exp.table.cb));
+  yals->exp.max.cb = i;
+  yals->exp.eps.cb = eps;
+  yals_msg (yals, 1, "pow(%f,(<= %d)) = %g", cb, -i, eps);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Computes positions of clauses in the database, literal occurrences in the formula,
+// and some statistics
+static void yals_connect (Yals * yals) {
+  int idx, n, lit, nvars = yals->nvars, * count, cidx, sign;
+  long long sumoccs, sumlen; int minoccs, maxoccs, minlen, maxlen;
+  int * occsptr, occs, len, lits, nused, uniform;
+  int nclauses, nbin, ntrn, nquad, nlarge;
+  const int * p,  * q;
+
+  FIT (yals->cdb);
+  FIT (yals->xcdb);
+  RELEASE (yals->mark);
+  RELEASE (yals->clause);
+
+  maxlen = 0;
+  sumlen = 0;
+  minlen = INT_MAX;
+  nclauses = nbin = ntrn = nquad = nlarge = 0;
+
+  // Count binary, ternary, quaternary OR clauses
+  // as well as find min/max OR clause lengths
+  for (p = yals->cdb.start; p < yals->cdb.top; p = q + 1) {
+    for (q = p; *q; q++)
+      ;
+    len = q - p;
+
+         if (len == 2) nbin++;
+    else if (len == 3) ntrn++;
+    else if (len == 4) nquad++;
+    else               nlarge++;
+
+    nclauses++;
+
+    sumlen += len;
+    if (len > maxlen) maxlen = len;
+    if (len < minlen) minlen = len;
+  }
+
+  // Count XOR clauses
+  // TODO(WN): also count XOR lengths here?
+  int nxclauses = 0;
+  for (p = yals->xcdb.start; p < yals->xcdb.top; p = q+1) {
+    for (q = p; *q; q++) {}
+
+    nxclauses++;
+  }
+
+  yals_msg (yals, 1,
+    "found %d binary, %d ternary and %d large OR clauses",
+    nbin, ntrn, nclauses - nbin - ntrn);
+
+  yals_msg (yals, 1,
+    "size of OR literal stack %d (%d for large clauses only)",
+    (int) COUNT (yals->cdb),
+    ((int) COUNT (yals->cdb)) - 3*nbin - 4*ntrn);
+
+  yals_msg (yals, 1,
+    "size of XOR literal stack %d",
+    (int) COUNT (yals->xcdb));
+
+  yals->maxlen = maxlen;
+  yals->minlen = minlen;
+#ifndef NYALSTATS
+  yals->stats.nincdec = MAX (maxlen + 1, 3);
+  NEWN (yals->stats.inc, yals->stats.nincdec);
+  NEWN (yals->stats.dec, yals->stats.nincdec);
+#endif
+
+  if ((INT_MAX >> LENSHIFT) < nclauses)
+    yals_abort (yals,
+      "maximum number of OR clauses %d exceeded",
+      (INT_MAX >> LENSHIFT));
+
+  if ((INT_MAX >> LENSHIFT) < nxclauses)
+    yals_abort (yals,
+      "maximum number of XOR clauses %d exceeded",
+      (INT_MAX >> LENSHIFT));
+
+  yals->nclauses = nclauses;
+  yals->nxclauses = nxclauses;
+  yals->nbin = nbin;
+  yals->ntrn = ntrn;
+  yals_msg (yals, 1, "connecting %d OR clauses, %d XOR clauses", nclauses, nxclauses);
+
+  // Init yals->lits
+  NEWN (yals->lits, nclauses);
+  lits = 0;
+  for (cidx = 0; cidx < nclauses; cidx++) {
+    yals->lits[cidx] = lits;
+    while (PEEK (yals->cdb, lits)) lits++;
+    lits++;
+  }
+  assert (lits == COUNT (yals->cdb));
+
+  // Init yals->xlits
+  NEWN (yals->xlits, nxclauses);
+  lits = 0;
+  for (cidx = 0; cidx < nxclauses; cidx++) {
+    yals->xlits[cidx] = lits;
+    while (PEEK (yals->xcdb, lits)) lits++;
+    lits++;
+  }
+  assert (lits == COUNT (yals->xcdb));
+
+  NEWN (yals->weights, MAXLEN + 1);
+
+  NEWN (count, 2*nvars);
+  count += nvars;
+  int * xcount;
+  NEWN (xcount, nvars);
+
+  maxoccs = -1;
+  minoccs = INT_MAX;
+  sumoccs = 0;
+
+  // Count literals in OR clauses
+  for (cidx = 0; cidx < yals->nclauses; cidx++) {
+    for (p = yals_lits (yals, cidx); (lit = *p); p++) {
+      count[lit]++;
+    }
+  }
+
+  // Count literals in XOR clauses
+  for (cidx = 0; cidx < yals->nxclauses; cidx++) {
+    for (p = yals_xlits(yals, cidx); (idx = *p); p++) {
+      xcount[idx]++;
+    }
+  }
+
+  occs = 0;
+  nused = 0;
+  for (lit = 1; lit < nvars; lit++) {
+    int sum = count[lit] + count[-lit] + xcount[lit];
+    occs += sum + 3; // `sum` slots for the actual occurrences + 3 end-of-list markers
+
+    if (sum) nused++;
+  }
+
+  assert (nused <= nvars);
+  if (nused == nvars)
+    yals_msg (yals, 1, "all variables occur");
+  else
+    yals_msg (yals, 1,
+      "%d variables used out of %d, %d do not occur %.0f%%",
+      nused, nvars, nvars - nused, yals_pct (nvars-nused, nvars));
+
+  yals->noccs = occs;
+  LOG ("size of occurrences stack %d", occs);
+  NEWN (yals->occs, yals->noccs);
+
+  NEWN (yals->refs, 3*nvars);
+
+  occs = 0;
+  for (lit = 1; lit < nvars; lit++) {
+    n = count[lit];
+    LOG ("literal %d occurs %d times in OR clauses", lit, n);
+    *yals_refs (yals, lit) = occs;
+    occs += n;
+    yals->occs[occs++] = -1;
+    n = count[-lit];
+    LOG ("literal %d occurs %d times in OR clauses", -lit, n);
+    *yals_refs (yals, -lit) = occs;
+    occs += n;
+    yals->occs[occs++] = -1;
+    n = xcount[lit];
+    LOG ("variable %d occurs %d times in XOR clauses", lit, n);
+    *yals_xrefs (yals, lit) = occs;
+    occs += n;
+    yals->occs[occs++] = -1;
+  }
+  assert (occs == yals->noccs);
+
+  yals->avglen = yals_avg (sumlen, yals->nclauses);
+
+  // TODO(WN): again, do we care about XOR lengths?
+  // maybe we prefer to break short XORs than long ones?
+  if (minlen == maxlen) {
+    yals_msg (yals, 1,
+      "all %d OR clauses are of uniform length %d",
+      yals->nclauses, maxlen);
+  } else if (maxlen >= 0) {
+    yals_msg (yals, 1,
+      "average OR clause length %.2f (min %d, max %d)",
+      yals->avglen, minlen, maxlen);
+    yals_msg (yals, 2,
+      "%d binary OR %.0f%%, %d ternary OR %.0f%% ",
+      nbin, yals_pct (nbin, yals->nclauses),
+      ntrn, yals_pct (ntrn, yals->nclauses));
+    yals_msg (yals, 2,
+      "%d quaterny OR %.0f%%, %d large OR clauses %.0f%%",
+      nquad, yals_pct (nquad, yals->nclauses),
+      nlarge, yals_pct (nlarge, yals->nclauses));
+  }
+
+  if (minlen == maxlen && !yals->opts.toggleuniform.val) uniform = 1;
+  else if (minlen != maxlen && yals->opts.toggleuniform.val) uniform = 1;
+  else uniform = 0;
+
+  if (uniform) {
+    yals_msg (yals, 1,
+      "using uniform strategy for clauses of length %d", maxlen);
+    yals->uniform = maxlen;
+  } else {
+    yals_msg (yals, 1, "using standard non-uniform strategy");
+    yals->uniform = 0;
+  }
+
+  yals_msg (yals, 1,
+    "clause variable ratio %.3f = %d / %d",
+    yals_avg (nclauses, nused), nclauses, nused);
+
+  for (idx = 1; idx < nvars; idx++)
+    for (sign = 1; sign >= -1; sign -= 2) {
+      lit = sign * idx;
+      occs = count[lit] + xcount[idx];
+      if (!occs) continue;
+      sumoccs += occs;
+      if (occs > maxoccs) maxoccs = occs;
+      if (occs < minoccs) minoccs = occs;
+    }
+
+  // Init yals->occs by writing, for each clause in which it occurs,
+  // a bitpacked (clause index, clause length) value into each literal's
+  // occurrences array
+  for (cidx = 0; cidx < yals->nclauses; cidx++) {
+    p = yals_lits (yals, cidx);
+    len = 0;
+    while (len < MAXLEN && p[len]) len++;
+    while ((lit = *p++)) {
+      occsptr = yals_refs (yals, lit);
+      occs = *occsptr;
+      assert_valid_occs (occs);
+      assert (!yals->occs[occs]);
+      yals->occs[occs] = (cidx << LENSHIFT) | len;
+      *occsptr = occs + 1;
+    }
+  }
+
+
+  // Init the XOR parts of yals->xoccs like above
+  for (cidx = 0; cidx < yals->nxclauses; cidx++) {
+    p = yals_xlits(yals, cidx);
+    len = 0;
+    while (len < MAXLEN && p[len]) len++;
+    while ((lit = *p++)) {
+      occsptr = yals_xrefs(yals, lit);
+      occs = *occsptr;
+      assert_valid_occs(occs);
+      assert (!yals->occs[occs]);
+      yals->occs[occs] = (cidx << LENSHIFT) | len;
+      *occsptr = occs + 1;
+    }
+  }
+
+  for (idx = 1; idx < nvars; idx++) {
+    for (sign = 1; sign >= -1; sign -= 2) {
+      lit = sign * idx;
+      occsptr = yals_refs (yals, lit);
+      occs = *occsptr;
+      assert_valid_occs (occs);
+      assert (yals->occs[occs] == -1);
+      n = count[lit];
+      assert (occs >= n);
+      *occsptr = occs - n;
+    }
+
+    occsptr = yals_xrefs (yals, idx);
+    occs = *occsptr;
+    assert_valid_occs (occs);
+    assert (yals->occs[occs] == -1);
+    n = xcount[idx];
+    assert (occs >= n);
+    *occsptr = occs - n;
+  }
+
+  count -= nvars;
+  DELN (count, 2*nvars);
+  DELN (xcount, nvars);
+
+  yals_msg (yals, 1,
+    "average literal occurrence %.2f (min %d, max %d)",
+    yals_avg (sumoccs, yals->nvars)/2.0, minoccs, maxoccs);
+
+  if (yals->uniform) yals->pick = yals->opts.unipick.val;
+  else yals->pick = yals->opts.pick.val;
+
+  yals_msg (yals, 1, "picking %s", yals_pick_to_str (yals));
+
+  yals->unsat.usequeue = (yals->pick > 0);
+
+  yals_msg (yals, 1,
+    "using %s for unsat clauses",
+    yals->unsat.usequeue ? "queue" : "stack");
+
+  if (yals->unsat.usequeue) NEWN (yals->lnk, nclauses + nxclauses);
+  else {
+    NEWN (yals->pos, nclauses + nxclauses);
+    for (cidx = 0; cidx < nclauses + nxclauses; cidx++) yals->pos[cidx] = -1;
+  }
+
+  yals->nvarwords = (nvars + BITS_PER_WORD - 1) / BITS_PER_WORD;
+
+  yals_msg (yals, 1, "%d x %d-bit words per assignment (%d bytes = %d KB)",
+    yals->nvarwords,
+    BITS_PER_WORD,
+    yals->nvarwords * sizeof (Word),
+    (yals->nvarwords * sizeof (Word) >> 10));
+
+  // Init yals->set and yals->clear
+  NEWN (yals->set, yals->nvarwords);
+  NEWN (yals->clear, yals->nvarwords);
+  memset (yals->clear, 0xff, yals->nvarwords * sizeof (Word));
+  while (!EMPTY (yals->trail)) {
+    lit = POP (yals->trail);
+    idx = ABS (lit);
+    if (lit < 0) CLRBIT (yals->clear, yals->nvarwords, idx);
+    else SETBIT (yals->set, yals->nvarwords, idx);
+  }
+  RELEASE (yals->trail);
+
+  // Init the assignment
+  NEWN (yals->vals, yals->nvarwords);
+
+  // Init some other stuff
+  NEWN (yals->best, yals->nvarwords);
+  NEWN (yals->tmp, yals->nvarwords);
+  NEWN (yals->flips, nvars);
+
+  if (maxlen < (1<<8)) {
+    yals->satcntbytes = 1;
+    NEWN (yals->satcnt1, yals->nclauses);
+  } else if (maxlen < (1<<16)) {
+    yals->satcntbytes = 2;
+    NEWN (yals->satcnt2, yals->nclauses);
+  } else {
+    yals->satcntbytes = 4;
+    NEWN (yals->satcnt4, yals->nclauses);
+  }
+  yals_msg (yals, 1,
+    "need %d bytes per clause for counting satisfied literals",
+    yals->satcntbytes);
+
+  NEWN (yals->xorsat, yals->nxclauses);
+
+  if (yals->opts.crit.val) {
+
+    yals_msg (yals, 1,
+      "dynamically computing break values on-the-fly "
+      "using critical literals");
+    NEWN (yals->crit, nclauses);
+    NEWN (yals->weightedbreak, 2*nvars);
+    NEWN (yals->xweightedbreak, nvars);
+  } else
+    yals_msg (yals, 1, "eagerly computing break values");
+
+  yals_init_weight_to_score_table (yals);
+}
+
+/*------------------------------------------------------------------------*/
+
+#define SETOPT(NAME,DEFAULT,MIN,MAX,DESCRIPTION) \
+do { \
+  int OLD; \
+  if (strcmp (name, #NAME)) break; \
+  if(val < (MIN)) { \
+    yals_warn (yals, \
+      "can not set option '%s' smaller than %d", name, (MIN)); \
+    val = (MIN); \
+  } \
+  if(val > (MAX)) { \
+    yals_warn (yals, \
+      "can not set option '%s' larger than %d", name, (MAX)); \
+    val = (MAX); \
+  } \
+  OLD = yals->opts.NAME.val; \
+  if (OLD == val) \
+    yals_msg (yals, 2, \
+      "keeping option '%s' add old value %d", name, val); \
+  else { \
+    yals_msg (yals, 1, \
+      "setting option '%s' to %d (previous value %d)", name, val, OLD); \
+    yals->opts.NAME.val = val; \
+  } \
+  return 1; \
+} while (0)
+
+#undef OPT
+#define OPT SETOPT
+
+int yals_setopt (Yals * yals, const char * name, int val) {
+  OPTSTEMPLATE
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+#define GETOPT(NAME,DEFAULT,MIN,MAX,DESCRIPTION) \
+do { \
+  if (!strcmp (name, #NAME)) return yals->opts.NAME.val; \
+} while (0)
+
+#undef OPT
+#define OPT GETOPT
+
+int yals_getopt (Yals * yals, const char * name) {
+  OPTSTEMPLATE
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+#define USGOPT(NAME,DEFAULT,MIN,MAX,DESCRIPTION) \
+do { \
+  char BUFFER[120]; int I; \
+  sprintf (BUFFER, "--%s=%d..%d", #NAME, (MIN), (MAX)); \
+  fputs (BUFFER, yals->out); \
+  for (I = 28 - strlen (BUFFER); I > 0; I--) fputc (' ', yals->out); \
+  fprintf (yals->out, "%s [%d]\n", (DESCRIPTION), (int)(DEFAULT)); \
+} while (0)
+
+#undef OPT
+#define OPT USGOPT
+
+void yals_usage (Yals * yals) {
+  yals_msglock (yals);
+  OPTSTEMPLATE
+  yals_msgunlock (yals);
+}
+
+/*------------------------------------------------------------------------*/
+
+#define SHOWOPT(NAME,DEFAULT,MIN,MAX,DESCRIPTION) \
+do { \
+  yals_msg (yals, 0, "--%s=%d", #NAME, yals->opts.NAME); \
+} while (0)
+
+#undef OPT
+#define OPT SHOWOPT
+
+void yals_showopts (Yals * yals) { OPTSTEMPLATE }
+
+/*------------------------------------------------------------------------*/
+
+static void yals_envopt (Yals * yals, const char * name, Opt * opt) {
+  int len = strlen (name) + strlen ("YALS") + 1, val, ch;
+  char * env = yals_malloc (yals, len), * p;
+  const char * str;
+  sprintf (env, "yals%s",name);
+  for (p = env; (ch = *p); p++) *p = toupper (ch);
+  if ((str = getenv (env))) {
+    val = atoi (str);
+    val = MIN (opt->min, val);
+    val = MAX (opt->max, val);
+    opt->val = val;
+  }
+  yals_free (yals, env, len);
+}
+
+#define INITOPT(NAME,DEFAULT,MIN,MAX,DESCRIPTION) \
+do { \
+  assert ((MIN) <= (DEFAULT)); \
+  assert ((DEFAULT) <= (MAX)); \
+  yals->opts.NAME.def = (DEFAULT); \
+  yals->opts.NAME.val = (DEFAULT); \
+  yals->opts.NAME.min = (MIN); \
+  yals->opts.NAME.max = (MAX); \
+  yals_envopt (yals, #NAME, &yals->opts.NAME); \
+} while (0)
+
+#undef OPT
+#define OPT INITOPT
+
+static void yals_initopts (Yals * yals) { OPTSTEMPLATE }
+
+/*------------------------------------------------------------------------*/
+
+static void * yals_default_malloc (void * state, size_t bytes) {
+  (void) state;
+  return malloc (bytes);
+}
+
+static void * yals_default_realloc (void * state, void * ptr,
+                                    size_t old_bytes, size_t new_bytes) {
+  (void) state;
+  (void) old_bytes;
+  return realloc (ptr, new_bytes);
+}
+
+static void yals_default_free (void * state, void * ptr, size_t bytes) {
+  (void) state;
+  (void) bytes;
+  return free (ptr);
+}
+
+/*------------------------------------------------------------------------*/
+
+Yals * yals_new_with_mem_mgr (void * mgr,
+                              YalsMalloc m, YalsRealloc r, YalsFree f) {
+  Yals * yals;
+  assert (m), assert (r), assert (f);
+  yals = m (mgr, sizeof *yals);
+  if (!yals) yals_abort (0, "out-of-memory allocating manager in 'yals_new'");
+  memset (yals, 0, sizeof *yals);
+  yals->out = stdout;
+  yals->mem.mgr = mgr;
+  yals->mem.malloc = m;
+  yals->mem.realloc = r;
+  yals->mem.free = f;
+  yals->stats.tmp = INT_MAX;
+  yals->stats.best = INT_MAX;
+  yals->stats.last = INT_MAX;
+  yals->limits.report.min = INT_MAX;
+  yals_inc_allocated (yals, sizeof *yals);
+  yals_srand (yals, 0);
+  yals_initopts (yals);
+  yals->opts.prefix = yals_strdup (yals, YALS_DEFAULT_PREFIX);
+  yals->limits.flips = -1;
+#ifndef NYALSMEMS
+  yals->limits.mems = -1;
+#endif
+#ifndef NYALSTATS
+  yals->stats.wb.min = UINT_MAX;
+  yals->stats.wb.max = 0;
+#endif
+#if 0
+  if (getenv ("YALSAMPLES") && getenv ("YALSMOD")) {
+    int s = atoi (getenv ("YALSAMPLES")), i;
+    int m = atoi (getenv ("YALSMOD"));
+    double start = yals_time (yals), delta;
+    int64_t * count;
+    if (m <= 0) m = 1;
+    yals_msg (yals, 0, "starting to sample %d times RNG mod %d", s, m);
+    NEWN (count, m);
+    for (i = 0; i < s; i++) {
+      int r = yals_rand_mod (yals, m);
+      assert (0 <= r), assert (r < m);
+      count[r]++;
+    }
+    for (i = 0; i < m; i++)
+      yals_msg (yals, 0,
+        " mod %6d hit %10d times %7.2f%% with error %7.2f%%",
+        i, count[i], yals_pct (count[i], s),
+        yals_pct (count[i] - s/(double)m, s/(double) m));
+    DELN (count, m);
+    delta = yals_time (yals) - start;
+    yals_msg (yals, 0,
+      "finished sampling RNG in %.3f seconds, %.2f ns per 'rand'",
+      delta, yals_avg (delta*1e9, s));
+  }
+#endif
+  return yals;
+}
+
+Yals * yals_new () {
+  return yals_new_with_mem_mgr (0,
+           yals_default_malloc, yals_default_realloc, yals_default_free);
+}
+
+static void yals_reset_cache (Yals * yals) {
+  int ncache = COUNT (yals->cache);
+  Word ** w;
+  for (w = yals->cache.start; w < yals->cache.top; w++)
+    DELN (*w, yals->nvarwords);
+  RELEASE (yals->cache);
+  yals->cachesizetarget = 0;
+  yals_msg (yals, 1, "reset %d cache lines", ncache);
+}
+
+void yals_del (Yals * yals) {
+  yals_reset_cache (yals);
+  yals_reset_unsat (yals);
+  RELEASE (yals->cdb);
+  RELEASE (yals->xcdb);
+  RELEASE (yals->xparitydb);
+  RELEASE (yals->clause);
+  RELEASE (yals->mark);
+  RELEASE (yals->mins);
+  RELEASE (yals->sigs);
+  RELEASE (yals->breaks);
+  RELEASE (yals->scores);
+  RELEASE (yals->cands);
+  RELEASE (yals->trail);
+  RELEASE (yals->phases);
+  RELEASE (yals->exp.table.two);
+  RELEASE (yals->exp.table.cb);
+  RELEASE (yals->minlits);
+  if (yals->unsat.usequeue) DELN (yals->lnk, yals->nclauses + yals->nxclauses);
+  else DELN (yals->pos, yals->nclauses + yals->nxclauses);
+  DELN (yals->lits, yals->nclauses);
+  DELN (yals->xlits, yals->nxclauses);
+  if (yals->crit) DELN (yals->crit, yals->nclauses);
+  if (yals->weightedbreak) DELN (yals->weightedbreak, 2*yals->nvars);
+  if (yals->xweightedbreak) DELN (yals->xweightedbreak, yals->nvars);
+  if (yals->satcntbytes == 1) DELN (yals->satcnt1, yals->nclauses);
+  else if (yals->satcntbytes == 2) DELN (yals->satcnt2, yals->nclauses);
+  else DELN (yals->satcnt4, yals->nclauses);
+  DELN(yals->xorsat, yals->nxclauses);
+  if (yals->weights) DELN (yals->weights, MAXLEN + 1);
+  DELN (yals->vals, yals->nvarwords);
+  DELN (yals->best, yals->nvarwords);
+  DELN (yals->tmp, yals->nvarwords);
+  DELN (yals->clear, yals->nvarwords);
+  DELN (yals->set, yals->nvarwords);
+  DELN (yals->occs, yals->noccs);
+  if (yals->refs) DELN (yals->refs, 3*yals->nvars);
+  if (yals->flips) DELN (yals->flips, yals->nvars);
+#ifndef NYALSTATS
+  DELN (yals->stats.inc, yals->stats.nincdec);
+  DELN (yals->stats.dec, yals->stats.nincdec);
+#endif
+  yals_strdel (yals, yals->opts.prefix);
+  yals_dec_allocated (yals, sizeof *yals);
+  assert (getenv ("YALSLEAK") || !yals->stats.allocated.current);
+  yals->mem.free (yals->mem.mgr, yals, sizeof *yals);
+}
+
+void yals_setprefix (Yals * yals, const char * prefix) {
+  yals_strdel (yals, yals->opts.prefix);
+  yals->opts.prefix = yals_strdup (yals, prefix ? prefix : "");
+}
+
+void yals_setout (Yals * yals, FILE * out) {
+  yals->out = out;
+}
+
+void yals_setphase (Yals * yals, int lit) {
+  if (!lit) yals_abort (yals, "zero literal argument to 'yals_val'");
+  PUSH (yals->phases, lit);
+}
+
+void yals_setflipslimit (Yals * yals, long long flips) {
+  yals->limits.flips = flips;
+  yals_msg (yals, 1, "new flips limit %lld", (long long) flips);
+}
+
+void yals_setmemslimit (Yals * yals, long long mems) {
+#ifndef NYALSMEMS
+  yals->limits.mems = mems;
+  yals_msg (yals, 1, "new mems limit %lld", (long long) mems);
+#else
+  yals_warn (yals,
+    "can not set mems limit to %lld "
+    "(compiled without 'mems' support)",
+    (long long) mems);
+#endif
+}
+
+/*------------------------------------------------------------------------*/
+
+void yals_setime (Yals * yals, double (*time)(void)) {
+  yals->cbs.time = time;
+}
+
+void yals_seterm (Yals * yals, int (*term)(void *), void * state) {
+  yals->cbs.term.state = state;
+  yals->cbs.term.fun = term;
+}
+
+void yals_setmsglock (Yals * yals,
+                      void (*lock)(void *),
+                      void (*unlock)(void *),
+                      void * state) {
+  yals->cbs.msg.state = state;
+  yals->cbs.msg.lock = lock;
+  yals->cbs.msg.unlock = unlock;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_new_clause (Yals * yals) {
+  int len = COUNT (yals->clause), * p, lit;
+  if (!len) {
+    LOG ("found empty clause in original formula");
+    yals->mt = 1;
+  }
+  if (len == 1) {
+    // NOTE(WN): unit XOR clauses are the same as OR unit clauses
+    lit = PEEK (yals->clause, 0);
+    LOG ("found unit clause %d in original formula", lit);
+    PUSH (yals->trail, lit);
+    return; // We don't add unit clauses
+  }
+
+  if (yals->isXor) {
+    for (p = yals->clause.start; p < yals->clause.top; p++) {
+      lit = *p;
+      int idx = ABS (lit);
+      PUSH (yals->xcdb, idx);
+    }
+    PUSH(yals->xcdb, 0);
+    PUSH(yals->xparitydb, yals->xorParity);
+    LOGLITS (yals->xcdb.top - len - 1, "new (length %d, parity %d) XOR", len, yals->xorParity);
+  } else {
+    for (p = yals->clause.start; p < yals->clause.top; p++) {
+      lit = *p;
+      PUSH (yals->cdb, lit);
+    }
+    PUSH (yals->cdb, 0);
+    LOGLITS (yals->cdb.top - len - 1, "new (length %d) OR", len);
+  }
+}
+
+static signed char yals_sign (int lit) { return (lit < 0) ? -1 : 1; }
+
+void yals_begin_xor_clause (Yals * yals) {
+  if (COUNT(yals->clause) != 0 || yals->isXor)
+    yals_abort(yals, "New XOR clause began without ending previous clause");
+  yals->isXor = 1;
+  yals->xorParity = 0;
+}
+
+void yals_add (Yals * yals, int lit) {
+  if (lit) { // Add literal to current clause
+    if (yals->isXor) {
+      int idx;
+      if (lit == INT_MIN)
+        yals_abort (yals, "can not add 'INT_MIN' as literal");
+      idx = ABS (lit);
+      if (idx == INT_MAX)
+        yals_abort (yals, "can not add 'INT_MAX' as literal");
+      if (idx >= yals->nvars) yals->nvars = idx + 1;
+      PUSH(yals->clause, lit);
+      if (lit < 0) yals->xorParity ^= 1;
+      // TODO(WN): triviality conditions?
+      return;
+    }
+
+    signed char mark;
+    int idx;
+    if (lit == INT_MIN)
+      yals_abort (yals, "can not add 'INT_MIN' as literal");
+    idx = ABS (lit);
+    if (idx == INT_MAX)
+      yals_abort (yals, "can not add 'INT_MAX' as literal");
+    if (idx >= yals->nvars) yals->nvars = idx + 1;
+    while (idx >= COUNT (yals->mark)) PUSH (yals->mark, 0);
+    mark = PEEK (yals->mark, idx);
+    if (lit < 0) mark = -mark;
+    if (mark < 0) yals->trivial = 1;
+    else if (!mark) {
+      PUSH (yals->clause, lit);
+      POKE (yals->mark, idx, yals_sign (lit));
+    }
+
+  } else { // DIMACS 0, start new clause
+    if (!yals->isXor) {
+      const int * p;
+      for (p = yals->clause.start; p < yals->clause.top; p++)
+        POKE (yals->mark, ABS (*p), 0);
+      if (yals->trivial) yals->trivial = 0;
+      else yals_new_clause (yals);
+    } else {
+      // NOTE(LL): yals->mark may be empty for XOR clauses
+      yals_new_clause (yals);
+    }
+    CLEAR (yals->clause);
+    yals->isXor = 0;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+#define ISDEFSTRAT(NAME,ENABLED) \
+do { \
+  if (!(ENABLED)) { \
+    assert (yals->strat.NAME == yals->opts.NAME.val); \
+    break; \
+  } \
+  if (yals->strat.NAME != yals->opts.NAME.val) return 0; \
+} while (0)
+#undef STRAT
+#define STRAT ISDEFSTRAT
+
+static int yals_is_default_strategy (Yals * yals) {
+  STRATSTEMPLATE
+  return 1;
+}
+
+#define PRINTSTRAT(NAME,ENABLED) \
+do { \
+  if (!(ENABLED)) break; \
+  fprintf (yals->out, " --%s=%d", #NAME, yals->strat.NAME); \
+} while (0)
+#undef STRAT
+#define STRAT PRINTSTRAT
+
+static void yals_print_strategy (Yals * yals, const char * type, int vl) {
+  if (yals->opts.verbose.val < vl) return;
+  yals_msglock (yals);
+  fprintf (yals->out, "%s%s", yals->opts.prefix, type);
+  STRATSTEMPLATE
+  if (yals_is_default_strategy (yals)) fprintf (yals->out, " (default)");
+  else fprintf (yals->out, " (random)");
+  fprintf (yals->out, "\n");
+  yals_msgunlock (yals);
+}
+
+/*------------------------------------------------------------------------*/
+
+#define DEFSTRAT(NAME,ENABLED) \
+do { \
+  yals->strat.NAME = yals->opts.NAME.val; \
+} while (0)
+#undef STRAT
+#define STRAT DEFSTRAT
+
+static void yals_set_default_strategy (Yals * yals) {
+  STRATSTEMPLATE
+  yals->stats.strat.def++;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int yals_rand_opt (Yals * yals, Opt * opt, const char * name) {
+  unsigned mod, r;
+  int res;
+  mod = opt->max;
+  mod -= opt->min;
+  mod++;
+  if (mod) {
+    r = yals_rand_mod (yals, mod);
+    res = (int)(r + (unsigned) opt->min);
+  } else {
+    assert (opt->min == INT_MIN);
+    assert (opt->max == INT_MAX);
+    res = (int) yals_rand (yals);
+  }
+  assert (opt->min <= res), assert (res <= opt->max);
+  (void) name;
+  LOG ("randomly picking strategy %s=%d from [%d,%d] default %d",
+    name, res, opt->min, opt->max, opt->val);
+  return res;
+}
+
+#define RANDSTRAT(NAME,ENABLED) \
+do { \
+  if ((ENABLED)) { \
+    yals->strat.NAME = \
+      yals_rand_opt (yals, &yals->opts.NAME, #NAME); \
+  } else yals->strat.NAME = yals->opts.NAME.val; \
+} while (0)
+#undef STRAT
+#define STRAT RANDSTRAT
+
+static void yals_set_random_strategy (Yals * yals) {
+  STRATSTEMPLATE
+  assert (yals->stats.restart.inner.count > 1);
+  yals->stats.strat.rnd++;
+  if (yals->strat.cached)
+    yals->strat.pol = yals->opts.pol.val;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_pick_strategy (Yals * yals) {
+  assert (yals->stats.restart.inner.count > 0);
+  if (yals->stats.restart.inner.count == 1 ||
+      !yals_rand_mod (yals, yals->opts.fixed.val))
+    yals_set_default_strategy (yals);
+  else yals_set_random_strategy (yals);
+  yals_print_strategy (yals, "picked strategy:", 2);
+}
+
+static void yals_fix_strategy (Yals * yals) {
+  if (yals->uniform) {
+    yals->strat.correct = 1;
+    yals->strat.pol = 0;
+    yals->strat.uni = 1;
+    yals->strat.weight = 1;
+    yals_print_strategy (yals, "fixed strategy:", 2);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+static int yals_inner_restart_interval (Yals * yals) {
+  int res = yals->opts.restart.val;
+  if (res < yals->nvars/2) res = yals->nvars/2;
+  return res;
+  //return yals->nvars;
+}
+
+static int64_t yals_outer_restart_interval (Yals * yals) {
+  int64_t res = yals_inner_restart_interval (yals);
+  res *= yals->opts.restartouterfactor.val;
+  assert (res >= 0);
+  return res;
+}
+
+static int yals_inc_inner_restart_interval (Yals * yals) {
+  int64_t interval;
+  int res;
+
+  if (yals->opts.restart.val > 0) {
+    if (yals->opts.reluctant.val) {
+      if (!yals->limits.restart.inner.rds.u)
+        yals->limits.restart.inner.rds.u =
+          yals->limits.restart.inner.rds.v = 1;
+      interval = yals->limits.restart.inner.rds.v;
+      interval *= yals_inner_restart_interval (yals);
+      yals_rds (&yals->limits.restart.inner.rds);
+    } else {
+      if (!yals->limits.restart.inner.interval)
+        yals->limits.restart.inner.interval =
+          yals_inner_restart_interval (yals);
+      interval = yals->limits.restart.inner.interval;
+      if (yals->limits.restart.inner.interval <= YALS_INT64_MAX/2)
+        yals->limits.restart.inner.interval *= 2;
+      else yals->limits.restart.inner.interval = YALS_INT64_MAX;
+    }
+  } else interval = YALS_INT64_MAX;
+
+  yals_msg (yals, 2, "next restart interval %lld", interval);
+
+  if (YALS_INT64_MAX - yals->stats.flips >= interval)
+    yals->limits.restart.inner.lim = yals->stats.flips + interval;
+  else
+    yals->limits.restart.inner.lim = YALS_INT64_MAX;
+
+  yals_msg (yals, 2,
+    "next restart at %lld",
+    yals->limits.restart.inner.lim);
+
+  res = (yals->stats.restart.inner.maxint < interval);
+  if (res) {
+    yals->stats.restart.inner.maxint = interval;
+    yals_msg (yals, 2, "new maximal restart interval %lld", interval);
+  }
+
+  return res;
+}
+
+static int yals_need_to_restart_inner (Yals * yals) {
+  if (yals->uniform &&
+      yals->stats.restart.inner.count >= yals->opts.unirestarts.val)
+    return 0;
+  return yals->stats.flips >= yals->limits.restart.inner.lim;
+}
+
+static int yals_need_to_restart_outer (Yals * yals) {
+  return yals->stats.flips >= yals->limits.restart.outer.lim;
+}
+
+static void yals_restart_inner (Yals * yals) {
+  double start;
+  assert (yals_need_to_restart_inner (yals));
+  start = yals_time (yals);
+  yals->stats.restart.inner.count++;
+  if ((yals_inc_inner_restart_interval (yals) && yals->opts.verbose.val) ||
+      yals->opts.verbose.val >= 2)
+    yals_report (yals, "restart %lld", yals->stats.restart.inner.count);
+  if (yals->stats.best < yals->stats.last) {
+    yals->stats.pick.keep++;
+    yals_msg (yals, 2,
+      "keeping strategy and assignment thus essentially skipping restart");
+  } else {
+    yals_cache_assignment (yals);
+    yals_pick_strategy (yals);
+    yals_fix_strategy (yals);
+    yals_pick_assignment (yals, 0);
+    yals_update_sat_and_unsat (yals);
+    yals->stats.tmp = INT_MAX;
+    yals_save_new_minimum (yals);
+  }
+  yals->stats.last = yals->stats.best;
+  yals->stats.time.restart += yals_time (yals) - start;
+}
+
+/*------------------------------------------------------------------------*/
+
+static int yals_done (Yals * yals) {
+  assert (!yals->mt);
+  if (!yals_nunsat (yals)) return 1;
+  if (yals->limits.flips >= 0 &&
+      yals->limits.flips <= yals->stats.flips) {
+    yals_msg (yals, 1,
+      "flips limit %lld after %lld flips reached",
+      yals->limits.flips, yals->stats.flips);
+    return -1;
+  }
+#ifndef NYALSMEMS
+  if (yals->limits.mems >= 0 &&
+      yals->limits.mems <= yals->stats.mems.all) {
+    yals_msg (yals, 1,
+      "mems limit %lld after %lld mems reached",
+      yals->limits.mems, yals->stats.mems.all);
+    return -1;
+  }
+#endif
+  if (yals->cbs.term.fun && yals->limits.term-- <= 0) {
+    yals->limits.term = yals->opts.termint.val;
+    if (yals->cbs.term.fun (yals->cbs.term.state)) {
+      yals_msg (yals, 1, "forced to terminate");
+      return -1;
+    }
+  }
+  if (yals->opts.hitlim.val >= 0 &&
+      yals->stats.hits  >= yals->opts.hitlim.val) {
+    yals_msg (yals, 1,
+      "minimum hits limit %lld reached after %lld hits",
+      yals->opts.hitlim.val, yals->stats.hits);
+    return -1;
+  }
+  return 0;
+}
+
+static void yals_init_inner_restart_interval (Yals * yals) {
+  memset (&yals->limits.restart.inner, 0, sizeof yals->limits.restart.inner);
+  yals->limits.restart.inner.lim = yals->stats.flips;
+  yals->stats.restart.inner.maxint = 0;
+}
+
+static int yals_inner_loop (Yals * yals) {
+  int res = 0;
+  yals_init_inner_restart_interval (yals);
+  LOG ("entering yals inner loop");
+  while (!(res = yals_done (yals)) && !yals_need_to_restart_outer (yals))
+    if (yals_need_to_restart_inner (yals)) yals_restart_inner (yals);
+    else yals_flip (yals);
+  return res;
+}
+
+static void yals_init_outer_restart_interval (Yals * yals) {
+  if (yals->opts.restartouter.val) {
+    yals->limits.restart.outer.interval = yals_outer_restart_interval (yals);
+    yals->limits.restart.outer.lim =
+      yals->stats.flips + yals->limits.restart.outer.interval;
+    yals_msg (yals, 1,
+      "initial outer restart limit at %lld flips",
+      yals->limits.restart.outer.lim);
+  } else {
+    yals_msg (yals, 1, "outer restarts disabled");
+    yals->limits.restart.outer.lim = YALS_INT64_MAX;
+  }
+}
+
+static void yals_restart_outer (Yals * yals) {
+  double start = yals_time (yals);
+  unsigned long long seed;
+  int64_t interval;
+  yals->stats.restart.outer.count++;
+  seed = yals_rand (yals);
+  seed |= ((unsigned long long) yals_rand (yals)) << 32;
+  yals_srand (yals, seed);
+  interval = yals->limits.restart.outer.interval;
+  if (yals->limits.restart.outer.interval <= YALS_INT64_MAX/2)
+    yals->limits.restart.outer.interval *= 2;
+  else yals->limits.restart.outer.interval = YALS_INT64_MAX;
+  if (YALS_INT64_MAX - yals->stats.flips >= interval)
+    yals->limits.restart.outer.lim = yals->stats.flips + interval;
+  else
+    yals->limits.restart.outer.lim = YALS_INT64_MAX;
+  yals_msg (yals, 1,
+    "starting next outer restart round %lld after %.2f seconds",
+    (long long) yals->stats.restart.outer.count, yals_sec (yals));
+  yals_msg (yals, 1, "current seed %llu", seed);
+  yals_msg (yals, 1,
+    "next outer restart limit %lld",
+    (long long) yals->limits.restart.outer.lim);
+  yals_reset_cache (yals);
+  yals->stats.time.restart += yals_time (yals) - start;
+}
+
+static void yals_outer_loop (Yals * yals) {
+  yals_init_outer_restart_interval (yals);
+  for (;;) {
+    yals_set_default_strategy (yals);
+    yals_fix_strategy (yals);
+    yals_pick_assignment (yals, 1);
+    yals_update_sat_and_unsat (yals);
+    yals->stats.tmp = INT_MAX;
+    yals_save_new_minimum (yals);
+    yals->stats.last = yals_nunsat (yals);
+    if (yals_inner_loop (yals)) return;
+    yals_restart_outer (yals);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_check_assignment (Yals * yals) {
+  const int * c = yals->cdb.start;
+  while (c < yals->cdb.top) {
+    int satisfied = 0, lit;
+    while ((lit = *c++))
+      satisfied += yals_best (yals, lit);
+    if (!satisfied)
+      yals_abort (yals,
+        "internal error in 'yals_sat' (invalid satisfying assignment)");
+  }
+}
+
+static int yals_lkhd_internal (Yals * yals) {
+  int64_t maxflips;
+  int res = 0, idx;
+  if (!yals->flips) goto DONE;
+  maxflips = -1;
+  for (idx = 1; idx < yals->nvars; idx++) {
+    int64_t tmpflips = yals->flips[idx];
+    if (tmpflips <= maxflips) continue;
+    res = idx, maxflips = tmpflips;
+  }
+  if (res &&
+      yals->best &&
+      !GETBIT (yals->best, yals->nvarwords, res))
+    res = -res;
+DONE:
+  return res;
+}
+
+int yals_sat (Yals * yals) {
+  int res, limited = 0, lkhd;
+
+  if (yals->opts.maxorigvar.val != 0) {
+    assert(yals->opts.maxorigvar.val < yals->nvars);
+  }
+
+  if (!EMPTY (yals->clause))
+    yals_abort (yals, "added clause incomplete in 'yals_sat'");
+
+  if (yals->mt) {
+    yals_msg (yals, 1, "original formula contains empty clause");
+    return 20;
+  }
+
+  if (yals->opts.prep.val && !EMPTY (yals->trail)) {
+    yals_preprocess (yals);
+    if (yals->mt) {
+      yals_msg (yals, 1,
+        "formula after unit propagation contains empty clause");
+      return 20;
+    }
+  }
+
+  yals->stats.time.entered = yals_time (yals);
+
+  if (yals->opts.setfpu.val) yals_set_fpu (yals);
+  yals_connect (yals);
+
+  res = 0;
+  limited += (yals->limits.flips >= 0);
+#ifndef NYALSMEMS
+  limited += (yals->limits.mems >= 0);
+#endif
+  if (!limited)
+    yals_msg (yals, 1, "starting unlimited search");
+  else {
+
+    if (yals->limits.flips < 0)
+      yals_msg (yals, 1,
+        "search not limited by the number of flips");
+    else
+      yals_msg (yals, 1,
+        "search limited by %lld flips",
+         (long long) yals->limits.flips);
+
+#ifndef NYALSMEMS
+    if (yals->limits.mems < 0)
+      yals_msg (yals, 1,
+        "search not limited by the number of mems");
+    else
+      yals_msg (yals, 1,
+        "search limited by %lld mems",
+         (long long) yals->limits.mems);
+#endif
+  }
+
+  yals_outer_loop (yals);
+
+  assert (!yals->mt);
+  if (!yals->stats.best) {
+    yals_print_strategy (yals, "winning strategy:", 1);
+    yals_check_assignment (yals);
+    res = 10;
+  } else assert (!res);
+
+  if ((lkhd = yals_lkhd_internal (yals)))
+    yals_msg (yals, 1,
+      "most flipped literal %d flipped %lld times",
+      lkhd, (long long) yals->flips[ABS (lkhd)]);
+
+  if (yals->opts.setfpu.val) yals_reset_fpu (yals);
+  yals_flush_time (yals);
+
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+int yals_deref (Yals * yals, int lit) {
+  if (!lit) yals_abort (yals, "zero literal argument to 'yals_val'");
+  if (yals->mt || ABS (lit) >= yals->nvars) return lit < 0 ? 1 : -1;
+  return yals_best (yals, lit) ? 1 : -1;
+}
+
+int yals_minimum (Yals * yals) { return yals->stats.best; }
+
+long long yals_flips (Yals * yals) { return yals->stats.flips; }
+
+long long yals_mems (Yals * yals) {
+#ifndef NYALSMEMS
+  return yals->stats.mems.all;
+#else
+  return 0;
+#endif
+}
+
+int yals_lkhd (Yals * yals) {
+  int res = yals_lkhd_internal (yals);
+  if (res)
+    yals_msg (yals, 1,
+      "look ahead literal %d flipped %lld times",
+      res, (long long) yals->flips [ABS (res)]);
+  else
+    yals_msg (yals, 2, "no look ahead literal found");
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+static void yals_minlits_cidx (Yals * yals, int cidx) {
+  const int * lits, * p;
+  int lit;
+  assert_valid_cidx (cidx);
+  lits = yals_lits (yals, cidx);
+  for (p = lits; (lit = *p); p++)
+    if (yals_best (yals, lit))
+      return;
+  for (p = lits; (lit = *p); p++) {
+    int idx = ABS (lit);
+    assert (idx < yals->nvars);
+    if (yals->mark.start[idx]) continue;
+    yals->mark.start[idx] = 1;
+    PUSH (yals->minlits, lit);
+  }
+}
+
+const int * yals_minlits (Yals * yals) {
+  int count, cidx;
+  RELEASE (yals->mark);
+  while (COUNT (yals->mark) < yals->nvars)
+    PUSH (yals->mark, 0);
+  FIT (yals->mark);
+  CLEAR (yals->minlits);
+  for (cidx = 0; cidx < yals->nclauses; cidx++)
+    yals_minlits_cidx (yals, cidx);
+  count = COUNT (yals->minlits);
+  yals_msg (yals, 1,
+    "found %d literals in unsat clauses %.0f%%",
+    count, yals_pct (count, yals->nvars));
+  PUSH (yals->minlits, 0);
+  RELEASE (yals->mark);
+  FIT (yals->minlits);
+  return yals->minlits.start;
+}
+
+/*------------------------------------------------------------------------*/
+
+void yals_stats (Yals * yals) {
+  Stats * s = &yals->stats;
+  double t = s->time.total;
+  int64_t sum;
+  yals_msg (yals, 0,
+    "restart time %.3f seconds %.0f%%",
+    s->time.restart, yals_pct (s->time.restart, s->time.total));
+  yals_msg (yals, 0,
+    "%lld inner restarts, %lld maximum interval",
+    (long long) s->restart.inner.count,
+    (long long) s->restart.inner.maxint);
+  yals_msg (yals, 0,
+    "%lld outer restarts, %lld maximum interval",
+    (long long) s->restart.outer.count,
+    (long long) yals->limits.restart.outer.interval);
+  sum = s->strat.def + s->strat.rnd;
+  yals_msg (yals, 0,
+    "default strategy %lld %.0f%%, random strategy %lld %.0f%%",
+    (long long) s->strat.def, yals_pct (s->strat.def, sum),
+    (long long) s->strat.rnd, yals_pct (s->strat.rnd, sum));
+  yals_msg (yals, 0,
+    "picked best=%lld cached=%lld keep=%lld pos=%lld neg=%lld rnd=%lld",
+    (long long) s->pick.best, (long long) s->pick.cached,
+    (long long) s->pick.keep, (long long) s->pick.pos,
+    (long long) s->pick.neg, (long long) s->pick.rnd);
+  sum = s->cache.inserted + s->cache.replaced;
+  yals_msg (yals, 0,
+    "cached %lld assignments, %lld replaced %.0f%%, %lld skipped, %d size",
+    (long long) sum,
+    (long long) s->cache.replaced, yals_pct (s->cache.replaced, sum),
+    (long long) s->cache.skipped, (int) COUNT (yals->cache));
+  sum = s->sig.falsepos + s->sig.truepos;
+  yals_msg (yals, 0,
+    "%lld sigchecks, %lld negative %.0f%%, "
+    "%lld positive %.0f%%, %lld false %.0f%%",
+    (long long) s->sig.search,
+    (long long) s->sig.neg, yals_pct (s->sig.neg, s->sig.search),
+    (long long) sum, yals_pct (sum, s->sig.search),
+    (long long) s->sig.falsepos, yals_pct (s->sig.falsepos, s->sig.search));
+  if (yals->unsat.usequeue) {
+    yals_msg (yals, 0,
+      "allocated max %d chunks %d links %lld unfair",
+      s->queue.max.chunks, s->queue.max.lnks, (long long) s->queue.unfair);
+    yals_msg (yals, 0,
+      "%lld defragmentations in %.3f seconds %.0f%%",
+      (long long) s->defrag.count,
+      s->time.defrag, yals_pct (s->time.defrag, s->time.total));
+    yals_msg (yals, 0,
+      "moved %lld in total and %.1f on average per defragmentation",
+      (long long) s->defrag.moved,
+      yals_avg (s->defrag.moved, s->defrag.count));
+  } else
+    yals_msg (yals, 0, "maximum unsat stack size %d", s->maxstacksize);
+
+#ifndef NYALSTATS
+  yals_msg (yals, 0,
+    "%lld broken, %.2f broken/flip, %lld made, %.2f made/flip",
+    (long long) s->broken, yals_avg (s->broken, s->flips),
+    (long long) s->made, yals_avg (s->made, s->flips));
+
+  yals_msg (yals, 0,
+    "%u maximum %u minimum sum of weighted breaks",
+    s->wb.max, s->wb.min);
+#endif
+
+  yals_msg (yals, 0,
+    "%.3f unsat clauses on average",
+    yals_pct (s->unsum, s->flips));
+
+#ifndef NYALSTATS
+  if (s->inc && s->dec) {
+    double suminc, sumdec, f = s->flips;
+    int64_t ninc, ndec, ninclarge, ndeclarge;
+    int len;
+    assert (!s->dec[0]);
+    assert (!s->inc[yals->maxlen]);
+    suminc = sumdec = ninc = ndec = ndeclarge = ninclarge = 0;
+    for (len = 0; len <= yals->maxlen; len++) {
+      int64_t inc = s->inc[len];
+      int64_t dec = s->dec[len];
+      ninc += inc, ndec += dec;
+      suminc += len * inc, sumdec += len * dec;
+      if (len > 2) ninclarge += inc;
+      if (len > 3) ndeclarge += dec;
+    }
+    yals_msg (yals, 0,
+      "%lld incs %.3f avg satcnt, %lld decs %.3f avg satcnt",
+      (long long) ninc, yals_avg (suminc, ninc),
+      (long long) ndec, yals_avg (sumdec, ndec));
+    yals_msg (yals, 0,
+      "inc0 %.2f %.2f%%, inc1 %.2f %.2f%%, "
+      "inc2 %.2f %.2f%%, incl %.2f %.2f%%",
+      yals_avg (s->inc[0], f), yals_pct (s->inc[0], ninc),
+      yals_avg (s->inc[1], f), yals_pct (s->inc[1], ninc),
+      yals_avg (s->inc[2], f), yals_pct (s->inc[2], ninc),
+      yals_avg (ninclarge, f), yals_pct (ninclarge, ninc));
+    yals_msg (yals, 0,
+      "dec1 %.2f %.2f%%, dec2 %.2f %.2f%%, "
+      "dec3 %.2f %.2f%%, decl %.2f %.2f%%",
+      yals_avg ( s->dec[1], f), yals_pct (s->dec[1], ndec),
+      yals_avg (s->dec[2], f), yals_pct (s->dec[2], ndec),
+      yals_avg (s->dec[3], f), yals_pct (s->dec[3], ndec),
+      yals_avg (ndeclarge, f), yals_pct (ndeclarge, ndec));
+  }
+#endif
+
+#ifndef NYALSMEMS
+  {
+    double M = 1000000.0;
+    long long all = 0;
+
+    all += s->mems.lits;
+    all += s->mems.crit;
+    all += s->mems.occs;
+    all += s->mems.read;
+    all += s->mems.update;
+    all += s->mems.weight;
+
+    assert (all == s->mems.all);
+
+    yals_msg (yals, 0,
+      "megamems: %.0f all 100%, %.0f lits %.0f%%, %.0f crit %.0f%%, "
+      "%.0f weight %.0f%%",
+      all/M,
+      s->mems.lits/M, yals_pct (s->mems.lits, all),
+      s->mems.crit/M, yals_pct (s->mems.crit, all),
+      s->mems.weight/M, yals_pct (s->mems.weight, all));
+
+    yals_msg (yals, 0,
+      "megamems: %.0f occs %.0f%%, %.0f read %.0f%%, %.0f update %.0f%%",
+      s->mems.occs/M, yals_pct (s->mems.occs, all),
+      s->mems.read/M, yals_pct (s->mems.read, all),
+      s->mems.update/M, yals_pct (s->mems.update, all));
+
+    yals_msg (yals, 0,
+      "%.1f million mems per second, %.1f mems per flip",
+      yals_avg (all/1e6, t), yals_avg (all, s->flips));
+  }
+#endif
+
+  yals_msg (yals, 0,
+    "%.1f seconds searching, %.1f MB maximally allocated (%lld bytes)",
+    t, s->allocated.max/(double)(1<<20), (long long) s->allocated.max);
+
+  yals_msg (yals, 0,
+    "%lld flips, %.1f thousand flips per second, %lld break zero %.1f%%",
+    (long long) s->flips, yals_avg (s->flips/1e3, t),
+    s->bzflips, yals_pct (s->bzflips, s->flips));
+
+  if (yals->opts.maxorigvar.val != 0) {
+    int64_t origFlips = 0;
+    int64_t auxFlips = 0;
+
+    int idx;
+    for (idx = 1; idx <= yals->opts.maxorigvar.val && idx < yals->nvars; idx++) {
+      origFlips += yals->flips[idx];
+    }
+    for (idx = yals->opts.maxorigvar.val + 1; idx < yals->nvars; idx++) {
+      auxFlips += yals->flips[idx];
+    }
+
+    yals_msg (yals, 0,
+      "%lld original var flips, %lld aux var flips",
+      origFlips, auxFlips);
+  }
+
+  yals_msg (yals, 0,
+    "minimum %d hit %lld times, maximum %d",
+    s->best, (long long) s->hits, s->worst);
+}
diff --git a/yals.h b/yals.h
new file mode 100644
index 0000000..2200ea2
--- /dev/null
+++ b/yals.h
@@ -0,0 +1,78 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2021 xnfSAT Authors                                           */
+/*-------------------------------------------------------------------------*/
+
+#ifndef LIBYALS_H_INCLUDED
+#define LIBYALS_H_INCLUDED
+
+/*------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/*------------------------------------------------------------------------*/
+
+typedef struct Yals Yals;
+
+/*------------------------------------------------------------------------*/
+
+Yals * yals_new ();
+void yals_del (Yals *);
+
+/*------------------------------------------------------------------------*/
+
+typedef void * (*YalsMalloc)(void*,size_t);
+typedef void * (*YalsRealloc)(void*,void*,size_t,size_t);
+typedef void (*YalsFree)(void*,void*,size_t);
+
+Yals * yals_new_with_mem_mgr (void*, YalsMalloc, YalsRealloc, YalsFree);
+
+/*------------------------------------------------------------------------*/
+
+void yals_srand (Yals *, unsigned long long seed);
+int yals_setopt (Yals *, const char * name, int val);
+void yals_setprefix (Yals *, const char *);
+void yals_setout (Yals *, FILE *);
+void yals_setphase (Yals *, int lit);
+void yals_setflipslimit (Yals *, long long);
+void yals_setmemslimit (Yals *, long long);
+
+int yals_getopt (Yals *, const char * name);
+void yals_usage (Yals *);
+void yals_showopts (Yals *);
+
+/*------------------------------------------------------------------------*/
+
+void yals_begin_xor_clause(Yals *);
+
+void yals_add (Yals *, int lit);
+
+int yals_sat (Yals *);
+
+/*------------------------------------------------------------------------*/
+
+long long yals_flips (Yals *);
+long long yals_mems (Yals *);
+
+int yals_minimum (Yals *);
+int yals_lkhd (Yals *);
+int yals_deref (Yals *, int lit);
+
+const int * yals_minlits (Yals *);
+
+/*------------------------------------------------------------------------*/
+
+void yals_stats (Yals *);
+
+/*------------------------------------------------------------------------*/
+
+void yals_seterm (Yals *, int (*term)(void*), void*);
+
+void yals_setime (Yals *, double (*time)(void));
+
+void yals_setmsglock (Yals *,
+       void (*lock)(void*), void (*unlock)(void*), void*);
+
+/*------------------------------------------------------------------------*/
+
+#endif
diff --git a/yils.h b/yils.h
new file mode 100644
index 0000000..0d7d121
--- /dev/null
+++ b/yils.h
@@ -0,0 +1,54 @@
+/*-------------------------------------------------------------------------*/
+/* Copyright 2021 xnfSAT Authors                                           */
+/*-------------------------------------------------------------------------*/
+
+#ifndef YILS_H_INCLUDED
+#define YILS_H_INCLUDED
+
+#ifndef YALSINTERNAL
+#error "this file is internal to 'libyals'"
+#endif
+
+/*------------------------------------------------------------------------*/
+
+#include "yals.h"
+
+/*------------------------------------------------------------------------*/
+
+#include <stdlib.h>
+
+/*------------------------------------------------------------------------*/
+
+#ifndef NDEBUG
+void yals_logging (Yals *, int logging);
+void yals_checking (Yals *, int checking);
+#endif
+
+/*------------------------------------------------------------------------*/
+
+void yals_abort (Yals *, const char * fmt, ...);
+void yals_exit (Yals *, int exit_code, const char * fmt, ...);
+void yals_msg (Yals *, int level, const char * fmt, ...);
+
+const char * yals_default_prefix (void);
+const char * yals_version ();
+void yals_banner (const char * prefix);
+
+/*------------------------------------------------------------------------*/
+
+double yals_process_time ();				// process time
+
+double yals_sec (Yals *);				// time in 'yals_sat'
+size_t yals_max_allocated (Yals *);		// max allocated bytes
+
+/*------------------------------------------------------------------------*/
+
+void * yals_malloc (Yals *, size_t);
+void yals_free (Yals *, void*, size_t);
+void * yals_realloc (Yals *, void*, size_t, size_t);
+
+/*------------------------------------------------------------------------*/
+
+void yals_srand (Yals *, unsigned long long);
+  
+#endif