  , R(s.R)
  , sizeLBDQueue(s.sizeLBDQueue)
  , sizeTrailQueue(s.sizeTrailQueue)
-@@ -771,7 +767,7 @@
-                     // seems to be interesting : keep it for the next round
-                     c.setCanBeDel(false);
+@@ -743,84 +739,89 @@
+     int index = trail.size() - 1;
+     do {
+         assert(confl != CRef_Undef); // (otherwise should be UIP)
+-        Clause &c = ca[confl];
+-        // Special case for binary clauses
+-        // The first one has to be SAT
+-        if(p != lit_Undef && c.size() == 2 && value(c[0]) == l_False) {
+-
+-            assert(value(c[1]) == l_True);
+-            Lit tmp = c[0];
+-            c[0] = c[1], c[1] = tmp;
+-        }
+-
+-        if(c.learnt()) {
+-            parallelImportClauseDuringConflictAnalysis(c, confl);
+-            claBumpActivity(c);
+-        } else { // original clause
+-            if(!c.getSeen()) {
+-                stats[originalClausesSeen]++;
+-                c.setSeen(true);
++        if(!moreConflict(out_learnt, selectors, pathC)) {
++            Clause &c = ca[confl];
++            // Special case for binary clauses
++            // The first one has to be SAT
++            if(p != lit_Undef && c.size() == 2 && value(c[0]) == l_False) {
++
++                assert(value(c[1]) == l_True);
++                Lit tmp = c[0];
++                c[0] = c[1], c[1] = tmp;
++            }
++
++            if(c.learnt()) {
++                parallelImportClauseDuringConflictAnalysis(c, confl);
++                claBumpActivity(c);
++            } else { // original clause
++                if(!c.getSeen()) {
++                    stats[originalClausesSeen]++;
++                    c.setSeen(true);
++                }
+             }
+-        }
+ 
+-        // DYNAMIC NBLEVEL trick (see competition'09 companion paper)
+-        if(c.learnt() && c.lbd() > 2) {
+-            unsigned int nblevels = computeLBD(c);
+-            if(nblevels + 1 < c.lbd()) { // improve the LBD
+-                if(c.lbd() <= lbLBDFrozenClause) {
+-                    // seems to be interesting : keep it for the next round
+-                    c.setCanBeDel(false);
+-                }
+-                if(chanseokStrategy && nblevels <= coLBDBound) {
+-                    c.nolearnt();
+-                    learnts.remove(confl);
+-                    permanentLearnts.push(confl);
+-                    stats[nbPermanentLearnts]++;
++            // DYNAMIC NBLEVEL trick (see competition'09 companion paper)
++            if(c.learnt() && c.lbd() > 2) {
++                unsigned int nblevels = computeLBD(c);
++                if(nblevels + 1 < c.lbd()) { // improve the LBD
++                    if(c.lbd() <= lbLBDFrozenClause) {
++                        // seems to be interesting : keep it for the next round
++                        c.setCanBeDel(false);
++                    }
++                    if(chanseokStrategy && nblevels <= static_cast<unsigned>(coLBDBound)) {
++                        c.nolearnt();
++                        learnts.remove(confl);
++                        permanentLearnts.push(confl);
++                        stats[nbPermanentLearnts]++;
+ 
+-                } else {
+-                    c.setLBD(nblevels); // Update it
++                    } else {
++                        c.setLBD(nblevels); // Update it
++                    }
                  }
--                if(chanseokStrategy && nblevels <= coLBDBound) {
-+                if(chanseokStrategy && nblevels <= static_cast<unsigned>(coLBDBound)) {
-                     c.nolearnt();
-                     learnts.remove(confl);
-                     permanentLearnts.push(confl);
-@@ -1413,7 +1409,7 @@
+             }
+-        }
+ 
+ 
+-        for(int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++) {
+-            Lit q = c[j];
++            for(int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++) {
++                Lit q = c[j];
+ 
+-            if(!seen[var(q)]) {
+-                if(level(var(q)) == 0) {
+-                } else { // Here, the old case
+-                    if(!isSelector(var(q)))
+-                        varBumpActivity(var(q));
+-
+-                    // This variable was responsible for a conflict,
+-                    // consider it as a UNSAT assignation for this literal
+-                    bumpForceUNSAT(~q); // Negation because q is false here
+-
+-                    seen[var(q)] = 1;
+-                    if(level(var(q)) >= decisionLevel()) {
+-                        pathC++;
+-                        // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+-                        if(!isSelector(var(q)) && (reason(var(q)) != CRef_Undef) && ca[reason(var(q))].learnt())
+-                            lastDecisionLevel.push(q);
+-                    } else {
+-                        if(isSelector(var(q))) {
+-                            assert(value(q) == l_False);
+-                            selectors.push(q);
+-                        } else
+-                            out_learnt.push(q);
++                if(!seen[var(q)]) {
++                    if(level(var(q)) == 0) {
++                    } else { // Here, the old case
++                        if(!isSelector(var(q)))
++                            varBumpActivity(var(q));
++
++                        // This variable was responsible for a conflict,
++                        // consider it as a UNSAT assignation for this literal
++                        bumpForceUNSAT(~q); // Negation because q is false here
++
++                        seen[var(q)] = 1;
++                        if(level(var(q)) >= decisionLevel()) {
++                            pathC++;
++                            // UPDATEVARACTIVITY trick (see competition'09 companion paper)
++                            if(!isSelector(var(q)) && (reason(var(q)) != CRef_Undef) && ca[reason(var(q))].learnt())
++                                lastDecisionLevel.push(q);
++                        } else {
++                            if(isSelector(var(q))) {
++                                assert(value(q) == l_False);
++                                selectors.push(q);
++                            } else
++                                out_learnt.push(q);
++                        }
+                     }
+-                }
+-            } //else stats[sumResSeen]++;
++                } //else stats[sumResSeen]++;
++            }
+         }
+ 
+-        // Select next clause to look at:
+-        while (!seen[var(trail[index--])]);
+-        p = trail[index + 1];
+-        //stats[sumRes]++;
+-        confl = reason(var(p));
+-        seen[var(p)] = 0;
+-        pathC--;
++        bool ret;
++        do {
++            // Select next clause to look at:
++            while (!seen[var(trail[index--])]);
++            p = trail[index + 1];
++            ret = moreReason(p, out_learnt, selectors, pathC);
++            confl = reason(var(p));
++            seen[var(p)] = 0;
++            pathC--;
++        }while(ret);
+ 
+     } while(pathC > 0);
+     out_learnt[0] = ~p;
+@@ -981,17 +982,19 @@
+     for(int i = trail.size() - 1; i >= trail_lim[0]; i--) {
+         Var x = var(trail[i]);
+         if(seen[x]) {
+-            if(reason(x) == CRef_Undef) {
+-                assert(level(x) > 0);
+-                out_conflict.push(~trail[i]);
+-            } else {
+-                Clause &c = ca[reason(x)];
+-                //                for (int j = 1; j < c.size(); j++) Minisat (glucose 2.0) loop
+-                // Bug in case of assumptions due to special data structures for Binary.
+-                // Many thanks to Sam Bayless (sbayless@cs.ubc.ca) for discover this bug.
+-                for(int j = ((c.size() == 2) ? 0 : 1); j < c.size(); j++)
+-                    if(level(var(c[j])) > 0)
+-                        seen[var(c[j])] = 1;
++            if(!moreReason(trail[i])) {
++                if(reason(x) == CRef_Undef) {
++                    assert(level(x) > 0);
++                    out_conflict.push(~trail[i]);
++                } else {
++                    Clause &c = ca[reason(x)];
++                    //                for (int j = 1; j < c.size(); j++) Minisat (glucose 2.0) loop
++                    // Bug in case of assumptions due to special data structures for Binary.
++                    // Many thanks to Sam Bayless (sbayless@cs.ubc.ca) for discover this bug.
++                    for(int j = ((c.size() == 2) ? 0 : 1); j < c.size(); j++)
++                        if(level(var(c[j])) > 0)
++                            seen[var(c[j])] = 1;
++                }
+             }
+ 
+             seen[x] = 0;
+@@ -1413,7 +1416,7 @@
          int i, j;
          for(i = j = 0; i < learnts.size(); i++) {
              Clause &c = ca[learnts[i]];

-        exit(0);
-    }
-}
diff -Naur glucose-syrup-4.1/parallel/Makefile glucose-syrup/parallel/Makefile
--- glucose-syrup-4.1/parallel/Makefile	2016-12-08 13:48:26.000000000 +0100
+++ glucose-syrup/parallel/Makefile	1970-01-01 01:00:00.000000000 +0100
@@ -1,4 +0,0 @@
-EXEC      = glucose-syrup
-DEPDIR    = mtl utils core simp
-MROOT = $(PWD)/..
-include $(MROOT)/mtl/template.mk
diff -Naur glucose-syrup-4.1/parallel/MultiSolvers.cc glucose-syrup/parallel/MultiSolvers.cc
--- glucose-syrup-4.1/parallel/MultiSolvers.cc	2016-12-08 13:48:26.000000000 +0100
+++ glucose-syrup/parallel/MultiSolvers.cc	1970-01-01 01:00:00.000000000 +0100
@@ -1,699 +0,0 @@
-/***************************************************************************************[MultiSolvers.cc]
- Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon

     // Handle case when solver is in contradictory state:
     if(!ok) {
         fprintf(f, "p cnf 1 2\n1 0\n-1 0\n");
@@ -1911,9 +1838,6 @@
 
     for(int i = 0; i < clauses.size(); i++)
         toDimacs(f, ca[clauses[i]], map, max);
