:tada:

Hybride/GSAT/ArrayFiller.cpp

@@ -0,0 +1,120 @@
+/*
+ * ArrayFiller.cpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The class for filling 1-D boolean array
+ */
+
+
+#include "ArrayFiller.hpp"
+
+ArrayFiller::ArrayFiller(bool* bArray,unsigned int arrSize):
+arrSize(arrSize),
+stepSize(DEFAULT_STEP_SIZE),
+currStep(DEFAULT_CURR_STEP),
+tRate(0),
+pArray(NULL)
+{
+
+	// -- Initialize boolean array if it has not been initialized
+
+	if (bArray==NULL)
+		this->bArray=new bool[arrSize];
+	else
+		this->bArray=bArray;
+
+	// -- Initializing sampling distribution --
+
+	this->rndReal=std::uniform_real_distribution<float>(0.0,1.0);
+
+	// -- Init random engine --
+
+	struct timespec ts;
+	unsigned theTick = 0U;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	theTick  = ts.tv_nsec / 1000000;
+	theTick += ts.tv_sec * 1000;
+	this->rndEngine.seed(theTick);
+}
+
+
+bool* ArrayFiller::getArray()
+{
+	return this->bArray;
+}
+
+void ArrayFiller::setPortionArray(float* pArray)
+{
+	this->pArray=pArray;
+}
+
+void ArrayFiller::setPortionRate(float rate)
+{
+	this->tRate=rate;
+}
+
+
+bool* ArrayFiller::fillArray(FillMethod method)
+{
+
+
+	switch (method)
+	{
+
+	case ZEROS_FILL:	// -- fills with zeros (false)
+		memset(this->bArray,0,this->arrSize*sizeof(bool));
+		break;
+
+	case ONES_FILL: // -- fills with ones (true)
+		memset(this->bArray,1,this->arrSize*sizeof(bool));
+		break;
+
+	case UNIFORM_FILL: // -- uniformly fills with zeros and ones
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd<UNIFORM_RATIO);
+		}
+		break;
+
+	case STEP_FILL:	// -- fills with step method
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->currStep);
+		}
+
+		this->currStep+=this->stepSize; // -- increase the step size ( probability of having true value)
+		if (this->currStep>1) this->currStep=0;
+		break;
+
+	case PORTION_FILL: // -- fills proportionally
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->tRate);
+		}
+		break;
+
+	case PORTION_EL_FILL: // -- fills each element proportionally
+
+		if (this->pArray==NULL)
+			break;
+
+
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->pArray[i]);
+		}
+		break;
+
+	}
+
+	return this->bArray;
+
+}
+
+
+

Hybride/GSAT/ArrayFiller.hpp

@@ -0,0 +1,61 @@
+/*
+ * ArrayFiller.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The class for filling 1-D boolean array
+ */
+
+#ifndef ARRAYFILLER_HPP_
+#define ARRAYFILLER_HPP_
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include "FillMethod.hpp"
+
+#define DEFAULT_STEP_SIZE	0.05
+#define DEFAULT_CURR_STEP	0.05
+
+using namespace std;
+
+class ArrayFiller
+{
+private :
+	bool *bArray ;					// -- pointer to the boolean array
+	unsigned int arrSize;			// -- array size
+	float stepSize;					// -- STEP_FILL, step size
+	float currStep;					// -- STEP_FILL, current step
+	float tRate;					// -- PORTION_FILL, true-rate
+	float* pArray;					// -- PORTION_EL_FILL array
+
+	std::uniform_real_distribution<float> rndReal;	// -- sampling from real uniform  distribution
+	std::default_random_engine rndEngine;			// -- sampling engine
+
+
+public:
+
+	// -- Vector Filler constructor
+	ArrayFiller(bool* bArray,unsigned int arrSize);
+
+	// -- property methods --
+	bool* getArray();
+
+	void setPortionArray(float* pArray);
+
+	void setPortionRate(float rate);
+
+	// -- Fill array randomly with the given method --
+	bool* fillArray(FillMethod method);
+
+};
+
+
+#endif /* ARRAYFILLER_HPP_ */

Hybride/GSAT/CFormula.cpp

@@ -0,0 +1,675 @@
+/*
+ * CFormula.cpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ */
+
+#include "CFormula.hpp"
+
+CFormula::CFormula():
+nVars(0),
+nClauses(0),
+fStats{0,0,0},
+fVars(NULL),
+fPortions(NULL),
+tPortion(0),
+nLit(NULL),
+evalArray(NULL),
+
+evalClause(NULL),
+varMap(NULL),
+
+clCounter(0),
+
+greedyFactor(DEFAULT_GREEDY_FACTOR),
+arrayFiller(NULL),
+nbSatisfiedClausesFill(0),
+nbSatisfiedClausesSolve(0),
+lastFillMethod(0),
+lastHeuristic(0),
+ite(0)
+{
+
+	this->fType.clear();
+	this->fComments.clear();
+
+	// -- Initializing distribution variables --
+
+	rndReal=std::uniform_real_distribution<float>(0.0,1.0);
+	rndMethod=std::uniform_int_distribution<int>(FIRST_FILL_METHOD,LAST_FILL_METHOD);
+	rndHeuristic=std::uniform_int_distribution<int>(FIRST_H_METHOD,LAST_H_METHOD);
+
+	// -- Init random engine --
+
+	struct timespec ts;
+	unsigned theTick = 0U;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	theTick  = ts.tv_nsec / 1000000;
+	theTick += ts.tv_sec * 1000;
+	rndEngine.seed(theTick);
+}
+
+
+
+
+bool CFormula::initFormula(const char* filename)
+{
+
+	// -- Initialize variables --
+
+	this->cFormula.empty();
+	this->fComments.empty();
+	this->fType.empty();
+	this->fStats={0,0,0};
+	this->clCounter=0;
+	bool fReached=false;
+
+
+	// -- Free previously allocated variables --
+
+	if (this->fVars) free(this->fVars);
+	if (this->fPortions) free(this->fPortions);
+	if (this->nLit) free(this->nLit);
+	if (this->evalArray) free(this->evalArray);
+	if (this->arrayFiller) free(this->arrayFiller);
+	if (this->varMap) free(this->varMap);
+	if (this->evalClause) free(this->evalClause);
+
+	// -- Open input file --
+
+	ifstream input_file;
+	input_file.open(filename);
+
+	if (!input_file.is_open())
+	{
+		printf("STD Error: cannot open '%s'.",filename);
+		return false;
+	}
+
+
+	// -- Parse the provided file --
+
+	std::string line;
+	while (std::getline(input_file, line))
+	{
+		// -- get the flag (can be 'c' or 'p') --
+		char flag=line[0];
+		std::vector<string> tokens;
+
+		switch (flag)
+		{
+
+		case COMMENT_FLAG:	// -- Comment line has reached --
+
+			// -- Add to comment string --
+			this->fComments.append(&line[1]);
+			this->fComments.append("\n");
+			break;
+
+
+		case PROBLEM_FLAG:	// -- Problem line has reached --
+
+			// -- Tokenize current line --
+			tokens.empty();
+			tokens=tokenize(&line[1]," ");
+
+			// -- Check if the syntax if correct in order to parse the parameters --
+			if (tokens.size()<3)
+			{
+				printf("There is a syntax error in the problem definition.");
+				return false;
+			}
+
+			// -- Assign the variables --
+			this->fType=tokens[0];
+			this->nVars=stoi(tokens[1])+1;		// -- starts from 1
+			this->nClauses=stoi(tokens[2]);
+			fReached=true;
+
+			// -- allocate the arrays
+			this->fVars=new bool[this->nVars];
+			this->fPortions= new float[this->nVars];
+			this->nLit=new int[this->nVars];
+			this->evalArray=new int[this->nVars];
+			this->evalClause=new bool[this->nClauses];
+			this->varMap=new std::vector<int>[this->nVars];
+
+			// -- initialize the arrays
+			memset(this->fVars,0,this->nVars*sizeof(bool));
+			memset(this->fPortions,0,this->nVars*sizeof(float));
+			memset(this->nLit,0,this->nVars*sizeof(int));
+			memset(this->evalArray,0,this->nVars*sizeof(int));
+			memset(this->evalClause,0,this->nClauses*sizeof(bool));
+
+			// -- Instantiate the arrayFiller class
+			this->arrayFiller=new ArrayFiller(this->fVars,this->nVars);
+
+			break;
+
+
+		case END_FLAG: // -- End of the formula has reached --
+			input_file.close();
+
+			// -- Ppdate stats --
+			this->tPortion=(float)this->fStats.nPosLits/this->fStats.nLits;
+			for (unsigned int i=1;i<this->nVars;i++)
+				this->fPortions[i]/=(float)this->nLit[i];
+
+			// -- Init random filler --
+			this->arrayFiller->setPortionRate(this->tPortion);
+			this->arrayFiller->setPortionArray(this->fPortions);
+			this->arrayFiller->fillArray(PORTION_EL_FILL);
+			return true;
+			break;
+
+		default:	// -- Clause line has reached--
+			if (!fReached)
+				continue;
+			this->cFormula.push_back(parseClause(&line[0]," "));
+			break;
+		}
+
+	}
+
+	return true;
+}
+
+
+
+
+bool CFormula::evalFormulaQ(unsigned int varIndex,int& clNum)
+{
+
+	bool fEval=true;
+	clNum=0;
+
+	// -- check through the modified clauses --
+	for (unsigned int i=0;i<this->varMap[varIndex].size();i++)
+	{
+		// -- get the clause --
+		int cIndex=this->varMap[varIndex].at(i);
+		Clause cl=this->cFormula[cIndex];
+
+		// -- for each literal
+		for (unsigned int j=0;j<cl.size();j++)
+		{
+
+			Literal lit=cl[j];
+
+			// -- get the index and sign
+			bool neg=(lit<0);
+			int index=abs(lit);
+			// -- evaluate the literal
+			bool litEval=neg^this->fVars[index];
+			this->evalClause[cIndex]=litEval; // -- update clause truth list
+
+			// -- if positive -> clause will be evaluated as positive
+			if (litEval)
+				break;
+
+		}
+
+	}
+
+
+	// -- evaluate the whole formula --
+
+	for (unsigned int i=0;i<this->cFormula.size();i++)
+	{
+		bool evalClause=this->evalClause[i];
+		fEval&=evalClause;
+		if (evalClause)clNum++;
+	}
+	return fEval;
+}
+
+
+bool CFormula::evalFormula(int& clNum)
+{
+
+
+	bool fEval=true;
+	clNum=0;
+
+
+	for (unsigned int i=0;i<this->cFormula.size();i++)
+	{
+
+		// -- get the clause --
+		Clause cl=this->cFormula[i];
+		bool clEval=false;
+
+		// -- for each literal
+		for (unsigned int j=0;j<cl.size();j++)
+		{
+
+			Literal lit=cl[j];
+
+			// -- get the index and sign
+			bool neg=(lit<0);
+			int index=abs(lit);
+			// -- evaluate the literal
+			bool litEval=neg^this->fVars[index];
+
+			this->evalClause[i]=litEval;
+
+			// -- if positive -> clause will be evaluated as positive
+			if (litEval)
+			{
+				clEval=true;
+				clNum++;
+				break;
+			}
+		}
+
+		// -- and it with current evaluation of formula
+		fEval&=clEval;
+
+	}
+
+	return fEval;
+}
+
+
+
+bool CFormula::startGSAT(int iterations,int maxTry,int fillMethod,int hMethod)
+{
+	float initGuessMean=0;	// -- initial guess average
+	float negClauseMean=0;	// -- average number of negative clauses
+	float elaborateMean=0; 	// -- averate number of elaboration
+	bool fEval=false;
+	int i;
+
+	for (i=0;i<iterations;i++)
+	{
+		int initGuess=0;
+		int clNum=0;
+		fEval=false;
+
+		// -- randomly select the filler method --
+		FillMethod fMethod;
+		if (fillMethod==-1)
+			fMethod=getRandomMethod();
+		else
+			fMethod=(FillMethod)fillMethod;
+		lastFillMethod=fMethod;
+		ite++;
+		// -- randomly select the heuristic method --
+		HeuristicMethod heuristic;
+		if (hMethod==-1)
+			heuristic=getRandomHeuristic();
+		else
+			heuristic=(HeuristicMethod)hMethod;
+		lastHeuristic=heuristic;
+		
+		this->arrayFiller->fillArray(fMethod);
+
+		// -- evaluate the function
+		fEval=this->evalFormula(clNum);
+		initGuess=clNum;
+		nbSatisfiedClausesFill=initGuess;
+		initGuessMean+=initGuess;
+
+		// -- return if already found the solution
+		if (fEval)
+			break;
+
+
+		for (int j=0;j<maxTry;j++)
+		{
+			int choice=0;
+
+
+			// -- select the choice with the given heuristics --
+
+			switch (heuristic)
+			{
+
+			case FIRST_BEST:
+				choice=this->getBestChoice(true);
+				break;
+
+			case RND_BEST:
+				choice=this->getBestChoice();
+				break;
+
+			case RND_DIST:
+				choice=this->getRndBest();
+				break;
+
+			case RND:
+				choice=(int)(rndReal(rndEngine)*this->nVars);
+				break;
+
+			case RND_GREEDY:
+				if (this->takeBestChoice())
+					choice=this->getBestChoice();
+				else
+					choice=this->getRndBest();
+				break;
+
+			case WALK_SAT:
+				choice=this->walkSatChoice();
+				break;
+
+			case GSAT_WSAT:
+				if (this->takeGW())
+					choice=this->getBestChoice();
+				else
+					choice=this->walkSatChoice();
+				break;
+
+			}
+
+
+			toggle(this->fVars[choice]);
+			fEval=this->evalFormulaQ(choice,clNum);//this->evalFormula(clNum);
+
+			if (fEval)
+				break;
+
+
+		}
+
+
+		negClauseMean+=this->nClauses-clNum;
+		elaborateMean+=clNum-initGuess;
+		nbSatisfiedClausesSolve=clNum;
+
+		//printf("[iteration %d, fill :%d, heuristic :%d] - init Guess :%d - final Guess :%d - model found :%d\n",i,fMethod,heuristic,initGuess,clNum,fEval);
+
+		if (fEval)
+			break;
+	}
+
+
+	/*printf("Elaborate mean :%f\n",elaborateMean/(float)i);
+	printf("Initial guess mean :%f\n",initGuessMean/(float)i);
+	printf("Neg clause mean :%f\n",negClauseMean/(float)i);*/
+
+
+
+	return fEval;
+
+}
+
+
+void CFormula::setGreedyFactor(float factor)
+{
+	this->greedyFactor=factor;
+}
+
+void CFormula::setGWFactor(float factor)
+{
+	this->gwFactor=factor;
+}
+
+std::vector<string> CFormula::tokenize(char*input,const char*split)
+{
+	char * token;
+	std::vector<string> token_vec;
+
+	token = strtok (input,split);
+	while (token != NULL)
+	{
+		token_vec.push_back(string(token));
+		token = strtok (NULL, " ");
+	}
+	return token_vec;
+}
+
+Clause CFormula::parseClause(char*input,const char*split)
+{
+	char * token;
+	Clause cl;
+
+	token = strtok (input,split);
+	while (token != NULL)
+	{
+		Literal lit=stoi(token);
+		if (lit!=0)
+		{
+			int index=abs(lit);
+			// -- update the stats
+
+			this->varMap[index].push_back(clCounter);
+
+			if (lit>0)
+			{
+				this->fStats.nPosLits++;
+				this->fPortions[index]+=1;
+			}
+			else this->fStats.nNegLits++;
+			fStats.nLits++;
+			this->nLit[index]++;
+			// --
+
+			cl.push_back(lit);
+		}
+		token = strtok (NULL, " ");
+	}
+
+	this->clCounter++;
+
+	return cl;
+}
+
+
+
+
+FillMethod CFormula::getRandomMethod()
+{
+	return (FillMethod)rndMethod(rndEngine);
+}
+
+
+HeuristicMethod CFormula::getRandomHeuristic()
+{
+	return (HeuristicMethod)rndHeuristic(rndEngine);
+}
+
+
+
+bool CFormula::takeBestChoice()
+{
+
+	double random=rndReal(rndEngine);	// -- Get a double random number between 0 and 1
+
+	// -- Check if GSAT should take a best action
+	if (random<=this->greedyFactor)
+		return true;
+	return false;
+}
+
+bool CFormula::takeGW()
+{
+
+	double random=rndReal(rndEngine);	// -- Get a double random number between 0 and 1
+
+	// -- Check if GSAT should take a best action
+	if (random<=this->gwFactor)
+		return true;
+	return false;
+}
+
+
+void CFormula::evalMove(int&min,int&max)
+{
+	min=std::numeric_limits<int>::max();
+	max=0;
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		int clNum=0;
+		int temp=0;
+		toggle(this->fVars[i]);
+
+		this->evalFormulaQ(i,clNum);	//this->evalFormula(clNum);
+		toggle(this->fVars[i]);
+		this->evalFormulaQ(i,temp);
+
+		this->evalArray[i]=clNum;
+		if (clNum>max) max=clNum;
+		if (clNum<min) min=clNum;
+
+	}
+}
+
+std::vector<int> CFormula::evalUnsatClause(int clIndex,int&min,int&max)
+{
+	min=std::numeric_limits<int>::max();
+	max=0;
+
+	Clause cl=this->cFormula[clIndex];
+	std::vector<int> evalArray;
+
+	for (unsigned int i=0;i<cl.size();i++)
+	{
+		Literal lit=cl[i];
+		int index=abs(lit);
+
+		int clNum=0;
+		int temp=0;
+
+		// -- evaluate the positive clauses
+		toggle(this->fVars[index]);
+		this->evalFormulaQ(index,clNum);	//this->evalFormula(clNum);
+		toggle(this->fVars[index]);
+		this->evalFormulaQ(index,temp);
+		// --
+
+		evalArray.push_back(clNum);
+		if (clNum>max) max=clNum;
+		if (clNum<min) min=clNum;
+
+	}
+
+	return evalArray;
+}
+
+int CFormula::getBestChoice(bool retFirst)
+{
+	int min,max;
+	this->evalMove(min,max);
+	int bestCount=0;
+	std::vector<int> bestArray;
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		if (this->evalArray[i]==max)
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			bestArray.push_back(i);
+			bestCount++;
+		}
+	}
+
+	if (bestCount==1)
+		return bestArray[0];
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*bestCount);
+	return bestArray[rndIndex];
+
+}
+
+
+int CFormula::walkSatChoice(bool retFirst)
+{
+
+	// -- Randomly get one unsatisfied clause
+	int clIndex=this->getUnsatClause(retFirst);
+
+	int min,max;
+
+	// -- List the best choices
+	std::vector<int> evalArray=evalUnsatClause( clIndex,min,max);
+
+	// -- select randomly from the best choices
+	int bestCount=0;
+	std::vector<int> bestArray;
+
+	for (unsigned int i=0;i<evalArray.size();i++)
+	{
+		if (evalArray[i]==max)
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			bestArray.push_back(i);
+			bestCount++;
+		}
+	}
+
+	if (bestCount==1)
+		return abs(this->cFormula[clIndex].at(bestArray[0]));
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*bestCount);
+
+	return abs(this->cFormula[clIndex].at(bestArray[rndIndex]));
+}
+
+int CFormula::getUnsatClause(bool retFirst)
+{
+
+	int clCount=0;
+	std::vector<int> clArray;
+
+	for (unsigned int i=0;i<this->nClauses;i++)
+	{
+		if (!this->evalClause[i])
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			clArray.push_back(i);
+			clCount++;
+		}
+	}
+
+	if (clCount==1)
+		return clArray[0];
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*clCount);
+	return clArray[rndIndex];
+
+}
+
+int CFormula::getRndBest(bool exponential)
+{
+	int min,max;
+	float cum=0;
+	this->evalMove(min,max);
+	float normalizer=0;
+
+	// -- calculate the discrete probability distribution --
+	float  probs[this->nVars];
+	float rnd =rndReal(rndEngine);
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+
+		probs[i]=(float)(this->evalArray[i]-min+DEFAULT_BIAS);
+
+		if (exponential)probs[i]=exp(probs[i]);
+		normalizer+=probs[i];
+	}
+
+	// -- sample from the distribution --
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		cum+=probs[i]/normalizer;
+
+		if (cum>rnd)
+			return i;
+
+	}
+
+	return 0;
+}
+
+
+
+

Hybride/GSAT/CFormula.hpp

@@ -0,0 +1,140 @@
+/*
+ * CFormula.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ */
+
+#ifndef CFORMULA_HPP_
+#define CFORMULA_HPP_
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include "FillMethod.hpp"
+#include "ArrayFiller.hpp"
+#include "HeuristicMethod.hpp"
+
+using namespace std;
+
+
+typedef int Literal;
+typedef std::vector<Literal> Clause;
+typedef std::vector<Clause> Formulae;
+
+
+
+#define COMMENT_FLAG 'c'
+#define PROBLEM_FLAG 'p'
+#define END_FLAG '%'
+#define toggle(x) (x=x^1)
+#define DEFAULT_BIAS 1
+#define DEFAULT_ITERATIONS 1000
+#define DEFAULT_MAX_TRY 255
+#define DEFAULT_GREEDY_FACTOR 0.8
+#define DEFAULT_GW_FACTOR 0.5
+
+class CFormula
+{
+public :
+	string fType;			// -- formula type (in this case should be 'cnf')
+	string fComments;		// -- formula comments
+	unsigned int nVars;		// -- number of variables
+	unsigned int nClauses;	// -- number of clauses
+	struct
+	{
+		unsigned int nPosLits;		// -- number of positive literals
+		unsigned int nNegLits;		// -- number of negative literals
+		unsigned int nLits;			// -- total literls
+	}fStats;
+
+public :
+  bool * fVars;				// -- formula variables
+  float * fPortions;			// -- variables' proportions
+  float tPortion;				// -- total positive to negative literal proportion
+  int * nLit	;				// -- total occurrence of specific literal in formula
+  int * evalArray;			// -- flip evaluation array
+  bool * evalClause;		    // -- evaluation of clauses  // ADDED
+  std::vector<int>* varMap;	// -- mapping between variables and clauses //ADDED
+  unsigned int clCounter;		// -- clause counter variable
+  float greedyFactor;			// -- GSAT greedy factor
+  float gwFactor;				// -- GSAT or WSAT select probability
+
+  Formulae cFormula;				// -- canonical formula jagged array(vector)
+  ArrayFiller* arrayFiller;		//-- array filler class
+  std::default_random_engine rndEngine;
+  std::uniform_real_distribution<float> rndReal;	// -- sampling from real uniform  distribution
+  std::uniform_int_distribution<int> rndMethod;   // -- sampling from int uniform  distribution
+  std::uniform_int_distribution<int> rndHeuristic;// -- sampling from int uniform  distribution
+  unsigned int nbSatisfiedClausesFill;
+  unsigned int nbSatisfiedClausesSolve;
+  unsigned int lastFillMethod;
+  unsigned int lastHeuristic;
+  unsigned int ite;
+  
+public:
+  CFormula();
+  
+  bool initFormula(const char* filename);
+
+  bool evalFormulaQ(unsigned int varIndex,int& clNum);	// -- faster version of evalFormula (just check the modified clauses)
+
+  bool evalFormula(int& clNum);
+
+  bool startGSAT(int iterations=DEFAULT_ITERATIONS,int maxTry=DEFAULT_MAX_TRY,int fillMethod=-1,int hMethod=-1);
+
+  void setGreedyFactor(float factor);
+
+  void setGWFactor(float factor);
+
+  inline unsigned int getNbClauses(){return nClauses;}
+  inline unsigned int getNbVariables(){return nVars;}
+
+  inline unsigned int getNbSatisfiedClausesFill(){return nbSatisfiedClausesFill;}
+  inline unsigned int getNbSatisfiedClausesSolve(){return nbSatisfiedClausesSolve;}
+  
+  inline unsigned int getHeuristicFill(){return lastFillMethod;}
+  inline unsigned int getHeuristicSolve(){return lastHeuristic;}
+  inline unsigned int getNbIterations(){return ite;}
+
+  
+private:
+	std::vector<string> tokenize(char*input,const char*split);
+
+	Clause parseClause(char*input,const char*split);
+
+	// -- randomly select the filler method --
+	FillMethod getRandomMethod();
+
+	// -- randomly select the heuristic method --
+	HeuristicMethod getRandomHeuristic();
+
+	// -- If GSAT should take a best action
+	bool takeBestChoice();
+
+	bool takeGW();
+
+	void evalMove(int&min,int&max);
+
+	std::vector<int> evalUnsatClause(int clIndex,int&min,int&max);
+
+	int getBestChoice(bool retFirst=false);
+
+	int walkSatChoice(bool retFirst=false);
+
+	int getUnsatClause(bool retFirst=false);
+
+	int getRndBest(bool exponential=true);	// -- randomly select the choice according to each move's reward
+
+
+};
+
+
+#endif /* CFORMULA_HPP_ */

Hybride/GSAT/FillMethod.hpp

@@ -0,0 +1,28 @@
+/*
+ * FillMethod.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The methods for filling 1-D boolean array
+ */
+
+#ifndef FILLMETHOD_HPP_
+#define FILLMETHOD_HPP_
+
+
+enum FillMethod
+{
+	ZEROS_FILL,
+	ONES_FILL,
+	UNIFORM_FILL,
+	STEP_FILL,
+	PORTION_FILL,
+	PORTION_EL_FILL
+};
+
+#define METHOD_COUNT 6
+#define FIRST_FILL_METHOD 	UNIFORM_FILL
+#define LAST_FILL_METHOD 	PORTION_EL_FILL
+#define UNIFORM_RATIO	0.5
+
+#endif /* FILLMETHOD_HPP_ */

Hybride/GSAT/GSAT.cpp

@@ -0,0 +1,144 @@
+//============================================================================
+// Name        : GSAT.cpp
+// Author      : Sina M.Baharlou
+// Version     : 1
+// Description : GSAT Solver
+//============================================================================
+
+
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include <sys/time.h>
+
+#include "GSAT.hpp"
+
+using namespace std;
+
+#include <algorithm>
+
+
+char* getCmdOption(char ** begin, char ** end, const std::string & option)
+{
+	char ** itr = std::find(begin, end, option);
+	if (itr != end && ++itr != end)
+	{
+		return *itr;
+	}
+	return 0;
+}
+
+bool cmdOptionExists(char** begin, char** end, const std::string& option)
+{
+	return std::find(begin, end, option) != end;
+}
+
+
+
+void printHelp()
+{
+	const char *help = "\n\n// --  GSAT simple solver -- // \n"
+			"// --  By Sina M.Baharlou -- // \n"
+			"// --  Oct  2016 \n\n"
+			"GSAT -i [input_file] <options> \n"
+			"Available options are : \n"
+			"\t--iterations [number of iterations] \n"
+			"\t--flip_max [number of maximum flips per iterations]\n"
+			"\t--greedy_factor [greedy factor] \n"
+			"\t--gw_factor [gsat/wsat factor] \n"
+			"\t--heuristic [heuristic_method]\n"
+			"\t\t-1- randomly select the heuristic method\n"
+			"\t\t 0- select the first best choice\n"
+			"\t\t 1- select randomly among the best choices\n"
+			"\t\t 2- select according to the cost distribution\n"
+			"\t\t 3- select randomly among all the choices\n"
+			"\t\t 4- combination of 1 and 2 according to the greedy factor\n"
+			"\t\t 5- WALKSAT\n"
+			"\t\t 6- randomly select between GSAT or WALKSAT\n"
+			"\t--rnd_method [rnd_method] \n"
+			"\t\t-1-randomly select the method\n"
+			"\t\t0-fill with zeros\n"
+			"\t\t1-fill with ones\n"
+			"\t\t2-fill uniformly\n"
+			"\t\t3-STEP method\n"
+			"\t\t4-PORTION method\n"
+			"\t\t5-PORTION_EL method\n";
+
+
+	printf("%s",help);
+}
+
+void GSAT::initialize(){
+  formula=new CFormula();
+  formula->initFormula(options->filename);
+  formula->setGreedyFactor(options->greedyFactor);
+  formula->setGWFactor(options->gwFactor);
+}
+
+bool GSAT::start(int fill,int heuristic){
+  return formula->startGSAT(1,options->maxTry,fill,heuristic);
+}
+
+Options* GSAT::setParameters(int argc,char* argv[]){
+  options = new Options();
+  // -- default variables --
+  options->iterations=DEFAULT_ITERATIONS;
+  options->maxTry=DEFAULT_MAX_TRY;
+  options->greedyFactor=DEFAULT_GREEDY_FACTOR;
+  options->gwFactor=DEFAULT_GW_FACTOR;
+  options->rndMethod=DEFAULT_RND_METHOD;
+  options->hMethod=DEFAULT_H_METHOD;
+  // --
+
+
+  if (argc<2)
+    {
+      printHelp();
+      exit(0);
+    }
+
+  if (!cmdOptionExists(argv, argv+argc, "-i"))
+    {
+      printHelp();
+      printf("STD Error : no input file has been provided.\n\n");
+      exit(0);
+    }
+
+  options->filename = getCmdOption(argv, argv + argc, "-i");
+
+  if (options->filename==NULL)
+    {
+      printf("STD Error : not input file has been provided.\n\n");
+      exit(0);
+    }
+
+  if (cmdOptionExists(argv, argv+argc, "--iterations"))
+    options->iterations=stoi(getCmdOption(argv, argv + argc, "--iterations"));
+
+
+
+  if (cmdOptionExists(argv, argv+argc, "--flip_max"))
+    options->maxTry=stoi(getCmdOption(argv, argv + argc, "--flip_max"));
+
+
+  if (cmdOptionExists(argv, argv+argc, "--greedy_factor"))
+    options->greedyFactor=stof(getCmdOption(argv, argv + argc, "--greedy_factor"));
+
+  if (cmdOptionExists(argv, argv+argc, "--gw_factor"))
+    options->gwFactor=stof(getCmdOption(argv, argv + argc, "--gw_factor"));
+
+  if (cmdOptionExists(argv, argv+argc, "--rnd_method"))
+    options->rndMethod=stoi(getCmdOption(argv, argv + argc, "--rnd_method"));
+
+  if (cmdOptionExists(argv, argv+argc, "--heuristic"))
+    options->hMethod=stoi(getCmdOption(argv, argv + argc, "--heuristic"));
+  return options;
+}

Hybride/GSAT/GSAT.hpp

@@ -0,0 +1,71 @@
+
+#ifndef GSAT_HPP_
+#define GSAT_HPP_
+
+
+#include "FillMethod.hpp"
+#include "ArrayFiller.hpp"
+#include "CFormula.hpp"
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <string> 
+#include <fstream>
+#include <random>
+#include <math.h>
+#include <sys/time.h>
+
+#define DEFAULT_ITERATIONS 1000
+#define DEFAULT_MAX_TRY 255
+#define DEFAULT_GREEDY_FACTOR 0.8
+#define DEFAULT_GW_FACTOR 0.5
+#define DEFAULT_RND_METHOD -1
+#define DEFAULT_H_METHOD -1
+
+class Options{
+public:
+  int iterations;
+  int maxTry;
+  float greedyFactor;
+  float gwFactor;
+  int rndMethod;
+  int hMethod;
+  char* filename;
+};
+
+char* getCmdOption(char ** begin, char ** end, const std::string & option);
+bool cmdOptionExists(char** begin, char** end, const std::string& option);
+void printHelp();
+
+class GSAT{
+public:
+  CFormula* formula;
+  Options* options;
+
+  Options* setParameters(int argc,char* argv[]);
+  void initialize();
+  bool start(int fill=DEFAULT_RND_METHOD,int heuristic=DEFAULT_H_METHOD);
+  inline double realTime() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (double)tv.tv_sec + (double) tv.tv_usec / 1000000;
+  }
+
+  inline unsigned int getNbClauses(){return formula->getNbClauses();}
+  inline unsigned int getNbVariables(){return formula->getNbVariables();}
+
+  inline unsigned int getNbSatisfiedClausesFill(){return formula->getNbSatisfiedClausesFill();}
+  inline unsigned int getNbSatisfiedClausesSolve(){return formula->getNbSatisfiedClausesSolve();}
+  
+  inline unsigned int getHeuristicFill(){return formula->getHeuristicFill();}
+  inline unsigned int getHeuristicSolve(){return formula->getHeuristicSolve();}
+  inline unsigned int getNbIterations(){return formula->getNbIterations();}
+};
+
+
+
+#endif

Hybride/GSAT/HeuristicMethod.hpp

@@ -0,0 +1,30 @@
+/*
+ * HeuristicMethod.hpp
+ *
+ *  Created on: Oct 3, 2016
+ *      Author: sina
+ */
+
+#ifndef HEURISTICMETHOD_HPP_
+#define HEURISTICMETHOD_HPP_
+
+
+enum HeuristicMethod
+{
+	FIRST_BEST,
+	RND_BEST,
+	RND_DIST,
+	RND,
+	RND_GREEDY,
+	WALK_SAT,
+	GSAT_WSAT,
+
+};
+
+#define FIRST_H_METHOD 	FIRST_BEST
+#define LAST_H_METHOD 	GSAT_WSAT
+
+
+
+
+#endif /* HEURISTICMETHOD_HPP_ */

Hybride/GSATThreadMPI.cpp

@@ -0,0 +1,115 @@
+#include <iostream>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include "Main.hpp"
+#include "GSATThreadMPI.hpp"
+#include  "color.h"
+
+extern int world_rank;
+
+/* --- Public --- */
+
+GSATThreadMPI::GSATThreadMPI(int _nbThread, int argc, char** argv) {
+	nbThread = _nbThread;
+	gsat = std::vector<GSAT*>(_nbThread);
+	threads = std::vector<std::thread>(_nbThread);
+	for(int i = 0; i < _nbThread; i++) {
+		gsat[i] = new GSAT();
+		gsat[i]->setParameters(argc,argv);
+  		gsat[i]->initialize();
+	}
+	srand(getpid());
+}
+
+GSATThreadMPI::~GSATThreadMPI() {
+	for(int i = 0; i < nbThread; i++) {
+		delete gsat[i];
+	}
+}
+
+bool GSATThreadMPI::solve() {
+	threads.clear();
+	end = false;
+	find = false;
+	//Lance thread
+	for(int i = 0; i < nbThread; i++) {
+		threads[i] = std::thread(&GSATThreadMPI::solverThread, this, i);
+	}
+	//Attend resultat
+	for(int i = 0; i < nbThread; i++){
+		threads[i].join();
+	}
+	//Si c'est le proc qui à trouvé
+	if(find) {
+		sleep(1); //Laisse le temps aux autres de se couper
+		//Affiche resultat
+		printf("-------------------------------------------------------------------------------------------------------\n");
+		printf(GREEN);
+		printf("s %s\n",find?"SATISFIABLE":"NOT FOUND");
+		printf(YELLOW);
+        printf("c real time : %.4f seconds\n", result.calcTime);
+        printf("c [processor:%d][thread:%2d][iteration:%5d][file:%d][heuristic:%d]Satisfied clauses (begin: %d)(end:%d)\n",
+			world_rank,
+			result.threadId,
+			result.nbIteration,
+			result.heuristicFill,
+			result.heuristicSolve,
+			result.nbSatisfiedClausesFill,
+			result.nbSatisfiedClausesSolve);
+        printf(RESET);
+        fflush(stdout);
+	}
+  	return find;
+}
+
+void GSATThreadMPI::isEnd() {
+	end = true;
+}
+
+/* --- Private --- */
+
+void GSATThreadMPI::solverThread(int id) {
+	//Resolution
+	double startTime = gsat[id]->realTime();
+	bool solve = false;
+	int cpt = 0;
+	while(!end && !solve){
+		//Pour eviter que les processeurs effectue tous les meme calculs
+        int fill = rand() % 4 + 2;
+        int h = rand() % 7;
+        solve = gsat[id]->start(fill, h);
+        if(solve) {
+        	printf(CYAN);
+        }
+		printf("c [processor:%d][thread:%2d][iteration:%5d][file:%d][heuristic:%d]Satisfied clauses (begin: %d)(end:%d)\n",
+			world_rank,
+			id,
+		   	gsat[id]->getNbIterations(),
+		   	gsat[id]->getHeuristicFill(),
+		   	gsat[id]->getHeuristicSolve(),
+		   	gsat[id]->getNbSatisfiedClausesFill(),
+		   	gsat[id]->getNbSatisfiedClausesSolve());
+		if(solve) {
+			printf(RESET);
+		}
+		cpt++;
+		if(id == 0) {
+			mpiSync(this, end || solve);
+			//printf("bool : %d %d\n", end, solve);
+		}
+	}
+	//printf("%d %d %d\n", world_rank, end, solve);
+	//Si 1er arreter
+	if(!end && solve) {
+		end = true;
+		find = true;
+		result.threadId = id;
+		result.calcTime = gsat[id]->realTime() - startTime;
+		result.nbIteration = gsat[id]->getNbIterations();
+		result.heuristicFill = gsat[id]->getHeuristicFill();
+		result.heuristicSolve = gsat[id]->getHeuristicSolve();
+		result.nbSatisfiedClausesFill = gsat[id]->getNbSatisfiedClausesFill();
+		result.nbSatisfiedClausesSolve = gsat[id]->getNbSatisfiedClausesSolve();
+	}
+}

Hybride/GSATThreadMPI.hpp

@@ -0,0 +1,44 @@
+#ifndef GSATTHREADMPI_HPP 
+#define GSATTHREADMPI_HPP 
+
+/* --- Include --- */
+#include <vector>
+#include <thread>
+#include "GSAT/GSAT.hpp"
+
+/* --- Constante --- */
+#define DEFAULT_NB_THREAD 4
+
+/* --- Structure --- */
+typedef struct {
+	int threadId;
+	double calcTime;
+	unsigned int nbIteration;
+	unsigned int heuristicFill;
+	unsigned int heuristicSolve;
+	unsigned int nbSatisfiedClausesFill;
+	unsigned int nbSatisfiedClausesSolve;
+}GSATResult;
+
+class GSATThreadMPI {
+	public:
+		GSATThreadMPI(int, int, char**);
+		~GSATThreadMPI();
+		bool solve();
+		void isEnd();
+		/* --- Getter --- */
+		inline unsigned int getNbVariables() {return gsat[0]->getNbVariables();}
+		inline unsigned int getNbClauses() {return gsat[0]->getNbClauses();}
+
+	private:
+		bool end;
+		bool find;
+		int nbThread;
+		std::vector<GSAT*> gsat;
+		std::vector<std::thread> threads;
+		GSATResult result;
+
+		void solverThread(int);
+};
+
+#endif

Hybride/Main.cpp

@@ -0,0 +1,86 @@
+#include "GSAT/GSAT.hpp"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <mpi.h>
+#include "Main.hpp"
+
+using namespace std;
+
+int world_size;
+int world_rank;
+
+void help(char* prog) {
+    fprintf(stderr, "usage: mpirun -n int ./%s -i file.cnf [-t int]\n\t-t Number of threads to use\n", prog);
+    exit(1);
+}
+
+int main(int argc, char* argv[]) {
+    extern char * optarg; 
+    int nbThread = DEFAULT_NB_THREAD;
+    int opt;
+    bool optI = false;
+
+    char** gsatArg = (char**) malloc(sizeof(char*) * 3);
+    gsatArg[0] = (char*) malloc(sizeof(char) * strlen(argv[0]) + 1);
+    memset(gsatArg[0], 0, strlen(argv[0]) + 1);
+    strncpy(gsatArg[0], argv[0], strlen(argv[0]));
+
+    while((opt = getopt(argc, argv, "i:t:")) != -1) {
+        switch(opt) {
+            case 'i':
+                optI = true;
+                gsatArg[1] = (char*) malloc(sizeof(char) * 3);
+                memset(gsatArg[1], 0, 3);
+                strncpy(gsatArg[1], "-i", 2);
+                gsatArg[2] = (char*) malloc(sizeof(char) * strlen(optarg) + 1);
+                memset(gsatArg[2], 0, strlen(optarg) + 1);
+                strncpy(gsatArg[2], optarg, strlen(optarg));
+                break;
+            case 't':
+                nbThread = atoi(optarg);
+                break;
+            case '?':
+                help(argv[0]); 
+        }
+    }
+
+    if(!optI) {
+        help(argv[0]);
+    }
+
+    //Init MPI
+    MPI_Init(NULL, NULL);
+    MPI_Comm_size(MPI_COMM_WORLD, &world_size);
+    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
+  
+    GSATThreadMPI* gsat = new GSATThreadMPI(nbThread, 3, gsatArg);
+    if(world_rank == 0) {
+        printf("c nbProcessors: %d\n", world_size);
+        printf("c nbThreads: %d\n", nbThread);
+        printf("c nbVariables: %d\n", gsat->getNbVariables());
+        printf("c nbClauses: %d\n", gsat->getNbClauses());
+    }
+    gsat->solve();
+    
+    MPI_Finalize();
+
+}
+
+void mpiSync(GSATThreadMPI* gsat, bool solve) {
+    bool stop = false;
+    for(int i = 0; i < world_size; i++){
+        int buff;
+        if(i == world_rank) {
+            buff = solve ? 1 : 0;
+        }
+        MPI_Bcast(&buff, 1, MPI_INT, i, MPI_COMM_WORLD);
+        if(i != world_rank && buff && !stop) {
+            stop = true;
+        }
+    }
+    if(stop) {
+        gsat->isEnd();
+    }
+}

Hybride/Main.hpp

@@ -0,0 +1,11 @@
+#ifndef MAIN_HPP
+#define MAIN_CPP
+
+#include "GSATThreadMPI.hpp"
+
+extern int world_rank;
+
+void help(char*);
+void mpiSync(GSATThreadMPI*, bool);
+
+#endif

Hybride/Makefile

@@ -0,0 +1,22 @@
+FLAGS = -std=c++0x -O2 -g -Wall -fmessage-length=0 -Wreorder -Wwrite-strings -Wsign-compare
+
+EXEC = Main
+
+OBJS = GSATThreadMPI.o GSAT/GSAT.o GSAT/ArrayFiller.o GSAT/CFormula.o
+
+LIBS = -lpthread
+
+TARGET = GSATSolver
+
+$(TARGET):	$(OBJS)
+	mpic++ -o $(TARGET) $(EXEC).cpp $(FLAGS) $(OBJS) $(LIBS)
+
+all: $(TARGET)
+
+clean:
+	rm -f $(OBJS) $(TARGET)
+	rm -rf *.*~
+	rm -rf *~
+
+run: 
+	@mpirun -n 3 ./GSATSolver -i ../benchmarks/uf150/uf150-099.cnf -t 2

Hybride/README.txt

@@ -0,0 +1,3 @@
+
+make -j
+./GSAT -i ../benchmarks/uf150/uf150-099.cnf

Hybride/color.h

@@ -0,0 +1,7 @@
+#define RED     "\x1b[31m"
+#define GREEN   "\x1b[32m"
+#define YELLOW  "\x1b[33m"
+#define BLUE    "\x1b[34m"
+#define MAGENTA "\x1b[35m"
+#define CYAN    "\x1b[36m"
+#define RESET   "\x1b[0m"

MPI/GSAT/ArrayFiller.cpp

@@ -0,0 +1,120 @@
+/*
+ * ArrayFiller.cpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The class for filling 1-D boolean array
+ */
+
+
+#include "ArrayFiller.hpp"
+
+ArrayFiller::ArrayFiller(bool* bArray,unsigned int arrSize):
+arrSize(arrSize),
+stepSize(DEFAULT_STEP_SIZE),
+currStep(DEFAULT_CURR_STEP),
+tRate(0),
+pArray(NULL)
+{
+
+	// -- Initialize boolean array if it has not been initialized
+
+	if (bArray==NULL)
+		this->bArray=new bool[arrSize];
+	else
+		this->bArray=bArray;
+
+	// -- Initializing sampling distribution --
+
+	this->rndReal=std::uniform_real_distribution<float>(0.0,1.0);
+
+	// -- Init random engine --
+
+	struct timespec ts;
+	unsigned theTick = 0U;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	theTick  = ts.tv_nsec / 1000000;
+	theTick += ts.tv_sec * 1000;
+	this->rndEngine.seed(theTick);
+}
+
+
+bool* ArrayFiller::getArray()
+{
+	return this->bArray;
+}
+
+void ArrayFiller::setPortionArray(float* pArray)
+{
+	this->pArray=pArray;
+}
+
+void ArrayFiller::setPortionRate(float rate)
+{
+	this->tRate=rate;
+}
+
+
+bool* ArrayFiller::fillArray(FillMethod method)
+{
+
+
+	switch (method)
+	{
+
+	case ZEROS_FILL:	// -- fills with zeros (false)
+		memset(this->bArray,0,this->arrSize*sizeof(bool));
+		break;
+
+	case ONES_FILL: // -- fills with ones (true)
+		memset(this->bArray,1,this->arrSize*sizeof(bool));
+		break;
+
+	case UNIFORM_FILL: // -- uniformly fills with zeros and ones
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd<UNIFORM_RATIO);
+		}
+		break;
+
+	case STEP_FILL:	// -- fills with step method
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->currStep);
+		}
+
+		this->currStep+=this->stepSize; // -- increase the step size ( probability of having true value)
+		if (this->currStep>1) this->currStep=0;
+		break;
+
+	case PORTION_FILL: // -- fills proportionally
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->tRate);
+		}
+		break;
+
+	case PORTION_EL_FILL: // -- fills each element proportionally
+
+		if (this->pArray==NULL)
+			break;
+
+
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->pArray[i]);
+		}
+		break;
+
+	}
+
+	return this->bArray;
+
+}
+
+
+

MPI/GSAT/ArrayFiller.hpp

@@ -0,0 +1,61 @@
+/*
+ * ArrayFiller.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The class for filling 1-D boolean array
+ */
+
+#ifndef ARRAYFILLER_HPP_
+#define ARRAYFILLER_HPP_
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include "FillMethod.hpp"
+
+#define DEFAULT_STEP_SIZE	0.05
+#define DEFAULT_CURR_STEP	0.05
+
+using namespace std;
+
+class ArrayFiller
+{
+private :
+	bool *bArray ;					// -- pointer to the boolean array
+	unsigned int arrSize;			// -- array size
+	float stepSize;					// -- STEP_FILL, step size
+	float currStep;					// -- STEP_FILL, current step
+	float tRate;					// -- PORTION_FILL, true-rate
+	float* pArray;					// -- PORTION_EL_FILL array
+
+	std::uniform_real_distribution<float> rndReal;	// -- sampling from real uniform  distribution
+	std::default_random_engine rndEngine;			// -- sampling engine
+
+
+public:
+
+	// -- Vector Filler constructor
+	ArrayFiller(bool* bArray,unsigned int arrSize);
+
+	// -- property methods --
+	bool* getArray();
+
+	void setPortionArray(float* pArray);
+
+	void setPortionRate(float rate);
+
+	// -- Fill array randomly with the given method --
+	bool* fillArray(FillMethod method);
+
+};
+
+
+#endif /* ARRAYFILLER_HPP_ */

MPI/GSAT/CFormula.cpp

@@ -0,0 +1,675 @@
+/*
+ * CFormula.cpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ */
+
+#include "CFormula.hpp"
+
+CFormula::CFormula():
+nVars(0),
+nClauses(0),
+fStats{0,0,0},
+fVars(NULL),
+fPortions(NULL),
+tPortion(0),
+nLit(NULL),
+evalArray(NULL),
+
+evalClause(NULL),
+varMap(NULL),
+
+clCounter(0),
+
+greedyFactor(DEFAULT_GREEDY_FACTOR),
+arrayFiller(NULL),
+nbSatisfiedClausesFill(0),
+nbSatisfiedClausesSolve(0),
+lastFillMethod(0),
+lastHeuristic(0),
+ite(0)
+{
+
+	this->fType.clear();
+	this->fComments.clear();
+
+	// -- Initializing distribution variables --
+
+	rndReal=std::uniform_real_distribution<float>(0.0,1.0);
+	rndMethod=std::uniform_int_distribution<int>(FIRST_FILL_METHOD,LAST_FILL_METHOD);
+	rndHeuristic=std::uniform_int_distribution<int>(FIRST_H_METHOD,LAST_H_METHOD);
+
+	// -- Init random engine --
+
+	struct timespec ts;
+	unsigned theTick = 0U;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	theTick  = ts.tv_nsec / 1000000;
+	theTick += ts.tv_sec * 1000;
+	rndEngine.seed(theTick);
+}
+
+
+
+
+bool CFormula::initFormula(const char* filename)
+{
+
+	// -- Initialize variables --
+
+	this->cFormula.empty();
+	this->fComments.empty();
+	this->fType.empty();
+	this->fStats={0,0,0};
+	this->clCounter=0;
+	bool fReached=false;
+
+
+	// -- Free previously allocated variables --
+
+	if (this->fVars) free(this->fVars);
+	if (this->fPortions) free(this->fPortions);
+	if (this->nLit) free(this->nLit);
+	if (this->evalArray) free(this->evalArray);
+	if (this->arrayFiller) free(this->arrayFiller);
+	if (this->varMap) free(this->varMap);
+	if (this->evalClause) free(this->evalClause);
+
+	// -- Open input file --
+
+	ifstream input_file;
+	input_file.open(filename);
+
+	if (!input_file.is_open())
+	{
+		printf("STD Error: cannot open '%s'.",filename);
+		return false;
+	}
+
+
+	// -- Parse the provided file --
+
+	std::string line;
+	while (std::getline(input_file, line))
+	{
+		// -- get the flag (can be 'c' or 'p') --
+		char flag=line[0];
+		std::vector<string> tokens;
+
+		switch (flag)
+		{
+
+		case COMMENT_FLAG:	// -- Comment line has reached --
+
+			// -- Add to comment string --
+			this->fComments.append(&line[1]);
+			this->fComments.append("\n");
+			break;
+
+
+		case PROBLEM_FLAG:	// -- Problem line has reached --
+
+			// -- Tokenize current line --
+			tokens.empty();
+			tokens=tokenize(&line[1]," ");
+
+			// -- Check if the syntax if correct in order to parse the parameters --
+			if (tokens.size()<3)
+			{
+				printf("There is a syntax error in the problem definition.");
+				return false;
+			}
+
+			// -- Assign the variables --
+			this->fType=tokens[0];
+			this->nVars=stoi(tokens[1])+1;		// -- starts from 1
+			this->nClauses=stoi(tokens[2]);
+			fReached=true;
+
+			// -- allocate the arrays
+			this->fVars=new bool[this->nVars];
+			this->fPortions= new float[this->nVars];
+			this->nLit=new int[this->nVars];
+			this->evalArray=new int[this->nVars];
+			this->evalClause=new bool[this->nClauses];
+			this->varMap=new std::vector<int>[this->nVars];
+
+			// -- initialize the arrays
+			memset(this->fVars,0,this->nVars*sizeof(bool));
+			memset(this->fPortions,0,this->nVars*sizeof(float));
+			memset(this->nLit,0,this->nVars*sizeof(int));
+			memset(this->evalArray,0,this->nVars*sizeof(int));
+			memset(this->evalClause,0,this->nClauses*sizeof(bool));
+
+			// -- Instantiate the arrayFiller class
+			this->arrayFiller=new ArrayFiller(this->fVars,this->nVars);
+
+			break;
+
+
+		case END_FLAG: // -- End of the formula has reached --
+			input_file.close();
+
+			// -- Ppdate stats --
+			this->tPortion=(float)this->fStats.nPosLits/this->fStats.nLits;
+			for (unsigned int i=1;i<this->nVars;i++)
+				this->fPortions[i]/=(float)this->nLit[i];
+
+			// -- Init random filler --
+			this->arrayFiller->setPortionRate(this->tPortion);
+			this->arrayFiller->setPortionArray(this->fPortions);
+			this->arrayFiller->fillArray(PORTION_EL_FILL);
+			return true;
+			break;
+
+		default:	// -- Clause line has reached--
+			if (!fReached)
+				continue;
+			this->cFormula.push_back(parseClause(&line[0]," "));
+			break;
+		}
+
+	}
+
+	return true;
+}
+
+
+
+
+bool CFormula::evalFormulaQ(unsigned int varIndex,int& clNum)
+{
+
+	bool fEval=true;
+	clNum=0;
+
+	// -- check through the modified clauses --
+	for (unsigned int i=0;i<this->varMap[varIndex].size();i++)
+	{
+		// -- get the clause --
+		int cIndex=this->varMap[varIndex].at(i);
+		Clause cl=this->cFormula[cIndex];
+
+		// -- for each literal
+		for (unsigned int j=0;j<cl.size();j++)
+		{
+
+			Literal lit=cl[j];
+
+			// -- get the index and sign
+			bool neg=(lit<0);
+			int index=abs(lit);
+			// -- evaluate the literal
+			bool litEval=neg^this->fVars[index];
+			this->evalClause[cIndex]=litEval; // -- update clause truth list
+
+			// -- if positive -> clause will be evaluated as positive
+			if (litEval)
+				break;
+
+		}
+
+	}
+
+
+	// -- evaluate the whole formula --
+
+	for (unsigned int i=0;i<this->cFormula.size();i++)
+	{
+		bool evalClause=this->evalClause[i];
+		fEval&=evalClause;
+		if (evalClause)clNum++;
+	}
+	return fEval;
+}
+
+
+bool CFormula::evalFormula(int& clNum)
+{
+
+
+	bool fEval=true;
+	clNum=0;
+
+
+	for (unsigned int i=0;i<this->cFormula.size();i++)
+	{
+
+		// -- get the clause --
+		Clause cl=this->cFormula[i];
+		bool clEval=false;
+
+		// -- for each literal
+		for (unsigned int j=0;j<cl.size();j++)
+		{
+
+			Literal lit=cl[j];
+
+			// -- get the index and sign
+			bool neg=(lit<0);
+			int index=abs(lit);
+			// -- evaluate the literal
+			bool litEval=neg^this->fVars[index];
+
+			this->evalClause[i]=litEval;
+
+			// -- if positive -> clause will be evaluated as positive
+			if (litEval)
+			{
+				clEval=true;
+				clNum++;
+				break;
+			}
+		}
+
+		// -- and it with current evaluation of formula
+		fEval&=clEval;
+
+	}
+
+	return fEval;
+}
+
+
+
+bool CFormula::startGSAT(int iterations,int maxTry,int fillMethod,int hMethod)
+{
+	float initGuessMean=0;	// -- initial guess average
+	float negClauseMean=0;	// -- average number of negative clauses
+	float elaborateMean=0; 	// -- averate number of elaboration
+	bool fEval=false;
+	int i;
+
+	for (i=0;i<iterations;i++)
+	{
+		int initGuess=0;
+		int clNum=0;
+		fEval=false;
+
+		// -- randomly select the filler method --
+		FillMethod fMethod;
+		if (fillMethod==-1)
+			fMethod=getRandomMethod();
+		else
+			fMethod=(FillMethod)fillMethod;
+		lastFillMethod=fMethod;
+		ite++;
+		// -- randomly select the heuristic method --
+		HeuristicMethod heuristic;
+		if (hMethod==-1)
+			heuristic=getRandomHeuristic();
+		else
+			heuristic=(HeuristicMethod)hMethod;
+		lastHeuristic=heuristic;
+		
+		this->arrayFiller->fillArray(fMethod);
+
+		// -- evaluate the function
+		fEval=this->evalFormula(clNum);
+		initGuess=clNum;
+		nbSatisfiedClausesFill=initGuess;
+		initGuessMean+=initGuess;
+
+		// -- return if already found the solution
+		if (fEval)
+			break;
+
+
+		for (int j=0;j<maxTry;j++)
+		{
+			int choice=0;
+
+
+			// -- select the choice with the given heuristics --
+
+			switch (heuristic)
+			{
+
+			case FIRST_BEST:
+				choice=this->getBestChoice(true);
+				break;
+
+			case RND_BEST:
+				choice=this->getBestChoice();
+				break;
+
+			case RND_DIST:
+				choice=this->getRndBest();
+				break;
+
+			case RND:
+				choice=(int)(rndReal(rndEngine)*this->nVars);
+				break;
+
+			case RND_GREEDY:
+				if (this->takeBestChoice())
+					choice=this->getBestChoice();
+				else
+					choice=this->getRndBest();
+				break;
+
+			case WALK_SAT:
+				choice=this->walkSatChoice();
+				break;
+
+			case GSAT_WSAT:
+				if (this->takeGW())
+					choice=this->getBestChoice();
+				else
+					choice=this->walkSatChoice();
+				break;
+
+			}
+
+
+			toggle(this->fVars[choice]);
+			fEval=this->evalFormulaQ(choice,clNum);//this->evalFormula(clNum);
+
+			if (fEval)
+				break;
+
+
+		}
+
+
+		negClauseMean+=this->nClauses-clNum;
+		elaborateMean+=clNum-initGuess;
+		nbSatisfiedClausesSolve=clNum;
+
+		//printf("[iteration %d, fill :%d, heuristic :%d] - init Guess :%d - final Guess :%d - model found :%d\n",i,fMethod,heuristic,initGuess,clNum,fEval);
+
+		if (fEval)
+			break;
+	}
+
+
+	/*printf("Elaborate mean :%f\n",elaborateMean/(float)i);
+	printf("Initial guess mean :%f\n",initGuessMean/(float)i);
+	printf("Neg clause mean :%f\n",negClauseMean/(float)i);*/
+
+
+
+	return fEval;
+
+}
+
+
+void CFormula::setGreedyFactor(float factor)
+{
+	this->greedyFactor=factor;
+}
+
+void CFormula::setGWFactor(float factor)
+{
+	this->gwFactor=factor;
+}
+
+std::vector<string> CFormula::tokenize(char*input,const char*split)
+{
+	char * token;
+	std::vector<string> token_vec;
+
+	token = strtok (input,split);
+	while (token != NULL)
+	{
+		token_vec.push_back(string(token));
+		token = strtok (NULL, " ");
+	}
+	return token_vec;
+}
+
+Clause CFormula::parseClause(char*input,const char*split)
+{
+	char * token;
+	Clause cl;
+
+	token = strtok (input,split);
+	while (token != NULL)
+	{
+		Literal lit=stoi(token);
+		if (lit!=0)
+		{
+			int index=abs(lit);
+			// -- update the stats
+
+			this->varMap[index].push_back(clCounter);
+
+			if (lit>0)
+			{
+				this->fStats.nPosLits++;
+				this->fPortions[index]+=1;
+			}
+			else this->fStats.nNegLits++;
+			fStats.nLits++;
+			this->nLit[index]++;
+			// --
+
+			cl.push_back(lit);
+		}
+		token = strtok (NULL, " ");
+	}
+
+	this->clCounter++;
+
+	return cl;
+}
+
+
+
+
+FillMethod CFormula::getRandomMethod()
+{
+	return (FillMethod)rndMethod(rndEngine);
+}
+
+
+HeuristicMethod CFormula::getRandomHeuristic()
+{
+	return (HeuristicMethod)rndHeuristic(rndEngine);
+}
+
+
+
+bool CFormula::takeBestChoice()
+{
+
+	double random=rndReal(rndEngine);	// -- Get a double random number between 0 and 1
+
+	// -- Check if GSAT should take a best action
+	if (random<=this->greedyFactor)
+		return true;
+	return false;
+}
+
+bool CFormula::takeGW()
+{
+
+	double random=rndReal(rndEngine);	// -- Get a double random number between 0 and 1
+
+	// -- Check if GSAT should take a best action
+	if (random<=this->gwFactor)
+		return true;
+	return false;
+}
+
+
+void CFormula::evalMove(int&min,int&max)
+{
+	min=std::numeric_limits<int>::max();
+	max=0;
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		int clNum=0;
+		int temp=0;
+		toggle(this->fVars[i]);
+
+		this->evalFormulaQ(i,clNum);	//this->evalFormula(clNum);
+		toggle(this->fVars[i]);
+		this->evalFormulaQ(i,temp);
+
+		this->evalArray[i]=clNum;
+		if (clNum>max) max=clNum;
+		if (clNum<min) min=clNum;
+
+	}
+}
+
+std::vector<int> CFormula::evalUnsatClause(int clIndex,int&min,int&max)
+{
+	min=std::numeric_limits<int>::max();
+	max=0;
+
+	Clause cl=this->cFormula[clIndex];
+	std::vector<int> evalArray;
+
+	for (unsigned int i=0;i<cl.size();i++)
+	{
+		Literal lit=cl[i];
+		int index=abs(lit);
+
+		int clNum=0;
+		int temp=0;
+
+		// -- evaluate the positive clauses
+		toggle(this->fVars[index]);
+		this->evalFormulaQ(index,clNum);	//this->evalFormula(clNum);
+		toggle(this->fVars[index]);
+		this->evalFormulaQ(index,temp);
+		// --
+
+		evalArray.push_back(clNum);
+		if (clNum>max) max=clNum;
+		if (clNum<min) min=clNum;
+
+	}
+
+	return evalArray;
+}
+
+int CFormula::getBestChoice(bool retFirst)
+{
+	int min,max;
+	this->evalMove(min,max);
+	int bestCount=0;
+	std::vector<int> bestArray;
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		if (this->evalArray[i]==max)
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			bestArray.push_back(i);
+			bestCount++;
+		}
+	}
+
+	if (bestCount==1)
+		return bestArray[0];
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*bestCount);
+	return bestArray[rndIndex];
+
+}
+
+
+int CFormula::walkSatChoice(bool retFirst)
+{
+
+	// -- Randomly get one unsatisfied clause
+	int clIndex=this->getUnsatClause(retFirst);
+
+	int min,max;
+
+	// -- List the best choices
+	std::vector<int> evalArray=evalUnsatClause( clIndex,min,max);
+
+	// -- select randomly from the best choices
+	int bestCount=0;
+	std::vector<int> bestArray;
+
+	for (unsigned int i=0;i<evalArray.size();i++)
+	{
+		if (evalArray[i]==max)
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			bestArray.push_back(i);
+			bestCount++;
+		}
+	}
+
+	if (bestCount==1)
+		return abs(this->cFormula[clIndex].at(bestArray[0]));
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*bestCount);
+
+	return abs(this->cFormula[clIndex].at(bestArray[rndIndex]));
+}
+
+int CFormula::getUnsatClause(bool retFirst)
+{
+
+	int clCount=0;
+	std::vector<int> clArray;
+
+	for (unsigned int i=0;i<this->nClauses;i++)
+	{
+		if (!this->evalClause[i])
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			clArray.push_back(i);
+			clCount++;
+		}
+	}
+
+	if (clCount==1)
+		return clArray[0];
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*clCount);
+	return clArray[rndIndex];
+
+}
+
+int CFormula::getRndBest(bool exponential)
+{
+	int min,max;
+	float cum=0;
+	this->evalMove(min,max);
+	float normalizer=0;
+
+	// -- calculate the discrete probability distribution --
+	float  probs[this->nVars];
+	float rnd =rndReal(rndEngine);
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+
+		probs[i]=(float)(this->evalArray[i]-min+DEFAULT_BIAS);
+
+		if (exponential)probs[i]=exp(probs[i]);
+		normalizer+=probs[i];
+	}
+
+	// -- sample from the distribution --
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		cum+=probs[i]/normalizer;
+
+		if (cum>rnd)
+			return i;
+
+	}
+
+	return 0;
+}
+
+
+
+

MPI/GSAT/CFormula.hpp

@@ -0,0 +1,140 @@
+/*
+ * CFormula.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ */
+
+#ifndef CFORMULA_HPP_
+#define CFORMULA_HPP_
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include "FillMethod.hpp"
+#include "ArrayFiller.hpp"
+#include "HeuristicMethod.hpp"
+
+using namespace std;
+
+
+typedef int Literal;
+typedef std::vector<Literal> Clause;
+typedef std::vector<Clause> Formulae;
+
+
+
+#define COMMENT_FLAG 'c'
+#define PROBLEM_FLAG 'p'
+#define END_FLAG '%'
+#define toggle(x) (x=x^1)
+#define DEFAULT_BIAS 1
+#define DEFAULT_ITERATIONS 1000
+#define DEFAULT_MAX_TRY 255
+#define DEFAULT_GREEDY_FACTOR 0.8
+#define DEFAULT_GW_FACTOR 0.5
+
+class CFormula
+{
+public :
+	string fType;			// -- formula type (in this case should be 'cnf')
+	string fComments;		// -- formula comments
+	unsigned int nVars;		// -- number of variables
+	unsigned int nClauses;	// -- number of clauses
+	struct
+	{
+		unsigned int nPosLits;		// -- number of positive literals
+		unsigned int nNegLits;		// -- number of negative literals
+		unsigned int nLits;			// -- total literls
+	}fStats;
+
+public :
+  bool * fVars;				// -- formula variables
+  float * fPortions;			// -- variables' proportions
+  float tPortion;				// -- total positive to negative literal proportion
+  int * nLit	;				// -- total occurrence of specific literal in formula
+  int * evalArray;			// -- flip evaluation array
+  bool * evalClause;		    // -- evaluation of clauses  // ADDED
+  std::vector<int>* varMap;	// -- mapping between variables and clauses //ADDED
+  unsigned int clCounter;		// -- clause counter variable
+  float greedyFactor;			// -- GSAT greedy factor
+  float gwFactor;				// -- GSAT or WSAT select probability
+
+  Formulae cFormula;				// -- canonical formula jagged array(vector)
+  ArrayFiller* arrayFiller;		//-- array filler class
+  std::default_random_engine rndEngine;
+  std::uniform_real_distribution<float> rndReal;	// -- sampling from real uniform  distribution
+  std::uniform_int_distribution<int> rndMethod;   // -- sampling from int uniform  distribution
+  std::uniform_int_distribution<int> rndHeuristic;// -- sampling from int uniform  distribution
+  unsigned int nbSatisfiedClausesFill;
+  unsigned int nbSatisfiedClausesSolve;
+  unsigned int lastFillMethod;
+  unsigned int lastHeuristic;
+  unsigned int ite;
+  
+public:
+  CFormula();
+  
+  bool initFormula(const char* filename);
+
+  bool evalFormulaQ(unsigned int varIndex,int& clNum);	// -- faster version of evalFormula (just check the modified clauses)
+
+  bool evalFormula(int& clNum);
+
+  bool startGSAT(int iterations=DEFAULT_ITERATIONS,int maxTry=DEFAULT_MAX_TRY,int fillMethod=-1,int hMethod=-1);
+
+  void setGreedyFactor(float factor);
+
+  void setGWFactor(float factor);
+
+  inline unsigned int getNbClauses(){return nClauses;}
+  inline unsigned int getNbVariables(){return nVars;}
+
+  inline unsigned int getNbSatisfiedClausesFill(){return nbSatisfiedClausesFill;}
+  inline unsigned int getNbSatisfiedClausesSolve(){return nbSatisfiedClausesSolve;}
+  
+  inline unsigned int getHeuristicFill(){return lastFillMethod;}
+  inline unsigned int getHeuristicSolve(){return lastHeuristic;}
+  inline unsigned int getNbIterations(){return ite;}
+
+  
+private:
+	std::vector<string> tokenize(char*input,const char*split);
+
+	Clause parseClause(char*input,const char*split);
+
+	// -- randomly select the filler method --
+	FillMethod getRandomMethod();
+
+	// -- randomly select the heuristic method --
+	HeuristicMethod getRandomHeuristic();
+
+	// -- If GSAT should take a best action
+	bool takeBestChoice();
+
+	bool takeGW();
+
+	void evalMove(int&min,int&max);
+
+	std::vector<int> evalUnsatClause(int clIndex,int&min,int&max);
+
+	int getBestChoice(bool retFirst=false);
+
+	int walkSatChoice(bool retFirst=false);
+
+	int getUnsatClause(bool retFirst=false);
+
+	int getRndBest(bool exponential=true);	// -- randomly select the choice according to each move's reward
+
+
+};
+
+
+#endif /* CFORMULA_HPP_ */

MPI/GSAT/FillMethod.hpp

@@ -0,0 +1,28 @@
+/*
+ * FillMethod.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The methods for filling 1-D boolean array
+ */
+
+#ifndef FILLMETHOD_HPP_
+#define FILLMETHOD_HPP_
+
+
+enum FillMethod
+{
+	ZEROS_FILL,
+	ONES_FILL,
+	UNIFORM_FILL,
+	STEP_FILL,
+	PORTION_FILL,
+	PORTION_EL_FILL
+};
+
+#define METHOD_COUNT 6
+#define FIRST_FILL_METHOD 	UNIFORM_FILL
+#define LAST_FILL_METHOD 	PORTION_EL_FILL
+#define UNIFORM_RATIO	0.5
+
+#endif /* FILLMETHOD_HPP_ */

MPI/GSAT/GSAT.cpp

@@ -0,0 +1,144 @@
+//============================================================================
+// Name        : GSAT.cpp
+// Author      : Sina M.Baharlou
+// Version     : 1
+// Description : GSAT Solver
+//============================================================================
+
+
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include <sys/time.h>
+
+#include "GSAT.hpp"
+
+using namespace std;
+
+#include <algorithm>
+
+
+char* getCmdOption(char ** begin, char ** end, const std::string & option)
+{
+	char ** itr = std::find(begin, end, option);
+	if (itr != end && ++itr != end)
+	{
+		return *itr;
+	}
+	return 0;
+}
+
+bool cmdOptionExists(char** begin, char** end, const std::string& option)
+{
+	return std::find(begin, end, option) != end;
+}
+
+
+
+void printHelp()
+{
+	const char *help = "\n\n// --  GSAT simple solver -- // \n"
+			"// --  By Sina M.Baharlou -- // \n"
+			"// --  Oct  2016 \n\n"
+			"GSAT -i [input_file] <options> \n"
+			"Available options are : \n"
+			"\t--iterations [number of iterations] \n"
+			"\t--flip_max [number of maximum flips per iterations]\n"
+			"\t--greedy_factor [greedy factor] \n"
+			"\t--gw_factor [gsat/wsat factor] \n"
+			"\t--heuristic [heuristic_method]\n"
+			"\t\t-1- randomly select the heuristic method\n"
+			"\t\t 0- select the first best choice\n"
+			"\t\t 1- select randomly among the best choices\n"
+			"\t\t 2- select according to the cost distribution\n"
+			"\t\t 3- select randomly among all the choices\n"
+			"\t\t 4- combination of 1 and 2 according to the greedy factor\n"
+			"\t\t 5- WALKSAT\n"
+			"\t\t 6- randomly select between GSAT or WALKSAT\n"
+			"\t--rnd_method [rnd_method] \n"
+			"\t\t-1-randomly select the method\n"
+			"\t\t0-fill with zeros\n"
+			"\t\t1-fill with ones\n"
+			"\t\t2-fill uniformly\n"
+			"\t\t3-STEP method\n"
+			"\t\t4-PORTION method\n"
+			"\t\t5-PORTION_EL method\n";
+
+
+	printf("%s",help);
+}
+
+void GSAT::initialize(){
+  formula=new CFormula();
+  formula->initFormula(options->filename);
+  formula->setGreedyFactor(options->greedyFactor);
+  formula->setGWFactor(options->gwFactor);
+}
+
+bool GSAT::start(int fill,int heuristic){
+  return formula->startGSAT(1,options->maxTry,fill,heuristic);
+}
+
+Options* GSAT::setParameters(int argc,char* argv[]){
+  options = new Options();
+  // -- default variables --
+  options->iterations=DEFAULT_ITERATIONS;
+  options->maxTry=DEFAULT_MAX_TRY;
+  options->greedyFactor=DEFAULT_GREEDY_FACTOR;
+  options->gwFactor=DEFAULT_GW_FACTOR;
+  options->rndMethod=DEFAULT_RND_METHOD;
+  options->hMethod=DEFAULT_H_METHOD;
+  // --
+
+
+  if (argc<2)
+    {
+      printHelp();
+      exit(0);
+    }
+
+  if (!cmdOptionExists(argv, argv+argc, "-i"))
+    {
+      printHelp();
+      printf("STD Error : no input file has been provided.\n\n");
+      exit(0);
+    }
+
+  options->filename = getCmdOption(argv, argv + argc, "-i");
+
+  if (options->filename==NULL)
+    {
+      printf("STD Error : not input file has been provided.\n\n");
+      exit(0);
+    }
+
+  if (cmdOptionExists(argv, argv+argc, "--iterations"))
+    options->iterations=stoi(getCmdOption(argv, argv + argc, "--iterations"));
+
+
+
+  if (cmdOptionExists(argv, argv+argc, "--flip_max"))
+    options->maxTry=stoi(getCmdOption(argv, argv + argc, "--flip_max"));
+
+
+  if (cmdOptionExists(argv, argv+argc, "--greedy_factor"))
+    options->greedyFactor=stof(getCmdOption(argv, argv + argc, "--greedy_factor"));
+
+  if (cmdOptionExists(argv, argv+argc, "--gw_factor"))
+    options->gwFactor=stof(getCmdOption(argv, argv + argc, "--gw_factor"));
+
+  if (cmdOptionExists(argv, argv+argc, "--rnd_method"))
+    options->rndMethod=stoi(getCmdOption(argv, argv + argc, "--rnd_method"));
+
+  if (cmdOptionExists(argv, argv+argc, "--heuristic"))
+    options->hMethod=stoi(getCmdOption(argv, argv + argc, "--heuristic"));
+  return options;
+}

MPI/GSAT/GSAT.hpp

@@ -0,0 +1,71 @@
+
+#ifndef GSAT_HPP_
+#define GSAT_HPP_
+
+
+#include "FillMethod.hpp"
+#include "ArrayFiller.hpp"
+#include "CFormula.hpp"
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <string> 
+#include <fstream>
+#include <random>
+#include <math.h>
+#include <sys/time.h>
+
+#define DEFAULT_ITERATIONS 1000
+#define DEFAULT_MAX_TRY 255
+#define DEFAULT_GREEDY_FACTOR 0.8
+#define DEFAULT_GW_FACTOR 0.5
+#define DEFAULT_RND_METHOD -1
+#define DEFAULT_H_METHOD -1
+
+class Options{
+public:
+  int iterations;
+  int maxTry;
+  float greedyFactor;
+  float gwFactor;
+  int rndMethod;
+  int hMethod;
+  char* filename;
+};
+
+char* getCmdOption(char ** begin, char ** end, const std::string & option);
+bool cmdOptionExists(char** begin, char** end, const std::string& option);
+void printHelp();
+
+class GSAT{
+public:
+  CFormula* formula;
+  Options* options;
+
+  Options* setParameters(int argc,char* argv[]);
+  void initialize();
+  bool start(int fill=DEFAULT_RND_METHOD,int heuristic=DEFAULT_H_METHOD);
+  inline double realTime() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (double)tv.tv_sec + (double) tv.tv_usec / 1000000;
+  }
+
+  inline unsigned int getNbClauses(){return formula->getNbClauses();}
+  inline unsigned int getNbVariables(){return formula->getNbVariables();}
+
+  inline unsigned int getNbSatisfiedClausesFill(){return formula->getNbSatisfiedClausesFill();}
+  inline unsigned int getNbSatisfiedClausesSolve(){return formula->getNbSatisfiedClausesSolve();}
+  
+  inline unsigned int getHeuristicFill(){return formula->getHeuristicFill();}
+  inline unsigned int getHeuristicSolve(){return formula->getHeuristicSolve();}
+  inline unsigned int getNbIterations(){return formula->getNbIterations();}
+};
+
+
+
+#endif

MPI/GSAT/HeuristicMethod.hpp

@@ -0,0 +1,30 @@
+/*
+ * HeuristicMethod.hpp
+ *
+ *  Created on: Oct 3, 2016
+ *      Author: sina
+ */
+
+#ifndef HEURISTICMETHOD_HPP_
+#define HEURISTICMETHOD_HPP_
+
+
+enum HeuristicMethod
+{
+	FIRST_BEST,
+	RND_BEST,
+	RND_DIST,
+	RND,
+	RND_GREEDY,
+	WALK_SAT,
+	GSAT_WSAT,
+
+};
+
+#define FIRST_H_METHOD 	FIRST_BEST
+#define LAST_H_METHOD 	GSAT_WSAT
+
+
+
+
+#endif /* HEURISTICMETHOD_HPP_ */

MPI/Main.cpp

@@ -0,0 +1,92 @@
+#include "GSAT/GSAT.hpp"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <mpi.h>
+#include "color.h"
+
+using namespace std;
+
+void help(char* prog) {
+    fprintf(stderr, "usage: %s -i file.cnf\n", prog);
+    exit(1);
+}
+
+int main(int argc, char* argv[]) {
+
+    if(argc < 3) {
+        help(argv[0]);
+    }
+
+    //Init MPI
+    int world_size;
+    int world_rank;
+    MPI_Init(NULL, NULL);
+    MPI_Comm_size(MPI_COMM_WORLD, &world_size);
+    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
+
+    GSAT* gsat = new GSAT();
+    gsat->setParameters(argc,argv);
+    gsat->initialize();
+    if(world_rank == 0) {
+        printf("c nbProcessors: %d\n", world_size);
+        printf("c nbVariables: %d\n",gsat->getNbVariables());
+        printf("c nbClauses: %d\n",gsat->getNbClauses());
+    }
+    double startTime = gsat->realTime();
+    srand(getpid());
+      
+    bool end = false;
+    bool stop = false;
+    while(!end && !stop){
+        //Pour eviter que les processeurs effectue tous les meme calculs
+        int fill = rand() % 4 + 2;
+        int h = rand() % 7;
+        end = gsat->start(fill, h);
+        //Affiche calcul
+        if(end) {
+            printf(CYAN);
+        }
+        printf("c [processor:%d][iteration:%5d][file:%d][heuristic:%d]Satisfied clauses (begin: %d)(end:%d)\n",
+            world_rank,
+            gsat->getNbIterations(),
+            gsat->getHeuristicFill(),
+            gsat->getHeuristicSolve(),
+            gsat->getNbSatisfiedClausesFill(),
+            gsat->getNbSatisfiedClausesSolve());
+        if(end) {
+            printf(RESET);
+        }
+        //Regarde si quelqu'un a trouver
+        for(int i = 0; i < world_size; i++){
+            int buff;
+            if(i == world_rank) {
+                buff = end ? 1 : 0;
+            }
+            MPI_Bcast(&buff, 1, MPI_INT, i, MPI_COMM_WORLD);
+            if(i != world_rank && buff && !stop) {
+                stop = true;
+            }
+        }
+    }
+
+    if(end) {
+        printf("--------------------------------------------------------------------------------------------\n");
+        printf(GREEN);
+        printf("s %s\n",end?"SATISFIABLE":"NOT FOUND");
+        printf(YELLOW);
+        printf("c real time : %.4f seconds\n", gsat->realTime() - startTime);
+        printf("c [processor:%d][iteration:%5d][file:%d][heuristic:%d]Satisfied clauses (begin: %d)(end:%d)\n",
+            world_rank,
+            gsat->getNbIterations(),
+            gsat->getHeuristicFill(),
+            gsat->getHeuristicSolve(),
+            gsat->getNbSatisfiedClausesFill(),
+            gsat->getNbSatisfiedClausesSolve());
+        printf(RESET);
+    }
+
+    MPI_Finalize();    
+
+}

MPI/Makefile

@@ -0,0 +1,22 @@
+FLAGS = -std=c++0x -O2 -g -Wall -fmessage-length=0 -Wreorder -Wwrite-strings -Wsign-compare
+
+EXEC = Main
+
+OBJS = GSAT/GSAT.o GSAT/ArrayFiller.o GSAT/CFormula.o
+
+LIBS = 
+
+TARGET = GSATSolver
+
+$(TARGET):	$(OBJS)
+	mpic++ -o $(TARGET) $(EXEC).cpp $(FLAGS) $(OBJS) $(LIBS)
+
+all: $(TARGET)
+
+clean:
+	rm -f $(OBJS) $(TARGET)
+	rm -rf *.*~
+	rm -rf *~
+
+run: 
+	@mpirun -n 4 ./GSATSolver -i ../benchmarks/uf150/uf150-099.cnf

MPI/README.txt

@@ -0,0 +1,3 @@
+
+make -j
+./GSAT -i ../benchmarks/uf150/uf150-099.cnf

MPI/color.h

@@ -0,0 +1,7 @@
+#define RED     "\x1b[31m"
+#define GREEN   "\x1b[32m"
+#define YELLOW  "\x1b[33m"
+#define BLUE    "\x1b[34m"
+#define MAGENTA "\x1b[35m"
+#define CYAN    "\x1b[36m"
+#define RESET   "\x1b[0m"

Part_2/GSAT/ArrayFiller.cpp

@@ -0,0 +1,120 @@
+/*
+ * ArrayFiller.cpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The class for filling 1-D boolean array
+ */
+
+
+#include "ArrayFiller.hpp"
+
+ArrayFiller::ArrayFiller(bool* bArray,unsigned int arrSize):
+arrSize(arrSize),
+stepSize(DEFAULT_STEP_SIZE),
+currStep(DEFAULT_CURR_STEP),
+tRate(0),
+pArray(NULL)
+{
+
+	// -- Initialize boolean array if it has not been initialized
+
+	if (bArray==NULL)
+		this->bArray=new bool[arrSize];
+	else
+		this->bArray=bArray;
+
+	// -- Initializing sampling distribution --
+
+	this->rndReal=std::uniform_real_distribution<float>(0.0,1.0);
+
+	// -- Init random engine --
+
+	struct timespec ts;
+	unsigned theTick = 0U;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	theTick  = ts.tv_nsec / 1000000;
+	theTick += ts.tv_sec * 1000;
+	this->rndEngine.seed(theTick);
+}
+
+
+bool* ArrayFiller::getArray()
+{
+	return this->bArray;
+}
+
+void ArrayFiller::setPortionArray(float* pArray)
+{
+	this->pArray=pArray;
+}
+
+void ArrayFiller::setPortionRate(float rate)
+{
+	this->tRate=rate;
+}
+
+
+bool* ArrayFiller::fillArray(FillMethod method)
+{
+
+
+	switch (method)
+	{
+
+	case ZEROS_FILL:	// -- fills with zeros (false)
+		memset(this->bArray,0,this->arrSize*sizeof(bool));
+		break;
+
+	case ONES_FILL: // -- fills with ones (true)
+		memset(this->bArray,1,this->arrSize*sizeof(bool));
+		break;
+
+	case UNIFORM_FILL: // -- uniformly fills with zeros and ones
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd<UNIFORM_RATIO);
+		}
+		break;
+
+	case STEP_FILL:	// -- fills with step method
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->currStep);
+		}
+
+		this->currStep+=this->stepSize; // -- increase the step size ( probability of having true value)
+		if (this->currStep>1) this->currStep=0;
+		break;
+
+	case PORTION_FILL: // -- fills proportionally
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->tRate);
+		}
+		break;
+
+	case PORTION_EL_FILL: // -- fills each element proportionally
+
+		if (this->pArray==NULL)
+			break;
+
+
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->pArray[i]);
+		}
+		break;
+
+	}
+
+	return this->bArray;
+
+}
+
+
+

Part_2/GSAT/ArrayFiller.hpp

@@ -0,0 +1,61 @@
+/*
+ * ArrayFiller.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The class for filling 1-D boolean array
+ */
+
+#ifndef ARRAYFILLER_HPP_
+#define ARRAYFILLER_HPP_
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include "FillMethod.hpp"
+
+#define DEFAULT_STEP_SIZE	0.05
+#define DEFAULT_CURR_STEP	0.05
+
+using namespace std;
+
+class ArrayFiller
+{
+private :
+	bool *bArray ;					// -- pointer to the boolean array
+	unsigned int arrSize;			// -- array size
+	float stepSize;					// -- STEP_FILL, step size
+	float currStep;					// -- STEP_FILL, current step
+	float tRate;					// -- PORTION_FILL, true-rate
+	float* pArray;					// -- PORTION_EL_FILL array
+
+	std::uniform_real_distribution<float> rndReal;	// -- sampling from real uniform  distribution
+	std::default_random_engine rndEngine;			// -- sampling engine
+
+
+public:
+
+	// -- Vector Filler constructor
+	ArrayFiller(bool* bArray,unsigned int arrSize);
+
+	// -- property methods --
+	bool* getArray();
+
+	void setPortionArray(float* pArray);
+
+	void setPortionRate(float rate);
+
+	// -- Fill array randomly with the given method --
+	bool* fillArray(FillMethod method);
+
+};
+
+
+#endif /* ARRAYFILLER_HPP_ */

Part_2/GSAT/CFormula.cpp

@@ -0,0 +1,675 @@
+/*
+ * CFormula.cpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ */
+
+#include "CFormula.hpp"
+
+CFormula::CFormula():
+nVars(0),
+nClauses(0),
+fStats{0,0,0},
+fVars(NULL),
+fPortions(NULL),
+tPortion(0),
+nLit(NULL),
+evalArray(NULL),
+
+evalClause(NULL),
+varMap(NULL),
+
+clCounter(0),
+
+greedyFactor(DEFAULT_GREEDY_FACTOR),
+arrayFiller(NULL),
+nbSatisfiedClausesFill(0),
+nbSatisfiedClausesSolve(0),
+lastFillMethod(0),
+lastHeuristic(0),
+ite(0)
+{
+
+	this->fType.clear();
+	this->fComments.clear();
+
+	// -- Initializing distribution variables --
+
+	rndReal=std::uniform_real_distribution<float>(0.0,1.0);
+	rndMethod=std::uniform_int_distribution<int>(FIRST_FILL_METHOD,LAST_FILL_METHOD);
+	rndHeuristic=std::uniform_int_distribution<int>(FIRST_H_METHOD,LAST_H_METHOD);
+
+	// -- Init random engine --
+
+	struct timespec ts;
+	unsigned theTick = 0U;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	theTick  = ts.tv_nsec / 1000000;
+	theTick += ts.tv_sec * 1000;
+	rndEngine.seed(theTick);
+}
+
+
+
+
+bool CFormula::initFormula(const char* filename)
+{
+
+	// -- Initialize variables --
+
+	this->cFormula.empty();
+	this->fComments.empty();
+	this->fType.empty();
+	this->fStats={0,0,0};
+	this->clCounter=0;
+	bool fReached=false;
+
+
+	// -- Free previously allocated variables --
+
+	if (this->fVars) free(this->fVars);
+	if (this->fPortions) free(this->fPortions);
+	if (this->nLit) free(this->nLit);
+	if (this->evalArray) free(this->evalArray);
+	if (this->arrayFiller) free(this->arrayFiller);
+	if (this->varMap) free(this->varMap);
+	if (this->evalClause) free(this->evalClause);
+
+	// -- Open input file --
+
+	ifstream input_file;
+	input_file.open(filename);
+
+	if (!input_file.is_open())
+	{
+		printf("STD Error: cannot open '%s'.",filename);
+		return false;
+	}
+
+
+	// -- Parse the provided file --
+
+	std::string line;
+	while (std::getline(input_file, line))
+	{
+		// -- get the flag (can be 'c' or 'p') --
+		char flag=line[0];
+		std::vector<string> tokens;
+
+		switch (flag)
+		{
+
+		case COMMENT_FLAG:	// -- Comment line has reached --
+
+			// -- Add to comment string --
+			this->fComments.append(&line[1]);
+			this->fComments.append("\n");
+			break;
+
+
+		case PROBLEM_FLAG:	// -- Problem line has reached --
+
+			// -- Tokenize current line --
+			tokens.empty();
+			tokens=tokenize(&line[1]," ");
+
+			// -- Check if the syntax if correct in order to parse the parameters --
+			if (tokens.size()<3)
+			{
+				printf("There is a syntax error in the problem definition.");
+				return false;
+			}
+
+			// -- Assign the variables --
+			this->fType=tokens[0];
+			this->nVars=stoi(tokens[1])+1;		// -- starts from 1
+			this->nClauses=stoi(tokens[2]);
+			fReached=true;
+
+			// -- allocate the arrays
+			this->fVars=new bool[this->nVars];
+			this->fPortions= new float[this->nVars];
+			this->nLit=new int[this->nVars];
+			this->evalArray=new int[this->nVars];
+			this->evalClause=new bool[this->nClauses];
+			this->varMap=new std::vector<int>[this->nVars];
+
+			// -- initialize the arrays
+			memset(this->fVars,0,this->nVars*sizeof(bool));
+			memset(this->fPortions,0,this->nVars*sizeof(float));
+			memset(this->nLit,0,this->nVars*sizeof(int));
+			memset(this->evalArray,0,this->nVars*sizeof(int));
+			memset(this->evalClause,0,this->nClauses*sizeof(bool));
+
+			// -- Instantiate the arrayFiller class
+			this->arrayFiller=new ArrayFiller(this->fVars,this->nVars);
+
+			break;
+
+
+		case END_FLAG: // -- End of the formula has reached --
+			input_file.close();
+
+			// -- Ppdate stats --
+			this->tPortion=(float)this->fStats.nPosLits/this->fStats.nLits;
+			for (unsigned int i=1;i<this->nVars;i++)
+				this->fPortions[i]/=(float)this->nLit[i];
+
+			// -- Init random filler --
+			this->arrayFiller->setPortionRate(this->tPortion);
+			this->arrayFiller->setPortionArray(this->fPortions);
+			this->arrayFiller->fillArray(PORTION_EL_FILL);
+			return true;
+			break;
+
+		default:	// -- Clause line has reached--
+			if (!fReached)
+				continue;
+			this->cFormula.push_back(parseClause(&line[0]," "));
+			break;
+		}
+
+	}
+
+	return true;
+}
+
+
+
+
+bool CFormula::evalFormulaQ(unsigned int varIndex,int& clNum)
+{
+
+	bool fEval=true;
+	clNum=0;
+
+	// -- check through the modified clauses --
+	for (unsigned int i=0;i<this->varMap[varIndex].size();i++)
+	{
+		// -- get the clause --
+		int cIndex=this->varMap[varIndex].at(i);
+		Clause cl=this->cFormula[cIndex];
+
+		// -- for each literal
+		for (unsigned int j=0;j<cl.size();j++)
+		{
+
+			Literal lit=cl[j];
+
+			// -- get the index and sign
+			bool neg=(lit<0);
+			int index=abs(lit);
+			// -- evaluate the literal
+			bool litEval=neg^this->fVars[index];
+			this->evalClause[cIndex]=litEval; // -- update clause truth list
+
+			// -- if positive -> clause will be evaluated as positive
+			if (litEval)
+				break;
+
+		}
+
+	}
+
+
+	// -- evaluate the whole formula --
+
+	for (unsigned int i=0;i<this->cFormula.size();i++)
+	{
+		bool evalClause=this->evalClause[i];
+		fEval&=evalClause;
+		if (evalClause)clNum++;
+	}
+	return fEval;
+}
+
+
+bool CFormula::evalFormula(int& clNum)
+{
+
+
+	bool fEval=true;
+	clNum=0;
+
+
+	for (unsigned int i=0;i<this->cFormula.size();i++)
+	{
+
+		// -- get the clause --
+		Clause cl=this->cFormula[i];
+		bool clEval=false;
+
+		// -- for each literal
+		for (unsigned int j=0;j<cl.size();j++)
+		{
+
+			Literal lit=cl[j];
+
+			// -- get the index and sign
+			bool neg=(lit<0);
+			int index=abs(lit);
+			// -- evaluate the literal
+			bool litEval=neg^this->fVars[index];
+
+			this->evalClause[i]=litEval;
+
+			// -- if positive -> clause will be evaluated as positive
+			if (litEval)
+			{
+				clEval=true;
+				clNum++;
+				break;
+			}
+		}
+
+		// -- and it with current evaluation of formula
+		fEval&=clEval;
+
+	}
+
+	return fEval;
+}
+
+
+
+bool CFormula::startGSAT(int iterations,int maxTry,int fillMethod,int hMethod)
+{
+	float initGuessMean=0;	// -- initial guess average
+	float negClauseMean=0;	// -- average number of negative clauses
+	float elaborateMean=0; 	// -- averate number of elaboration
+	bool fEval=false;
+	int i;
+
+	for (i=0;i<iterations;i++)
+	{
+		int initGuess=0;
+		int clNum=0;
+		fEval=false;
+
+		// -- randomly select the filler method --
+		FillMethod fMethod;
+		if (fillMethod==-1)
+			fMethod=getRandomMethod();
+		else
+			fMethod=(FillMethod)fillMethod;
+		lastFillMethod=fMethod;
+		ite++;
+		// -- randomly select the heuristic method --
+		HeuristicMethod heuristic;
+		if (hMethod==-1)
+			heuristic=getRandomHeuristic();
+		else
+			heuristic=(HeuristicMethod)hMethod;
+		lastHeuristic=heuristic;
+		
+		this->arrayFiller->fillArray(fMethod);
+
+		// -- evaluate the function
+		fEval=this->evalFormula(clNum);
+		initGuess=clNum;
+		nbSatisfiedClausesFill=initGuess;
+		initGuessMean+=initGuess;
+
+		// -- return if already found the solution
+		if (fEval)
+			break;
+
+
+		for (int j=0;j<maxTry;j++)
+		{
+			int choice=0;
+
+
+			// -- select the choice with the given heuristics --
+
+			switch (heuristic)
+			{
+
+			case FIRST_BEST:
+				choice=this->getBestChoice(true);
+				break;
+
+			case RND_BEST:
+				choice=this->getBestChoice();
+				break;
+
+			case RND_DIST:
+				choice=this->getRndBest();
+				break;
+
+			case RND:
+				choice=(int)(rndReal(rndEngine)*this->nVars);
+				break;
+
+			case RND_GREEDY:
+				if (this->takeBestChoice())
+					choice=this->getBestChoice();
+				else
+					choice=this->getRndBest();
+				break;
+
+			case WALK_SAT:
+				choice=this->walkSatChoice();
+				break;
+
+			case GSAT_WSAT:
+				if (this->takeGW())
+					choice=this->getBestChoice();
+				else
+					choice=this->walkSatChoice();
+				break;
+
+			}
+
+
+			toggle(this->fVars[choice]);
+			fEval=this->evalFormulaQ(choice,clNum);//this->evalFormula(clNum);
+
+			if (fEval)
+				break;
+
+
+		}
+
+
+		negClauseMean+=this->nClauses-clNum;
+		elaborateMean+=clNum-initGuess;
+		nbSatisfiedClausesSolve=clNum;
+
+		//printf("[iteration %d, fill :%d, heuristic :%d] - init Guess :%d - final Guess :%d - model found :%d\n",i,fMethod,heuristic,initGuess,clNum,fEval);
+
+		if (fEval)
+			break;
+	}
+
+
+	/*printf("Elaborate mean :%f\n",elaborateMean/(float)i);
+	printf("Initial guess mean :%f\n",initGuessMean/(float)i);
+	printf("Neg clause mean :%f\n",negClauseMean/(float)i);*/
+
+
+
+	return fEval;
+
+}
+
+
+void CFormula::setGreedyFactor(float factor)
+{
+	this->greedyFactor=factor;
+}
+
+void CFormula::setGWFactor(float factor)
+{
+	this->gwFactor=factor;
+}
+
+std::vector<string> CFormula::tokenize(char*input,const char*split)
+{
+	char * token;
+	std::vector<string> token_vec;
+
+	token = strtok (input,split);
+	while (token != NULL)
+	{
+		token_vec.push_back(string(token));
+		token = strtok (NULL, " ");
+	}
+	return token_vec;
+}
+
+Clause CFormula::parseClause(char*input,const char*split)
+{
+	char * token;
+	Clause cl;
+
+	token = strtok (input,split);
+	while (token != NULL)
+	{
+		Literal lit=stoi(token);
+		if (lit!=0)
+		{
+			int index=abs(lit);
+			// -- update the stats
+
+			this->varMap[index].push_back(clCounter);
+
+			if (lit>0)
+			{
+				this->fStats.nPosLits++;
+				this->fPortions[index]+=1;
+			}
+			else this->fStats.nNegLits++;
+			fStats.nLits++;
+			this->nLit[index]++;
+			// --
+
+			cl.push_back(lit);
+		}
+		token = strtok (NULL, " ");
+	}
+
+	this->clCounter++;
+
+	return cl;
+}
+
+
+
+
+FillMethod CFormula::getRandomMethod()
+{
+	return (FillMethod)rndMethod(rndEngine);
+}
+
+
+HeuristicMethod CFormula::getRandomHeuristic()
+{
+	return (HeuristicMethod)rndHeuristic(rndEngine);
+}
+
+
+
+bool CFormula::takeBestChoice()
+{
+
+	double random=rndReal(rndEngine);	// -- Get a double random number between 0 and 1
+
+	// -- Check if GSAT should take a best action
+	if (random<=this->greedyFactor)
+		return true;
+	return false;
+}
+
+bool CFormula::takeGW()
+{
+
+	double random=rndReal(rndEngine);	// -- Get a double random number between 0 and 1
+
+	// -- Check if GSAT should take a best action
+	if (random<=this->gwFactor)
+		return true;
+	return false;
+}
+
+
+void CFormula::evalMove(int&min,int&max)
+{
+	min=std::numeric_limits<int>::max();
+	max=0;
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		int clNum=0;
+		int temp=0;
+		toggle(this->fVars[i]);
+
+		this->evalFormulaQ(i,clNum);	//this->evalFormula(clNum);
+		toggle(this->fVars[i]);
+		this->evalFormulaQ(i,temp);
+
+		this->evalArray[i]=clNum;
+		if (clNum>max) max=clNum;
+		if (clNum<min) min=clNum;
+
+	}
+}
+
+std::vector<int> CFormula::evalUnsatClause(int clIndex,int&min,int&max)
+{
+	min=std::numeric_limits<int>::max();
+	max=0;
+
+	Clause cl=this->cFormula[clIndex];
+	std::vector<int> evalArray;
+
+	for (unsigned int i=0;i<cl.size();i++)
+	{
+		Literal lit=cl[i];
+		int index=abs(lit);
+
+		int clNum=0;
+		int temp=0;
+
+		// -- evaluate the positive clauses
+		toggle(this->fVars[index]);
+		this->evalFormulaQ(index,clNum);	//this->evalFormula(clNum);
+		toggle(this->fVars[index]);
+		this->evalFormulaQ(index,temp);
+		// --
+
+		evalArray.push_back(clNum);
+		if (clNum>max) max=clNum;
+		if (clNum<min) min=clNum;
+
+	}
+
+	return evalArray;
+}
+
+int CFormula::getBestChoice(bool retFirst)
+{
+	int min,max;
+	this->evalMove(min,max);
+	int bestCount=0;
+	std::vector<int> bestArray;
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		if (this->evalArray[i]==max)
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			bestArray.push_back(i);
+			bestCount++;
+		}
+	}
+
+	if (bestCount==1)
+		return bestArray[0];
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*bestCount);
+	return bestArray[rndIndex];
+
+}
+
+
+int CFormula::walkSatChoice(bool retFirst)
+{
+
+	// -- Randomly get one unsatisfied clause
+	int clIndex=this->getUnsatClause(retFirst);
+
+	int min,max;
+
+	// -- List the best choices
+	std::vector<int> evalArray=evalUnsatClause( clIndex,min,max);
+
+	// -- select randomly from the best choices
+	int bestCount=0;
+	std::vector<int> bestArray;
+
+	for (unsigned int i=0;i<evalArray.size();i++)
+	{
+		if (evalArray[i]==max)
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			bestArray.push_back(i);
+			bestCount++;
+		}
+	}
+
+	if (bestCount==1)
+		return abs(this->cFormula[clIndex].at(bestArray[0]));
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*bestCount);
+
+	return abs(this->cFormula[clIndex].at(bestArray[rndIndex]));
+}
+
+int CFormula::getUnsatClause(bool retFirst)
+{
+
+	int clCount=0;
+	std::vector<int> clArray;
+
+	for (unsigned int i=0;i<this->nClauses;i++)
+	{
+		if (!this->evalClause[i])
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			clArray.push_back(i);
+			clCount++;
+		}
+	}
+
+	if (clCount==1)
+		return clArray[0];
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*clCount);
+	return clArray[rndIndex];
+
+}
+
+int CFormula::getRndBest(bool exponential)
+{
+	int min,max;
+	float cum=0;
+	this->evalMove(min,max);
+	float normalizer=0;
+
+	// -- calculate the discrete probability distribution --
+	float  probs[this->nVars];
+	float rnd =rndReal(rndEngine);
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+
+		probs[i]=(float)(this->evalArray[i]-min+DEFAULT_BIAS);
+
+		if (exponential)probs[i]=exp(probs[i]);
+		normalizer+=probs[i];
+	}
+
+	// -- sample from the distribution --
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		cum+=probs[i]/normalizer;
+
+		if (cum>rnd)
+			return i;
+
+	}
+
+	return 0;
+}
+
+
+
+

Part_2/GSAT/CFormula.hpp

@@ -0,0 +1,140 @@
+/*
+ * CFormula.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ */
+
+#ifndef CFORMULA_HPP_
+#define CFORMULA_HPP_
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include "FillMethod.hpp"
+#include "ArrayFiller.hpp"
+#include "HeuristicMethod.hpp"
+
+using namespace std;
+
+
+typedef int Literal;
+typedef std::vector<Literal> Clause;
+typedef std::vector<Clause> Formulae;
+
+
+
+#define COMMENT_FLAG 'c'
+#define PROBLEM_FLAG 'p'
+#define END_FLAG '%'
+#define toggle(x) (x=x^1)
+#define DEFAULT_BIAS 1
+#define DEFAULT_ITERATIONS 1000
+#define DEFAULT_MAX_TRY 255
+#define DEFAULT_GREEDY_FACTOR 0.8
+#define DEFAULT_GW_FACTOR 0.5
+
+class CFormula
+{
+public :
+	string fType;			// -- formula type (in this case should be 'cnf')
+	string fComments;		// -- formula comments
+	unsigned int nVars;		// -- number of variables
+	unsigned int nClauses;	// -- number of clauses
+	struct
+	{
+		unsigned int nPosLits;		// -- number of positive literals
+		unsigned int nNegLits;		// -- number of negative literals
+		unsigned int nLits;			// -- total literls
+	}fStats;
+
+public :
+  bool * fVars;				// -- formula variables
+  float * fPortions;			// -- variables' proportions
+  float tPortion;				// -- total positive to negative literal proportion
+  int * nLit	;				// -- total occurrence of specific literal in formula
+  int * evalArray;			// -- flip evaluation array
+  bool * evalClause;		    // -- evaluation of clauses  // ADDED
+  std::vector<int>* varMap;	// -- mapping between variables and clauses //ADDED
+  unsigned int clCounter;		// -- clause counter variable
+  float greedyFactor;			// -- GSAT greedy factor
+  float gwFactor;				// -- GSAT or WSAT select probability
+
+  Formulae cFormula;				// -- canonical formula jagged array(vector)
+  ArrayFiller* arrayFiller;		//-- array filler class
+  std::default_random_engine rndEngine;
+  std::uniform_real_distribution<float> rndReal;	// -- sampling from real uniform  distribution
+  std::uniform_int_distribution<int> rndMethod;   // -- sampling from int uniform  distribution
+  std::uniform_int_distribution<int> rndHeuristic;// -- sampling from int uniform  distribution
+  unsigned int nbSatisfiedClausesFill;
+  unsigned int nbSatisfiedClausesSolve;
+  unsigned int lastFillMethod;
+  unsigned int lastHeuristic;
+  unsigned int ite;
+  
+public:
+  CFormula();
+  
+  bool initFormula(const char* filename);
+
+  bool evalFormulaQ(unsigned int varIndex,int& clNum);	// -- faster version of evalFormula (just check the modified clauses)
+
+  bool evalFormula(int& clNum);
+
+  bool startGSAT(int iterations=DEFAULT_ITERATIONS,int maxTry=DEFAULT_MAX_TRY,int fillMethod=-1,int hMethod=-1);
+
+  void setGreedyFactor(float factor);
+
+  void setGWFactor(float factor);
+
+  inline unsigned int getNbClauses(){return nClauses;}
+  inline unsigned int getNbVariables(){return nVars;}
+
+  inline unsigned int getNbSatisfiedClausesFill(){return nbSatisfiedClausesFill;}
+  inline unsigned int getNbSatisfiedClausesSolve(){return nbSatisfiedClausesSolve;}
+  
+  inline unsigned int getHeuristicFill(){return lastFillMethod;}
+  inline unsigned int getHeuristicSolve(){return lastHeuristic;}
+  inline unsigned int getNbIterations(){return ite;}
+
+  
+private:
+	std::vector<string> tokenize(char*input,const char*split);
+
+	Clause parseClause(char*input,const char*split);
+
+	// -- randomly select the filler method --
+	FillMethod getRandomMethod();
+
+	// -- randomly select the heuristic method --
+	HeuristicMethod getRandomHeuristic();
+
+	// -- If GSAT should take a best action
+	bool takeBestChoice();
+
+	bool takeGW();
+
+	void evalMove(int&min,int&max);
+
+	std::vector<int> evalUnsatClause(int clIndex,int&min,int&max);
+
+	int getBestChoice(bool retFirst=false);
+
+	int walkSatChoice(bool retFirst=false);
+
+	int getUnsatClause(bool retFirst=false);
+
+	int getRndBest(bool exponential=true);	// -- randomly select the choice according to each move's reward
+
+
+};
+
+
+#endif /* CFORMULA_HPP_ */

Part_2/GSAT/FillMethod.hpp

@@ -0,0 +1,28 @@
+/*
+ * FillMethod.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The methods for filling 1-D boolean array
+ */
+
+#ifndef FILLMETHOD_HPP_
+#define FILLMETHOD_HPP_
+
+
+enum FillMethod
+{
+	ZEROS_FILL,
+	ONES_FILL,
+	UNIFORM_FILL,
+	STEP_FILL,
+	PORTION_FILL,
+	PORTION_EL_FILL
+};
+
+#define METHOD_COUNT 6
+#define FIRST_FILL_METHOD 	UNIFORM_FILL
+#define LAST_FILL_METHOD 	PORTION_EL_FILL
+#define UNIFORM_RATIO	0.5
+
+#endif /* FILLMETHOD_HPP_ */

Part_2/GSAT/GSAT.cpp

@@ -0,0 +1,144 @@
+//============================================================================
+// Name        : GSAT.cpp
+// Author      : Sina M.Baharlou
+// Version     : 1
+// Description : GSAT Solver
+//============================================================================
+
+
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include <sys/time.h>
+
+#include "GSAT.hpp"
+
+using namespace std;
+
+#include <algorithm>
+
+
+char* getCmdOption(char ** begin, char ** end, const std::string & option)
+{
+	char ** itr = std::find(begin, end, option);
+	if (itr != end && ++itr != end)
+	{
+		return *itr;
+	}
+	return 0;
+}
+
+bool cmdOptionExists(char** begin, char** end, const std::string& option)
+{
+	return std::find(begin, end, option) != end;
+}
+
+
+
+void printHelp()
+{
+	const char *help = "\n\n// --  GSAT simple solver -- // \n"
+			"// --  By Sina M.Baharlou -- // \n"
+			"// --  Oct  2016 \n\n"
+			"GSAT -i [input_file] <options> \n"
+			"Available options are : \n"
+			"\t--iterations [number of iterations] \n"
+			"\t--flip_max [number of maximum flips per iterations]\n"
+			"\t--greedy_factor [greedy factor] \n"
+			"\t--gw_factor [gsat/wsat factor] \n"
+			"\t--heuristic [heuristic_method]\n"
+			"\t\t-1- randomly select the heuristic method\n"
+			"\t\t 0- select the first best choice\n"
+			"\t\t 1- select randomly among the best choices\n"
+			"\t\t 2- select according to the cost distribution\n"
+			"\t\t 3- select randomly among all the choices\n"
+			"\t\t 4- combination of 1 and 2 according to the greedy factor\n"
+			"\t\t 5- WALKSAT\n"
+			"\t\t 6- randomly select between GSAT or WALKSAT\n"
+			"\t--rnd_method [rnd_method] \n"
+			"\t\t-1-randomly select the method\n"
+			"\t\t0-fill with zeros\n"
+			"\t\t1-fill with ones\n"
+			"\t\t2-fill uniformly\n"
+			"\t\t3-STEP method\n"
+			"\t\t4-PORTION method\n"
+			"\t\t5-PORTION_EL method\n";
+
+
+	printf("%s",help);
+}
+
+void GSAT::initialize(){
+  formula=new CFormula();
+  formula->initFormula(options->filename);
+  formula->setGreedyFactor(options->greedyFactor);
+  formula->setGWFactor(options->gwFactor);
+}
+
+bool GSAT::start(int fill,int heuristic){
+  return formula->startGSAT(1,options->maxTry,fill,heuristic);
+}
+
+Options* GSAT::setParameters(int argc,char* argv[]){
+  options = new Options();
+  // -- default variables --
+  options->iterations=DEFAULT_ITERATIONS;
+  options->maxTry=DEFAULT_MAX_TRY;
+  options->greedyFactor=DEFAULT_GREEDY_FACTOR;
+  options->gwFactor=DEFAULT_GW_FACTOR;
+  options->rndMethod=DEFAULT_RND_METHOD;
+  options->hMethod=DEFAULT_H_METHOD;
+  // --
+
+
+  if (argc<2)
+    {
+      printHelp();
+      exit(0);
+    }
+
+  if (!cmdOptionExists(argv, argv+argc, "-i"))
+    {
+      printHelp();
+      printf("STD Error : no input file has been provided.\n\n");
+      exit(0);
+    }
+
+  options->filename = getCmdOption(argv, argv + argc, "-i");
+
+  if (options->filename==NULL)
+    {
+      printf("STD Error : not input file has been provided.\n\n");
+      exit(0);
+    }
+
+  if (cmdOptionExists(argv, argv+argc, "--iterations"))
+    options->iterations=stoi(getCmdOption(argv, argv + argc, "--iterations"));
+
+
+
+  if (cmdOptionExists(argv, argv+argc, "--flip_max"))
+    options->maxTry=stoi(getCmdOption(argv, argv + argc, "--flip_max"));
+
+
+  if (cmdOptionExists(argv, argv+argc, "--greedy_factor"))
+    options->greedyFactor=stof(getCmdOption(argv, argv + argc, "--greedy_factor"));
+
+  if (cmdOptionExists(argv, argv+argc, "--gw_factor"))
+    options->gwFactor=stof(getCmdOption(argv, argv + argc, "--gw_factor"));
+
+  if (cmdOptionExists(argv, argv+argc, "--rnd_method"))
+    options->rndMethod=stoi(getCmdOption(argv, argv + argc, "--rnd_method"));
+
+  if (cmdOptionExists(argv, argv+argc, "--heuristic"))
+    options->hMethod=stoi(getCmdOption(argv, argv + argc, "--heuristic"));
+  return options;
+}

Part_2/GSAT/GSAT.hpp

@@ -0,0 +1,71 @@
+
+#ifndef GSAT_HPP_
+#define GSAT_HPP_
+
+
+#include "FillMethod.hpp"
+#include "ArrayFiller.hpp"
+#include "CFormula.hpp"
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <string> 
+#include <fstream>
+#include <random>
+#include <math.h>
+#include <sys/time.h>
+
+#define DEFAULT_ITERATIONS 1000
+#define DEFAULT_MAX_TRY 255
+#define DEFAULT_GREEDY_FACTOR 0.8
+#define DEFAULT_GW_FACTOR 0.5
+#define DEFAULT_RND_METHOD -1
+#define DEFAULT_H_METHOD -1
+
+class Options{
+public:
+  int iterations;
+  int maxTry;
+  float greedyFactor;
+  float gwFactor;
+  int rndMethod;
+  int hMethod;
+  char* filename;
+};
+
+char* getCmdOption(char ** begin, char ** end, const std::string & option);
+bool cmdOptionExists(char** begin, char** end, const std::string& option);
+void printHelp();
+
+class GSAT{
+public:
+  CFormula* formula;
+  Options* options;
+
+  Options* setParameters(int argc,char* argv[]);
+  void initialize();
+  bool start(int fill=DEFAULT_RND_METHOD,int heuristic=DEFAULT_H_METHOD);
+  inline double realTime() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (double)tv.tv_sec + (double) tv.tv_usec / 1000000;
+  }
+
+  inline unsigned int getNbClauses(){return formula->getNbClauses();}
+  inline unsigned int getNbVariables(){return formula->getNbVariables();}
+
+  inline unsigned int getNbSatisfiedClausesFill(){return formula->getNbSatisfiedClausesFill();}
+  inline unsigned int getNbSatisfiedClausesSolve(){return formula->getNbSatisfiedClausesSolve();}
+  
+  inline unsigned int getHeuristicFill(){return formula->getHeuristicFill();}
+  inline unsigned int getHeuristicSolve(){return formula->getHeuristicSolve();}
+  inline unsigned int getNbIterations(){return formula->getNbIterations();}
+};
+
+
+
+#endif

Part_2/GSAT/HeuristicMethod.hpp

@@ -0,0 +1,30 @@
+/*
+ * HeuristicMethod.hpp
+ *
+ *  Created on: Oct 3, 2016
+ *      Author: sina
+ */
+
+#ifndef HEURISTICMETHOD_HPP_
+#define HEURISTICMETHOD_HPP_
+
+
+enum HeuristicMethod
+{
+	FIRST_BEST,
+	RND_BEST,
+	RND_DIST,
+	RND,
+	RND_GREEDY,
+	WALK_SAT,
+	GSAT_WSAT,
+
+};
+
+#define FIRST_H_METHOD 	FIRST_BEST
+#define LAST_H_METHOD 	GSAT_WSAT
+
+
+
+
+#endif /* HEURISTICMETHOD_HPP_ */

Part_2/GSATThread.cpp

@@ -0,0 +1,122 @@
+#include <iostream>
+#include <stdlib.h>
+#include <stdio.h>
+#include "GSATThread.hpp"
+#include "color.h"
+
+/* --- Public --- */
+
+GSATThread::GSATThread(int argc, char** argv) {
+	gsat = std::vector<GSAT*>(NB_THREAD);
+	time = std::vector<double>(NB_THREAD);
+	threads = std::vector<std::thread>(NB_THREAD);
+	for(int i = 0; i < NB_THREAD; i++) {
+		gsat[i] = new GSAT();
+		gsat[i]->setParameters(argc,argv);
+  		gsat[i]->initialize();
+  		time[i] = 0;
+	}
+}
+
+GSATThread::~GSATThread() {
+	for(int i = 0; i < NB_THREAD; i++) {
+		delete gsat[i];
+	}
+}
+
+bool GSATThread::solve() {
+	return this->solve(0, true);
+}
+
+bool GSATThread::solve(int maxIteration) {
+	return this->solve(maxIteration, true);
+}
+
+bool GSATThread::solve(bool verbose) {
+	return this->solve(0, verbose);
+}
+
+bool GSATThread::solve(int _maxIteration, bool verbose) {
+	threads.clear();
+	end = false;
+	calcTime = 0;
+	maxIteration = _maxIteration;
+	//Lance thread
+	for(int i = 0; i < NB_THREAD; i++) {
+		time[i] = gsat[i]->realTime();
+		threads[i] = std::thread(&GSATThread::solverThread, this, i, verbose);
+	}
+	//Attend resultat
+	for(int i = 0; i < NB_THREAD; i++){
+		threads[i].join();
+	}
+	//Resultat
+	if(verbose) {
+		printf("------------------------------------------------------------------------------------------\n");
+		this->printResult();
+	}
+  	return end;
+}
+
+void GSATThread::printResult() {
+	if(end) {
+		printf(GREEN "s SATISFIABLE\n" RESET);
+	} else {
+		printf(RED "NOT FOUND\n" RESET);
+	}
+	//printf("s %s\n",end?"SATISFIABLE":"NOT FOUND");
+	if(!end && calcTime == 0) {
+		//Si on à pas trouver
+		calcTime = gsat[0]->realTime() - time[0];
+	}
+	printf(YELLOW);
+	if(end) {
+		printf("c [thread:%2d][iteration:%5d][file:%d][heuristic:%d]Satisfied clauses (begin: %d)(end:%d)\n",
+			result.threadId,
+			result.nbIteration,
+			result.heuristicFill,
+			result.heuristicSolve,
+			result.nbSatisfiedClausesFill,
+			result.nbSatisfiedClausesSolve);
+	}
+  	printf("c real time : %.4f seconds\n", calcTime);
+  	printf(RESET);
+}
+
+/* --- Private --- */
+
+void GSATThread::solverThread(int id, bool verbose) {
+	//Resolution
+	bool solve = false;
+	int cpt = 0;
+	while(!end && !solve && (maxIteration == 0 || cpt < maxIteration)){
+		solve = gsat[id]->start();
+		if(verbose) {
+			if(solve) {
+				printf(CYAN);
+			}
+			printf("c [thread:%2d][iteration:%5d][file:%d][heuristic:%d]Satisfied clauses (begin: %d)(end:%d)\n",
+				id,
+		   		gsat[id]->getNbIterations(),
+		   		gsat[id]->getHeuristicFill(),
+		   		gsat[id]->getHeuristicSolve(),
+		   		gsat[id]->getNbSatisfiedClausesFill(),
+		   		gsat[id]->getNbSatisfiedClausesSolve());
+			if(solve) {
+				printf(RESET);
+			}
+		}
+		cpt++;
+	}
+	//Si 1er arreter
+	if(!end && solve) {
+		end = true;
+		calcTime = gsat[id]->realTime() - time[id];
+		result.threadId = id;
+		result.nbIteration = gsat[id]->getNbIterations();
+		result.heuristicFill = gsat[id]->getHeuristicFill();
+		result.heuristicSolve = gsat[id]->getHeuristicSolve();
+		result.nbSatisfiedClausesFill = gsat[id]->getNbSatisfiedClausesFill();
+		result.nbSatisfiedClausesSolve = gsat[id]->getNbSatisfiedClausesSolve();
+	}
+}

Part_2/GSATThread.hpp

@@ -0,0 +1,47 @@
+#ifndef GSATTHREAD_HPP 
+#define GSATTHREAD_HPP 
+
+/* --- Include --- */
+#include <vector>
+#include <thread>
+#include "GSAT/GSAT.hpp"
+
+/* --- Constante --- */
+#define NB_THREAD 4
+
+/* --- Structure --- */
+typedef struct {
+	int threadId;
+	unsigned int nbIteration;
+	unsigned int heuristicFill;
+	unsigned int heuristicSolve;
+	unsigned int nbSatisfiedClausesFill;
+	unsigned int nbSatisfiedClausesSolve;
+}GSATResult;
+
+class GSATThread {
+	public:
+		GSATThread(int, char**);
+		~GSATThread();
+		bool solve();
+		bool solve(int);
+		bool solve(bool);
+		bool solve(int, bool);
+		void printResult();
+		/* --- Getter --- */
+		inline unsigned int getNbVariables() {return gsat[0]->getNbVariables();}
+		inline unsigned int getNbClauses() {return gsat[0]->getNbClauses();}
+
+	private:
+		bool end;
+		double calcTime;
+		std::vector<GSAT*> gsat;
+		std::vector<double> time;
+		std::vector<std::thread> threads;
+		int maxIteration;
+		GSATResult result;
+
+		void solverThread(int, bool);
+};
+
+#endif

Part_2/Main.cpp

@@ -0,0 +1,63 @@
+#include "GSAT/GSAT.hpp"
+#include "GSATThread.hpp"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+using namespace std;
+
+void help(char* prog) {
+    fprintf(stderr, "usage: %s -i file.cnf [-s] [-m int]\n\t-s Silent mode\n\t-m Max iteration number\n", prog);
+    exit(1);
+}
+
+int main(int argc, char* argv[]) {
+    extern char * optarg; 
+    int maxIteration = 0;
+    bool verbose = true;
+    int opt;
+    bool optI = false;
+
+    char** gsatArg = (char**) malloc(sizeof(char*) * 3);
+    gsatArg[0] = (char*) malloc(sizeof(char) * strlen(argv[0]) + 1);
+    memset(gsatArg[0], 0, strlen(argv[0]) + 1);
+    strncpy(gsatArg[0], argv[0], strlen(argv[0]));
+
+    while((opt = getopt(argc, argv, "si:m:")) != -1) {
+        switch(opt) {
+            case 'i':
+                optI = true;
+                gsatArg[1] = (char*) malloc(sizeof(char) * 3);
+                memset(gsatArg[1], 0, 3);
+                strncpy(gsatArg[1], "-i", 2);
+                gsatArg[2] = (char*) malloc(sizeof(char) * strlen(optarg) + 1);
+                memset(gsatArg[2], 0, strlen(optarg) + 1);
+                strncpy(gsatArg[2], optarg, strlen(optarg));
+                break;
+            case 's':
+                verbose = false;
+                break;
+            case 'm':
+                maxIteration = atoi(optarg);
+                break;
+            case '?':
+                help(argv[0]); 
+        }
+    }
+
+    if(!optI) {
+        help(argv[0]);
+    }
+  
+    GSATThread* gsat = new GSATThread(3, gsatArg);
+    printf("c nbThreads: %d\n", NB_THREAD);
+    printf("c nbVariables: %d\n", gsat->getNbVariables());
+    printf("c nbClauses: %d\n", gsat->getNbClauses());
+    bool result = gsat->solve(maxIteration, verbose);
+    if(!verbose) {
+        printf("s %s\n", result?"SATISFIABLE":"NOT FOUND");
+    }
+    
+
+}

Part_2/Makefile

@@ -0,0 +1,20 @@
+CXXFLAGS = -std=c++0x -O2 -g -Wall -fmessage-length=0 -Wreorder -Wwrite-strings -Wsign-compare
+
+OBJS = Main.o GSATThread.o GSAT/GSAT.o GSAT/ArrayFiller.o GSAT/CFormula.o
+
+LIBS = -lpthread
+
+TARGET = GSATSolver
+
+$(TARGET):	$(OBJS)
+	$(CXX) -o $(TARGET) $(OBJS) $(LIBS)
+
+all:	$(TARGET)
+
+clean:
+	rm -f $(OBJS) $(TARGET)
+	rm -rf *.*~
+	rm -rf *~
+
+run:
+	./GSATSolver -i ../benchmarks/uf150/uf150-099.cnf

Part_2/README.txt

@@ -0,0 +1,3 @@
+
+make -j
+./GSAT -i ../benchmarks/uf150/uf150-099.cnf

Part_2/color.h

@@ -0,0 +1,7 @@
+#define RED     "\x1b[31m"
+#define GREEN   "\x1b[32m"
+#define YELLOW  "\x1b[33m"
+#define BLUE    "\x1b[34m"
+#define MAGENTA "\x1b[35m"
+#define CYAN    "\x1b[36m"
+#define RESET   "\x1b[0m"

ReadMe.md

@@ -0,0 +1,3 @@
+# Projet SPD
+
+Arthur Brandoa M1 S2 2018-2019 

Thread/GSAT/ArrayFiller.cpp

@@ -0,0 +1,120 @@
+/*
+ * ArrayFiller.cpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The class for filling 1-D boolean array
+ */
+
+
+#include "ArrayFiller.hpp"
+
+ArrayFiller::ArrayFiller(bool* bArray,unsigned int arrSize):
+arrSize(arrSize),
+stepSize(DEFAULT_STEP_SIZE),
+currStep(DEFAULT_CURR_STEP),
+tRate(0),
+pArray(NULL)
+{
+
+	// -- Initialize boolean array if it has not been initialized
+
+	if (bArray==NULL)
+		this->bArray=new bool[arrSize];
+	else
+		this->bArray=bArray;
+
+	// -- Initializing sampling distribution --
+
+	this->rndReal=std::uniform_real_distribution<float>(0.0,1.0);
+
+	// -- Init random engine --
+
+	struct timespec ts;
+	unsigned theTick = 0U;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	theTick  = ts.tv_nsec / 1000000;
+	theTick += ts.tv_sec * 1000;
+	this->rndEngine.seed(theTick);
+}
+
+
+bool* ArrayFiller::getArray()
+{
+	return this->bArray;
+}
+
+void ArrayFiller::setPortionArray(float* pArray)
+{
+	this->pArray=pArray;
+}
+
+void ArrayFiller::setPortionRate(float rate)
+{
+	this->tRate=rate;
+}
+
+
+bool* ArrayFiller::fillArray(FillMethod method)
+{
+
+
+	switch (method)
+	{
+
+	case ZEROS_FILL:	// -- fills with zeros (false)
+		memset(this->bArray,0,this->arrSize*sizeof(bool));
+		break;
+
+	case ONES_FILL: // -- fills with ones (true)
+		memset(this->bArray,1,this->arrSize*sizeof(bool));
+		break;
+
+	case UNIFORM_FILL: // -- uniformly fills with zeros and ones
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd<UNIFORM_RATIO);
+		}
+		break;
+
+	case STEP_FILL:	// -- fills with step method
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->currStep);
+		}
+
+		this->currStep+=this->stepSize; // -- increase the step size ( probability of having true value)
+		if (this->currStep>1) this->currStep=0;
+		break;
+
+	case PORTION_FILL: // -- fills proportionally
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->tRate);
+		}
+		break;
+
+	case PORTION_EL_FILL: // -- fills each element proportionally
+
+		if (this->pArray==NULL)
+			break;
+
+
+		for (unsigned int i=0;i<this->arrSize;i++)
+		{
+			float rnd=this->rndReal(this->rndEngine);
+			this->bArray[i]=(rnd < this->pArray[i]);
+		}
+		break;
+
+	}
+
+	return this->bArray;
+
+}
+
+
+

Thread/GSAT/ArrayFiller.hpp

@@ -0,0 +1,61 @@
+/*
+ * ArrayFiller.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The class for filling 1-D boolean array
+ */
+
+#ifndef ARRAYFILLER_HPP_
+#define ARRAYFILLER_HPP_
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include "FillMethod.hpp"
+
+#define DEFAULT_STEP_SIZE	0.05
+#define DEFAULT_CURR_STEP	0.05
+
+using namespace std;
+
+class ArrayFiller
+{
+private :
+	bool *bArray ;					// -- pointer to the boolean array
+	unsigned int arrSize;			// -- array size
+	float stepSize;					// -- STEP_FILL, step size
+	float currStep;					// -- STEP_FILL, current step
+	float tRate;					// -- PORTION_FILL, true-rate
+	float* pArray;					// -- PORTION_EL_FILL array
+
+	std::uniform_real_distribution<float> rndReal;	// -- sampling from real uniform  distribution
+	std::default_random_engine rndEngine;			// -- sampling engine
+
+
+public:
+
+	// -- Vector Filler constructor
+	ArrayFiller(bool* bArray,unsigned int arrSize);
+
+	// -- property methods --
+	bool* getArray();
+
+	void setPortionArray(float* pArray);
+
+	void setPortionRate(float rate);
+
+	// -- Fill array randomly with the given method --
+	bool* fillArray(FillMethod method);
+
+};
+
+
+#endif /* ARRAYFILLER_HPP_ */

Thread/GSAT/CFormula.cpp

@@ -0,0 +1,675 @@
+/*
+ * CFormula.cpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ */
+
+#include "CFormula.hpp"
+
+CFormula::CFormula():
+nVars(0),
+nClauses(0),
+fStats{0,0,0},
+fVars(NULL),
+fPortions(NULL),
+tPortion(0),
+nLit(NULL),
+evalArray(NULL),
+
+evalClause(NULL),
+varMap(NULL),
+
+clCounter(0),
+
+greedyFactor(DEFAULT_GREEDY_FACTOR),
+arrayFiller(NULL),
+nbSatisfiedClausesFill(0),
+nbSatisfiedClausesSolve(0),
+lastFillMethod(0),
+lastHeuristic(0),
+ite(0)
+{
+
+	this->fType.clear();
+	this->fComments.clear();
+
+	// -- Initializing distribution variables --
+
+	rndReal=std::uniform_real_distribution<float>(0.0,1.0);
+	rndMethod=std::uniform_int_distribution<int>(FIRST_FILL_METHOD,LAST_FILL_METHOD);
+	rndHeuristic=std::uniform_int_distribution<int>(FIRST_H_METHOD,LAST_H_METHOD);
+
+	// -- Init random engine --
+
+	struct timespec ts;
+	unsigned theTick = 0U;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	theTick  = ts.tv_nsec / 1000000;
+	theTick += ts.tv_sec * 1000;
+	rndEngine.seed(theTick);
+}
+
+
+
+
+bool CFormula::initFormula(const char* filename)
+{
+
+	// -- Initialize variables --
+
+	this->cFormula.empty();
+	this->fComments.empty();
+	this->fType.empty();
+	this->fStats={0,0,0};
+	this->clCounter=0;
+	bool fReached=false;
+
+
+	// -- Free previously allocated variables --
+
+	if (this->fVars) free(this->fVars);
+	if (this->fPortions) free(this->fPortions);
+	if (this->nLit) free(this->nLit);
+	if (this->evalArray) free(this->evalArray);
+	if (this->arrayFiller) free(this->arrayFiller);
+	if (this->varMap) free(this->varMap);
+	if (this->evalClause) free(this->evalClause);
+
+	// -- Open input file --
+
+	ifstream input_file;
+	input_file.open(filename);
+
+	if (!input_file.is_open())
+	{
+		printf("STD Error: cannot open '%s'.",filename);
+		return false;
+	}
+
+
+	// -- Parse the provided file --
+
+	std::string line;
+	while (std::getline(input_file, line))
+	{
+		// -- get the flag (can be 'c' or 'p') --
+		char flag=line[0];
+		std::vector<string> tokens;
+
+		switch (flag)
+		{
+
+		case COMMENT_FLAG:	// -- Comment line has reached --
+
+			// -- Add to comment string --
+			this->fComments.append(&line[1]);
+			this->fComments.append("\n");
+			break;
+
+
+		case PROBLEM_FLAG:	// -- Problem line has reached --
+
+			// -- Tokenize current line --
+			tokens.empty();
+			tokens=tokenize(&line[1]," ");
+
+			// -- Check if the syntax if correct in order to parse the parameters --
+			if (tokens.size()<3)
+			{
+				printf("There is a syntax error in the problem definition.");
+				return false;
+			}
+
+			// -- Assign the variables --
+			this->fType=tokens[0];
+			this->nVars=stoi(tokens[1])+1;		// -- starts from 1
+			this->nClauses=stoi(tokens[2]);
+			fReached=true;
+
+			// -- allocate the arrays
+			this->fVars=new bool[this->nVars];
+			this->fPortions= new float[this->nVars];
+			this->nLit=new int[this->nVars];
+			this->evalArray=new int[this->nVars];
+			this->evalClause=new bool[this->nClauses];
+			this->varMap=new std::vector<int>[this->nVars];
+
+			// -- initialize the arrays
+			memset(this->fVars,0,this->nVars*sizeof(bool));
+			memset(this->fPortions,0,this->nVars*sizeof(float));
+			memset(this->nLit,0,this->nVars*sizeof(int));
+			memset(this->evalArray,0,this->nVars*sizeof(int));
+			memset(this->evalClause,0,this->nClauses*sizeof(bool));
+
+			// -- Instantiate the arrayFiller class
+			this->arrayFiller=new ArrayFiller(this->fVars,this->nVars);
+
+			break;
+
+
+		case END_FLAG: // -- End of the formula has reached --
+			input_file.close();
+
+			// -- Ppdate stats --
+			this->tPortion=(float)this->fStats.nPosLits/this->fStats.nLits;
+			for (unsigned int i=1;i<this->nVars;i++)
+				this->fPortions[i]/=(float)this->nLit[i];
+
+			// -- Init random filler --
+			this->arrayFiller->setPortionRate(this->tPortion);
+			this->arrayFiller->setPortionArray(this->fPortions);
+			this->arrayFiller->fillArray(PORTION_EL_FILL);
+			return true;
+			break;
+
+		default:	// -- Clause line has reached--
+			if (!fReached)
+				continue;
+			this->cFormula.push_back(parseClause(&line[0]," "));
+			break;
+		}
+
+	}
+
+	return true;
+}
+
+
+
+
+bool CFormula::evalFormulaQ(unsigned int varIndex,int& clNum)
+{
+
+	bool fEval=true;
+	clNum=0;
+
+	// -- check through the modified clauses --
+	for (unsigned int i=0;i<this->varMap[varIndex].size();i++)
+	{
+		// -- get the clause --
+		int cIndex=this->varMap[varIndex].at(i);
+		Clause cl=this->cFormula[cIndex];
+
+		// -- for each literal
+		for (unsigned int j=0;j<cl.size();j++)
+		{
+
+			Literal lit=cl[j];
+
+			// -- get the index and sign
+			bool neg=(lit<0);
+			int index=abs(lit);
+			// -- evaluate the literal
+			bool litEval=neg^this->fVars[index];
+			this->evalClause[cIndex]=litEval; // -- update clause truth list
+
+			// -- if positive -> clause will be evaluated as positive
+			if (litEval)
+				break;
+
+		}
+
+	}
+
+
+	// -- evaluate the whole formula --
+
+	for (unsigned int i=0;i<this->cFormula.size();i++)
+	{
+		bool evalClause=this->evalClause[i];
+		fEval&=evalClause;
+		if (evalClause)clNum++;
+	}
+	return fEval;
+}
+
+
+bool CFormula::evalFormula(int& clNum)
+{
+
+
+	bool fEval=true;
+	clNum=0;
+
+
+	for (unsigned int i=0;i<this->cFormula.size();i++)
+	{
+
+		// -- get the clause --
+		Clause cl=this->cFormula[i];
+		bool clEval=false;
+
+		// -- for each literal
+		for (unsigned int j=0;j<cl.size();j++)
+		{
+
+			Literal lit=cl[j];
+
+			// -- get the index and sign
+			bool neg=(lit<0);
+			int index=abs(lit);
+			// -- evaluate the literal
+			bool litEval=neg^this->fVars[index];
+
+			this->evalClause[i]=litEval;
+
+			// -- if positive -> clause will be evaluated as positive
+			if (litEval)
+			{
+				clEval=true;
+				clNum++;
+				break;
+			}
+		}
+
+		// -- and it with current evaluation of formula
+		fEval&=clEval;
+
+	}
+
+	return fEval;
+}
+
+
+
+bool CFormula::startGSAT(int iterations,int maxTry,int fillMethod,int hMethod)
+{
+	float initGuessMean=0;	// -- initial guess average
+	float negClauseMean=0;	// -- average number of negative clauses
+	float elaborateMean=0; 	// -- averate number of elaboration
+	bool fEval=false;
+	int i;
+
+	for (i=0;i<iterations;i++)
+	{
+		int initGuess=0;
+		int clNum=0;
+		fEval=false;
+
+		// -- randomly select the filler method --
+		FillMethod fMethod;
+		if (fillMethod==-1)
+			fMethod=getRandomMethod();
+		else
+			fMethod=(FillMethod)fillMethod;
+		lastFillMethod=fMethod;
+		ite++;
+		// -- randomly select the heuristic method --
+		HeuristicMethod heuristic;
+		if (hMethod==-1)
+			heuristic=getRandomHeuristic();
+		else
+			heuristic=(HeuristicMethod)hMethod;
+		lastHeuristic=heuristic;
+		
+		this->arrayFiller->fillArray(fMethod);
+
+		// -- evaluate the function
+		fEval=this->evalFormula(clNum);
+		initGuess=clNum;
+		nbSatisfiedClausesFill=initGuess;
+		initGuessMean+=initGuess;
+
+		// -- return if already found the solution
+		if (fEval)
+			break;
+
+
+		for (int j=0;j<maxTry;j++)
+		{
+			int choice=0;
+
+
+			// -- select the choice with the given heuristics --
+
+			switch (heuristic)
+			{
+
+			case FIRST_BEST:
+				choice=this->getBestChoice(true);
+				break;
+
+			case RND_BEST:
+				choice=this->getBestChoice();
+				break;
+
+			case RND_DIST:
+				choice=this->getRndBest();
+				break;
+
+			case RND:
+				choice=(int)(rndReal(rndEngine)*this->nVars);
+				break;
+
+			case RND_GREEDY:
+				if (this->takeBestChoice())
+					choice=this->getBestChoice();
+				else
+					choice=this->getRndBest();
+				break;
+
+			case WALK_SAT:
+				choice=this->walkSatChoice();
+				break;
+
+			case GSAT_WSAT:
+				if (this->takeGW())
+					choice=this->getBestChoice();
+				else
+					choice=this->walkSatChoice();
+				break;
+
+			}
+
+
+			toggle(this->fVars[choice]);
+			fEval=this->evalFormulaQ(choice,clNum);//this->evalFormula(clNum);
+
+			if (fEval)
+				break;
+
+
+		}
+
+
+		negClauseMean+=this->nClauses-clNum;
+		elaborateMean+=clNum-initGuess;
+		nbSatisfiedClausesSolve=clNum;
+
+		//printf("[iteration %d, fill :%d, heuristic :%d] - init Guess :%d - final Guess :%d - model found :%d\n",i,fMethod,heuristic,initGuess,clNum,fEval);
+
+		if (fEval)
+			break;
+	}
+
+
+	/*printf("Elaborate mean :%f\n",elaborateMean/(float)i);
+	printf("Initial guess mean :%f\n",initGuessMean/(float)i);
+	printf("Neg clause mean :%f\n",negClauseMean/(float)i);*/
+
+
+
+	return fEval;
+
+}
+
+
+void CFormula::setGreedyFactor(float factor)
+{
+	this->greedyFactor=factor;
+}
+
+void CFormula::setGWFactor(float factor)
+{
+	this->gwFactor=factor;
+}
+
+std::vector<string> CFormula::tokenize(char*input,const char*split)
+{
+	char * token;
+	std::vector<string> token_vec;
+
+	token = strtok (input,split);
+	while (token != NULL)
+	{
+		token_vec.push_back(string(token));
+		token = strtok (NULL, " ");
+	}
+	return token_vec;
+}
+
+Clause CFormula::parseClause(char*input,const char*split)
+{
+	char * token;
+	Clause cl;
+
+	token = strtok (input,split);
+	while (token != NULL)
+	{
+		Literal lit=stoi(token);
+		if (lit!=0)
+		{
+			int index=abs(lit);
+			// -- update the stats
+
+			this->varMap[index].push_back(clCounter);
+
+			if (lit>0)
+			{
+				this->fStats.nPosLits++;
+				this->fPortions[index]+=1;
+			}
+			else this->fStats.nNegLits++;
+			fStats.nLits++;
+			this->nLit[index]++;
+			// --
+
+			cl.push_back(lit);
+		}
+		token = strtok (NULL, " ");
+	}
+
+	this->clCounter++;
+
+	return cl;
+}
+
+
+
+
+FillMethod CFormula::getRandomMethod()
+{
+	return (FillMethod)rndMethod(rndEngine);
+}
+
+
+HeuristicMethod CFormula::getRandomHeuristic()
+{
+	return (HeuristicMethod)rndHeuristic(rndEngine);
+}
+
+
+
+bool CFormula::takeBestChoice()
+{
+
+	double random=rndReal(rndEngine);	// -- Get a double random number between 0 and 1
+
+	// -- Check if GSAT should take a best action
+	if (random<=this->greedyFactor)
+		return true;
+	return false;
+}
+
+bool CFormula::takeGW()
+{
+
+	double random=rndReal(rndEngine);	// -- Get a double random number between 0 and 1
+
+	// -- Check if GSAT should take a best action
+	if (random<=this->gwFactor)
+		return true;
+	return false;
+}
+
+
+void CFormula::evalMove(int&min,int&max)
+{
+	min=std::numeric_limits<int>::max();
+	max=0;
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		int clNum=0;
+		int temp=0;
+		toggle(this->fVars[i]);
+
+		this->evalFormulaQ(i,clNum);	//this->evalFormula(clNum);
+		toggle(this->fVars[i]);
+		this->evalFormulaQ(i,temp);
+
+		this->evalArray[i]=clNum;
+		if (clNum>max) max=clNum;
+		if (clNum<min) min=clNum;
+
+	}
+}
+
+std::vector<int> CFormula::evalUnsatClause(int clIndex,int&min,int&max)
+{
+	min=std::numeric_limits<int>::max();
+	max=0;
+
+	Clause cl=this->cFormula[clIndex];
+	std::vector<int> evalArray;
+
+	for (unsigned int i=0;i<cl.size();i++)
+	{
+		Literal lit=cl[i];
+		int index=abs(lit);
+
+		int clNum=0;
+		int temp=0;
+
+		// -- evaluate the positive clauses
+		toggle(this->fVars[index]);
+		this->evalFormulaQ(index,clNum);	//this->evalFormula(clNum);
+		toggle(this->fVars[index]);
+		this->evalFormulaQ(index,temp);
+		// --
+
+		evalArray.push_back(clNum);
+		if (clNum>max) max=clNum;
+		if (clNum<min) min=clNum;
+
+	}
+
+	return evalArray;
+}
+
+int CFormula::getBestChoice(bool retFirst)
+{
+	int min,max;
+	this->evalMove(min,max);
+	int bestCount=0;
+	std::vector<int> bestArray;
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		if (this->evalArray[i]==max)
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			bestArray.push_back(i);
+			bestCount++;
+		}
+	}
+
+	if (bestCount==1)
+		return bestArray[0];
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*bestCount);
+	return bestArray[rndIndex];
+
+}
+
+
+int CFormula::walkSatChoice(bool retFirst)
+{
+
+	// -- Randomly get one unsatisfied clause
+	int clIndex=this->getUnsatClause(retFirst);
+
+	int min,max;
+
+	// -- List the best choices
+	std::vector<int> evalArray=evalUnsatClause( clIndex,min,max);
+
+	// -- select randomly from the best choices
+	int bestCount=0;
+	std::vector<int> bestArray;
+
+	for (unsigned int i=0;i<evalArray.size();i++)
+	{
+		if (evalArray[i]==max)
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			bestArray.push_back(i);
+			bestCount++;
+		}
+	}
+
+	if (bestCount==1)
+		return abs(this->cFormula[clIndex].at(bestArray[0]));
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*bestCount);
+
+	return abs(this->cFormula[clIndex].at(bestArray[rndIndex]));
+}
+
+int CFormula::getUnsatClause(bool retFirst)
+{
+
+	int clCount=0;
+	std::vector<int> clArray;
+
+	for (unsigned int i=0;i<this->nClauses;i++)
+	{
+		if (!this->evalClause[i])
+		{
+			if (retFirst) return i;	// -- return immediately the first choice
+
+			clArray.push_back(i);
+			clCount++;
+		}
+	}
+
+	if (clCount==1)
+		return clArray[0];
+
+	// -- randomly select the best choice
+	int rndIndex=(int)(rndReal(rndEngine)*clCount);
+	return clArray[rndIndex];
+
+}
+
+int CFormula::getRndBest(bool exponential)
+{
+	int min,max;
+	float cum=0;
+	this->evalMove(min,max);
+	float normalizer=0;
+
+	// -- calculate the discrete probability distribution --
+	float  probs[this->nVars];
+	float rnd =rndReal(rndEngine);
+
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+
+		probs[i]=(float)(this->evalArray[i]-min+DEFAULT_BIAS);
+
+		if (exponential)probs[i]=exp(probs[i]);
+		normalizer+=probs[i];
+	}
+
+	// -- sample from the distribution --
+	for (unsigned int i=1;i<this->nVars;i++)
+	{
+		cum+=probs[i]/normalizer;
+
+		if (cum>rnd)
+			return i;
+
+	}
+
+	return 0;
+}
+
+
+
+

Thread/GSAT/CFormula.hpp

@@ -0,0 +1,140 @@
+/*
+ * CFormula.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ */
+
+#ifndef CFORMULA_HPP_
+#define CFORMULA_HPP_
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include "FillMethod.hpp"
+#include "ArrayFiller.hpp"
+#include "HeuristicMethod.hpp"
+
+using namespace std;
+
+
+typedef int Literal;
+typedef std::vector<Literal> Clause;
+typedef std::vector<Clause> Formulae;
+
+
+
+#define COMMENT_FLAG 'c'
+#define PROBLEM_FLAG 'p'
+#define END_FLAG '%'
+#define toggle(x) (x=x^1)
+#define DEFAULT_BIAS 1
+#define DEFAULT_ITERATIONS 1000
+#define DEFAULT_MAX_TRY 255
+#define DEFAULT_GREEDY_FACTOR 0.8
+#define DEFAULT_GW_FACTOR 0.5
+
+class CFormula
+{
+public :
+	string fType;			// -- formula type (in this case should be 'cnf')
+	string fComments;		// -- formula comments
+	unsigned int nVars;		// -- number of variables
+	unsigned int nClauses;	// -- number of clauses
+	struct
+	{
+		unsigned int nPosLits;		// -- number of positive literals
+		unsigned int nNegLits;		// -- number of negative literals
+		unsigned int nLits;			// -- total literls
+	}fStats;
+
+public :
+  bool * fVars;				// -- formula variables
+  float * fPortions;			// -- variables' proportions
+  float tPortion;				// -- total positive to negative literal proportion
+  int * nLit	;				// -- total occurrence of specific literal in formula
+  int * evalArray;			// -- flip evaluation array
+  bool * evalClause;		    // -- evaluation of clauses  // ADDED
+  std::vector<int>* varMap;	// -- mapping between variables and clauses //ADDED
+  unsigned int clCounter;		// -- clause counter variable
+  float greedyFactor;			// -- GSAT greedy factor
+  float gwFactor;				// -- GSAT or WSAT select probability
+
+  Formulae cFormula;				// -- canonical formula jagged array(vector)
+  ArrayFiller* arrayFiller;		//-- array filler class
+  std::default_random_engine rndEngine;
+  std::uniform_real_distribution<float> rndReal;	// -- sampling from real uniform  distribution
+  std::uniform_int_distribution<int> rndMethod;   // -- sampling from int uniform  distribution
+  std::uniform_int_distribution<int> rndHeuristic;// -- sampling from int uniform  distribution
+  unsigned int nbSatisfiedClausesFill;
+  unsigned int nbSatisfiedClausesSolve;
+  unsigned int lastFillMethod;
+  unsigned int lastHeuristic;
+  unsigned int ite;
+  
+public:
+  CFormula();
+  
+  bool initFormula(const char* filename);
+
+  bool evalFormulaQ(unsigned int varIndex,int& clNum);	// -- faster version of evalFormula (just check the modified clauses)
+
+  bool evalFormula(int& clNum);
+
+  bool startGSAT(int iterations=DEFAULT_ITERATIONS,int maxTry=DEFAULT_MAX_TRY,int fillMethod=-1,int hMethod=-1);
+
+  void setGreedyFactor(float factor);
+
+  void setGWFactor(float factor);
+
+  inline unsigned int getNbClauses(){return nClauses;}
+  inline unsigned int getNbVariables(){return nVars;}
+
+  inline unsigned int getNbSatisfiedClausesFill(){return nbSatisfiedClausesFill;}
+  inline unsigned int getNbSatisfiedClausesSolve(){return nbSatisfiedClausesSolve;}
+  
+  inline unsigned int getHeuristicFill(){return lastFillMethod;}
+  inline unsigned int getHeuristicSolve(){return lastHeuristic;}
+  inline unsigned int getNbIterations(){return ite;}
+
+  
+private:
+	std::vector<string> tokenize(char*input,const char*split);
+
+	Clause parseClause(char*input,const char*split);
+
+	// -- randomly select the filler method --
+	FillMethod getRandomMethod();
+
+	// -- randomly select the heuristic method --
+	HeuristicMethod getRandomHeuristic();
+
+	// -- If GSAT should take a best action
+	bool takeBestChoice();
+
+	bool takeGW();
+
+	void evalMove(int&min,int&max);
+
+	std::vector<int> evalUnsatClause(int clIndex,int&min,int&max);
+
+	int getBestChoice(bool retFirst=false);
+
+	int walkSatChoice(bool retFirst=false);
+
+	int getUnsatClause(bool retFirst=false);
+
+	int getRndBest(bool exponential=true);	// -- randomly select the choice according to each move's reward
+
+
+};
+
+
+#endif /* CFORMULA_HPP_ */

Thread/GSAT/FillMethod.hpp

@@ -0,0 +1,28 @@
+/*
+ * FillMethod.hpp
+ *
+ *  Created on: Oct 1, 2016
+ *      Author: Sina M.Baharlou
+ *      The methods for filling 1-D boolean array
+ */
+
+#ifndef FILLMETHOD_HPP_
+#define FILLMETHOD_HPP_
+
+
+enum FillMethod
+{
+	ZEROS_FILL,
+	ONES_FILL,
+	UNIFORM_FILL,
+	STEP_FILL,
+	PORTION_FILL,
+	PORTION_EL_FILL
+};
+
+#define METHOD_COUNT 6
+#define FIRST_FILL_METHOD 	UNIFORM_FILL
+#define LAST_FILL_METHOD 	PORTION_EL_FILL
+#define UNIFORM_RATIO	0.5
+
+#endif /* FILLMETHOD_HPP_ */

Thread/GSAT/GSAT.cpp

@@ -0,0 +1,144 @@
+//============================================================================
+// Name        : GSAT.cpp
+// Author      : Sina M.Baharlou
+// Version     : 1
+// Description : GSAT Solver
+//============================================================================
+
+
+
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <random>
+#include <math.h>
+#include <sys/time.h>
+
+#include "GSAT.hpp"
+
+using namespace std;
+
+#include <algorithm>
+
+
+char* getCmdOption(char ** begin, char ** end, const std::string & option)
+{
+	char ** itr = std::find(begin, end, option);
+	if (itr != end && ++itr != end)
+	{
+		return *itr;
+	}
+	return 0;
+}
+
+bool cmdOptionExists(char** begin, char** end, const std::string& option)
+{
+	return std::find(begin, end, option) != end;
+}
+
+
+
+void printHelp()
+{
+	const char *help = "\n\n// --  GSAT simple solver -- // \n"
+			"// --  By Sina M.Baharlou -- // \n"
+			"// --  Oct  2016 \n\n"
+			"GSAT -i [input_file] <options> \n"
+			"Available options are : \n"
+			"\t--iterations [number of iterations] \n"
+			"\t--flip_max [number of maximum flips per iterations]\n"
+			"\t--greedy_factor [greedy factor] \n"
+			"\t--gw_factor [gsat/wsat factor] \n"
+			"\t--heuristic [heuristic_method]\n"
+			"\t\t-1- randomly select the heuristic method\n"
+			"\t\t 0- select the first best choice\n"
+			"\t\t 1- select randomly among the best choices\n"
+			"\t\t 2- select according to the cost distribution\n"
+			"\t\t 3- select randomly among all the choices\n"
+			"\t\t 4- combination of 1 and 2 according to the greedy factor\n"
+			"\t\t 5- WALKSAT\n"
+			"\t\t 6- randomly select between GSAT or WALKSAT\n"
+			"\t--rnd_method [rnd_method] \n"
+			"\t\t-1-randomly select the method\n"
+			"\t\t0-fill with zeros\n"
+			"\t\t1-fill with ones\n"
+			"\t\t2-fill uniformly\n"
+			"\t\t3-STEP method\n"
+			"\t\t4-PORTION method\n"
+			"\t\t5-PORTION_EL method\n";
+
+
+	printf("%s",help);
+}
+
+void GSAT::initialize(){
+  formula=new CFormula();
+  formula->initFormula(options->filename);
+  formula->setGreedyFactor(options->greedyFactor);
+  formula->setGWFactor(options->gwFactor);
+}
+
+bool GSAT::start(int fill,int heuristic){
+  return formula->startGSAT(1,options->maxTry,fill,heuristic);
+}
+
+Options* GSAT::setParameters(int argc,char* argv[]){
+  options = new Options();
+  // -- default variables --
+  options->iterations=DEFAULT_ITERATIONS;
+  options->maxTry=DEFAULT_MAX_TRY;
+  options->greedyFactor=DEFAULT_GREEDY_FACTOR;
+  options->gwFactor=DEFAULT_GW_FACTOR;
+  options->rndMethod=DEFAULT_RND_METHOD;
+  options->hMethod=DEFAULT_H_METHOD;
+  // --
+
+
+  if (argc<2)
+    {
+      printHelp();
+      exit(0);
+    }
+
+  if (!cmdOptionExists(argv, argv+argc, "-i"))
+    {
+      printHelp();
+      printf("STD Error : no input file has been provided.\n\n");
+      exit(0);
+    }
+
+  options->filename = getCmdOption(argv, argv + argc, "-i");
+
+  if (options->filename==NULL)
+    {
+      printf("STD Error : not input file has been provided.\n\n");
+      exit(0);
+    }
+
+  if (cmdOptionExists(argv, argv+argc, "--iterations"))
+    options->iterations=stoi(getCmdOption(argv, argv + argc, "--iterations"));
+
+
+
+  if (cmdOptionExists(argv, argv+argc, "--flip_max"))
+    options->maxTry=stoi(getCmdOption(argv, argv + argc, "--flip_max"));
+
+
+  if (cmdOptionExists(argv, argv+argc, "--greedy_factor"))
+    options->greedyFactor=stof(getCmdOption(argv, argv + argc, "--greedy_factor"));
+
+  if (cmdOptionExists(argv, argv+argc, "--gw_factor"))
+    options->gwFactor=stof(getCmdOption(argv, argv + argc, "--gw_factor"));
+
+  if (cmdOptionExists(argv, argv+argc, "--rnd_method"))
+    options->rndMethod=stoi(getCmdOption(argv, argv + argc, "--rnd_method"));
+
+  if (cmdOptionExists(argv, argv+argc, "--heuristic"))
+    options->hMethod=stoi(getCmdOption(argv, argv + argc, "--heuristic"));
+  return options;
+}

Thread/GSAT/GSAT.hpp

@@ -0,0 +1,71 @@
+
+#ifndef GSAT_HPP_
+#define GSAT_HPP_
+
+
+#include "FillMethod.hpp"
+#include "ArrayFiller.hpp"
+#include "CFormula.hpp"
+#include <iostream>
+#include <string.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <string> 
+#include <fstream>
+#include <random>
+#include <math.h>
+#include <sys/time.h>
+
+#define DEFAULT_ITERATIONS 1000
+#define DEFAULT_MAX_TRY 255
+#define DEFAULT_GREEDY_FACTOR 0.8
+#define DEFAULT_GW_FACTOR 0.5
+#define DEFAULT_RND_METHOD -1
+#define DEFAULT_H_METHOD -1
+
+class Options{
+public:
+  int iterations;
+  int maxTry;
+  float greedyFactor;
+  float gwFactor;
+  int rndMethod;
+  int hMethod;
+  char* filename;
+};
+
+char* getCmdOption(char ** begin, char ** end, const std::string & option);
+bool cmdOptionExists(char** begin, char** end, const std::string& option);
+void printHelp();
+
+class GSAT{
+public:
+  CFormula* formula;
+  Options* options;
+
+  Options* setParameters(int argc,char* argv[]);
+  void initialize();
+  bool start(int fill=DEFAULT_RND_METHOD,int heuristic=DEFAULT_H_METHOD);
+  inline double realTime() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (double)tv.tv_sec + (double) tv.tv_usec / 1000000;
+  }
+
+  inline unsigned int getNbClauses(){return formula->getNbClauses();}
+  inline unsigned int getNbVariables(){return formula->getNbVariables();}
+
+  inline unsigned int getNbSatisfiedClausesFill(){return formula->getNbSatisfiedClausesFill();}
+  inline unsigned int getNbSatisfiedClausesSolve(){return formula->getNbSatisfiedClausesSolve();}
+  
+  inline unsigned int getHeuristicFill(){return formula->getHeuristicFill();}
+  inline unsigned int getHeuristicSolve(){return formula->getHeuristicSolve();}
+  inline unsigned int getNbIterations(){return formula->getNbIterations();}
+};
+
+
+
+#endif

Thread/GSAT/HeuristicMethod.hpp

@@ -0,0 +1,30 @@
+/*
+ * HeuristicMethod.hpp
+ *
+ *  Created on: Oct 3, 2016
+ *      Author: sina
+ */
+
+#ifndef HEURISTICMETHOD_HPP_
+#define HEURISTICMETHOD_HPP_
+
+
+enum HeuristicMethod
+{
+	FIRST_BEST,
+	RND_BEST,
+	RND_DIST,
+	RND,
+	RND_GREEDY,
+	WALK_SAT,
+	GSAT_WSAT,
+
+};
+
+#define FIRST_H_METHOD 	FIRST_BEST
+#define LAST_H_METHOD 	GSAT_WSAT
+
+
+
+
+#endif /* HEURISTICMETHOD_HPP_ */

Thread/GSATThread.cpp

@@ -0,0 +1,123 @@
+#include <iostream>
+#include <stdlib.h>
+#include <stdio.h>
+#include "GSATThread.hpp"
+#include "color.h"
+
+/* --- Public --- */
+
+GSATThread::GSATThread(int _nbThread, int argc, char** argv) {
+	nbThread = _nbThread;
+	gsat = std::vector<GSAT*>(_nbThread);
+	time = std::vector<double>(_nbThread);
+	threads = std::vector<std::thread>(_nbThread);
+	for(int i = 0; i < _nbThread; i++) {
+		gsat[i] = new GSAT();
+		gsat[i]->setParameters(argc,argv);
+  		gsat[i]->initialize();
+  		time[i] = 0;
+	}
+}
+
+GSATThread::~GSATThread() {
+	for(int i = 0; i < nbThread; i++) {
+		delete gsat[i];
+	}
+}
+
+bool GSATThread::solve() {
+	return this->solve(0, true);
+}
+
+bool GSATThread::solve(int maxIteration) {
+	return this->solve(maxIteration, true);
+}
+
+bool GSATThread::solve(bool verbose) {
+	return this->solve(0, verbose);
+}
+
+bool GSATThread::solve(int _maxIteration, bool verbose) {
+	threads.clear();
+	end = false;
+	calcTime = 0;
+	maxIteration = _maxIteration;
+	//Lance thread
+	for(int i = 0; i < nbThread; i++) {
+		time[i] = gsat[i]->realTime();
+		threads[i] = std::thread(&GSATThread::solverThread, this, i, verbose);
+	}
+	//Attend resultat
+	for(int i = 0; i < nbThread; i++){
+		threads[i].join();
+	}
+	//Resultat
+	if(verbose) {
+		printf("------------------------------------------------------------------------------------------\n");
+		this->printResult();
+	}
+  	return end;
+}
+
+void GSATThread::printResult() {
+	if(end) {
+		printf(GREEN "s SATISFIABLE\n" RESET);
+	} else {
+		printf(RED "NOT FOUND\n" RESET);
+	}
+	//printf("s %s\n",end?"SATISFIABLE":"NOT FOUND");
+	if(!end && calcTime == 0) {
+		//Si on à pas trouver
+		calcTime = gsat[0]->realTime() - time[0];
+	}
+	printf(YELLOW);
+	if(end) {
+		printf("c [thread:%2d][iteration:%5d][file:%d][heuristic:%d]Satisfied clauses (begin: %d)(end:%d)\n",
+			result.threadId,
+			result.nbIteration,
+			result.heuristicFill,
+			result.heuristicSolve,
+			result.nbSatisfiedClausesFill,
+			result.nbSatisfiedClausesSolve);
+	}
+  	printf("c real time : %.4f seconds\n", calcTime);
+  	printf(RESET);
+}
+
+/* --- Private --- */
+
+void GSATThread::solverThread(int id, bool verbose) {
+	//Resolution
+	bool solve = false;
+	int cpt = 0;
+	while(!end && !solve && (maxIteration == 0 || cpt < maxIteration)){
+		solve = gsat[id]->start();
+		if(verbose) {
+			if(solve) {
+				printf(CYAN);
+			}
+			printf("c [thread:%2d][iteration:%5d][file:%d][heuristic:%d]Satisfied clauses (begin: %d)(end:%d)\n",
+				id,
+		   		gsat[id]->getNbIterations(),
+		   		gsat[id]->getHeuristicFill(),
+		   		gsat[id]->getHeuristicSolve(),
+		   		gsat[id]->getNbSatisfiedClausesFill(),
+		   		gsat[id]->getNbSatisfiedClausesSolve());
+			if(solve) {
+				printf(RESET);
+			}
+		}
+		cpt++;
+	}
+	//Si 1er arreter
+	if(!end && solve) {
+		end = true;
+		calcTime = gsat[id]->realTime() - time[id];
+		result.threadId = id;
+		result.nbIteration = gsat[id]->getNbIterations();
+		result.heuristicFill = gsat[id]->getHeuristicFill();
+		result.heuristicSolve = gsat[id]->getHeuristicSolve();
+		result.nbSatisfiedClausesFill = gsat[id]->getNbSatisfiedClausesFill();
+		result.nbSatisfiedClausesSolve = gsat[id]->getNbSatisfiedClausesSolve();
+	}
+}

Thread/GSATThread.hpp

@@ -0,0 +1,48 @@
+#ifndef GSATTHREAD_HPP 
+#define GSATTHREAD_HPP 
+
+/* --- Include --- */
+#include <vector>
+#include <thread>
+#include "GSAT/GSAT.hpp"
+
+/* --- Constante --- */
+#define DEFAULT_NB_THREAD 4
+
+/* --- Structure --- */
+typedef struct {
+	int threadId;
+	unsigned int nbIteration;
+	unsigned int heuristicFill;
+	unsigned int heuristicSolve;
+	unsigned int nbSatisfiedClausesFill;
+	unsigned int nbSatisfiedClausesSolve;
+}GSATResult;
+
+class GSATThread {
+	public:
+		GSATThread(int, int, char**);
+		~GSATThread();
+		bool solve();
+		bool solve(int);
+		bool solve(bool);
+		bool solve(int, bool);
+		void printResult();
+		/* --- Getter --- */
+		inline unsigned int getNbVariables() {return gsat[0]->getNbVariables();}
+		inline unsigned int getNbClauses() {return gsat[0]->getNbClauses();}
+
+	private:
+		bool end;
+		double calcTime;
+		int nbThread;
+		std::vector<GSAT*> gsat;
+		std::vector<double> time;
+		std::vector<std::thread> threads;
+		int maxIteration;
+		GSATResult result;
+
+		void solverThread(int, bool);
+};
+
+#endif

Thread/Main.cpp

@@ -0,0 +1,67 @@
+#include "GSAT/GSAT.hpp"
+#include "GSATThread.hpp"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+using namespace std;
+
+void help(char* prog) {
+    fprintf(stderr, "usage: %s -i file.cnf [-t int] [-s] [-m int]\n\t-t Number of threads to use\n\t-s Silent mode\n\t-m Max iteration number\n", prog);
+    exit(1);
+}
+
+int main(int argc, char* argv[]) {
+    extern char * optarg; 
+    int nbThread = DEFAULT_NB_THREAD;
+    int maxIteration = 0;
+    bool verbose = true;
+    int opt;
+    bool optI = false;
+
+    char** gsatArg = (char**) malloc(sizeof(char*) * 3);
+    gsatArg[0] = (char*) malloc(sizeof(char) * strlen(argv[0]) + 1);
+    memset(gsatArg[0], 0, strlen(argv[0]) + 1);
+    strncpy(gsatArg[0], argv[0], strlen(argv[0]));
+
+    while((opt = getopt(argc, argv, "si:t:m:")) != -1) {
+        switch(opt) {
+            case 'i':
+                optI = true;
+                gsatArg[1] = (char*) malloc(sizeof(char) * 3);
+                memset(gsatArg[1], 0, 3);
+                strncpy(gsatArg[1], "-i", 2);
+                gsatArg[2] = (char*) malloc(sizeof(char) * strlen(optarg) + 1);
+                memset(gsatArg[2], 0, strlen(optarg) + 1);
+                strncpy(gsatArg[2], optarg, strlen(optarg));
+                break;
+            case 't':
+                nbThread = atoi(optarg);
+                break;
+            case 's':
+                verbose = false;
+                break;
+            case 'm':
+                maxIteration = atoi(optarg);
+                break;
+            case '?':
+                help(argv[0]); 
+        }
+    }
+
+    if(!optI) {
+        help(argv[0]);
+    }
+  
+    GSATThread* gsat = new GSATThread(nbThread, 3, gsatArg);
+    printf("c nbThreads: %d\n", nbThread);
+    printf("c nbVariables: %d\n", gsat->getNbVariables());
+    printf("c nbClauses: %d\n", gsat->getNbClauses());
+    bool result = gsat->solve(maxIteration, verbose);
+    if(!verbose) {
+        printf("s %s\n", result?"SATISFIABLE":"NOT FOUND");
+    }
+    
+
+}

Thread/Makefile

@@ -0,0 +1,20 @@
+CXXFLAGS = -std=c++0x -O2 -g -Wall -fmessage-length=0 -Wreorder -Wwrite-strings -Wsign-compare
+
+OBJS = Main.o GSATThread.o GSAT/GSAT.o GSAT/ArrayFiller.o GSAT/CFormula.o
+
+LIBS = -lpthread
+
+TARGET = GSATSolver
+
+$(TARGET):	$(OBJS)
+	$(CXX) -o $(TARGET) $(OBJS) $(LIBS)
+
+all:	$(TARGET)
+
+clean:
+	rm -f $(OBJS) $(TARGET)
+	rm -rf *.*~
+	rm -rf *~
+
+run:
+	./GSATSolver -i ../benchmarks/uf150/uf150-099.cnf -t 4

Thread/README.txt

@@ -0,0 +1,3 @@
+
+make -j
+./GSAT -i ../benchmarks/uf150/uf150-099.cnf

Thread/color.h

@@ -0,0 +1,7 @@
+#define RED     "\x1b[31m"
+#define GREEN   "\x1b[32m"
+#define YELLOW  "\x1b[33m"
+#define BLUE    "\x1b[34m"
+#define MAGENTA "\x1b[35m"
+#define CYAN    "\x1b[36m"
+#define RESET   "\x1b[0m"

benchmarks/uf100/uf100-01.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 26 -99 7 0
+-90 84 -94 0
+74 -99 -7 0
+31 5 61 0
+29 16 -10 0
+9 -41 -98 0
+30 46 -43 0
+-78 -5 67 0
+85 -82 22 0
+-69 26 -57 0
+-77 -40 -12 0
+-34 85 13 0
+43 -86 -49 0
+26 -54 -82 0
+88 67 4 0
+16 -21 75 0
+95 29 14 0
+-51 -47 -8 0
+-99 80 31 0
+-58 -14 97 0
+-97 75 -62 0
+100 97 -86 0
+36 -54 -35 0
+-20 52 -70 0
+-80 -89 -10 0
+-17 47 42 0
+35 17 40 0
+9 66 97 0
+33 -28 1 0
+99 58 -21 0
+76 51 18 0
+62 -63 -51 0
+44 91 -47 0
+-89 -67 -82 0
+22 -67 -18 0
+14 -51 1 0
+65 29 -92 0
+97 73 -65 0
+-97 -1 64 0
+-39 -12 -100 0
+7 -67 -24 0
+37 -62 20 0
+-2 73 22 0
+64 -13 34 0
+-61 -30 -34 0
+-33 -92 -54 0
+-48 -36 -13 0
+17 66 -62 0
+71 96 -89 0
+-27 84 -9 0
+48 75 -86 0
+-52 79 -21 0
+53 -63 -50 0
+-90 -70 78 0
+-58 -99 84 0
+60 6 1 0
+29 59 -11 0
+-34 -75 19 0
+65 -78 -88 0
+43 -13 60 0
+-53 -38 25 0
+-86 -12 90 0
+-53 -94 -88 0
+-90 -42 54 0
+-38 -26 22 0
+16 -5 39 0
+-71 43 -33 0
+-74 -92 -87 0
+-36 53 -4 0
+98 -68 -13 0
+-20 81 69 0
+79 -91 69 0
+-3 -25 -99 0
+-52 21 15 0
+-43 7 -12 0
+-20 45 -57 0
+-15 -81 68 0
+-91 -94 43 0
+-52 -34 -48 0
+10 -31 -62 0
+-99 -6 32 0
+-33 -9 14 0
+-18 -83 -98 0
+88 -23 13 0
+-91 99 32 0
+-40 -19 23 0
+4 7 25 0
+21 -25 -98 0
+97 73 -92 0
+10 98 -79 0
+-59 -89 -18 0
+96 -63 100 0
+36 100 30 0
+-3 14 -87 0
+-76 -33 91 0
+-53 33 -30 0
+-63 8 51 0
+-68 -64 29 0
+-12 -1 -60 0
+-92 70 -16 0
+-23 77 22 0
+-40 -10 -42 0
+19 39 33 0
+-94 48 31 0
+35 37 95 0
+-40 -42 95 0
+94 33 51 0
+4 -42 -61 0
+-67 83 -44 0
+22 70 25 0
+35 59 -85 0
+70 13 11 0
+42 -51 -76 0
+99 -54 -48 0
+-31 -72 -52 0
+-99 -23 30 0
+-61 21 62 0
+-5 -82 59 0
+-46 83 99 0
+74 55 21 0
+97 -8 -32 0
+76 51 3 0
+45 28 25 0
+49 53 91 0
+97 19 -70 0
+-27 -41 -86 0
+40 -43 27 0
+86 24 -77 0
+18 75 -37 0
+-24 18 100 0
+-71 62 -85 0
+-33 60 -94 0
+-9 -87 97 0
+69 15 98 0
+-86 47 -38 0
+30 -10 -34 0
+-65 -99 13 0
+32 -66 -1 0
+51 19 13 0
+67 -10 83 0
+77 24 -31 0
+-64 -2 -95 0
+-90 92 -17 0
+-88 70 86 0
+36 -84 19 0
+-39 -65 -37 0
+-65 39 76 0
+10 -3 27 0
+-94 -81 15 0
+89 16 7 0
+71 69 56 0
+-4 -82 6 0
+-73 -98 68 0
+-93 -72 -29 0
+-61 -68 -77 0
+87 71 -49 0
+-72 -14 -73 0
+-19 49 -66 0
+100 41 -28 0
+-89 74 47 0
+-46 -27 17 0
+85 41 58 0
+37 65 92 0
+-23 -52 -75 0
+40 -38 100 0
+50 -5 -63 0
+-29 15 30 0
+12 -70 11 0
+50 -15 74 0
+-79 6 -76 0
+-25 60 59 0
+76 32 -48 0
+-52 30 51 0
+-84 82 58 0
+-95 -86 29 0
+-24 -89 98 0
+-15 -51 33 0
+-44 -7 79 0
+-36 52 -93 0
+17 -3 85 0
+-83 -96 36 0
+81 -93 62 0
+63 -98 -24 0
+52 27 -44 0
+44 -37 54 0
+76 63 -21 0
+-22 23 91 0
+100 99 43 0
+-16 92 -61 0
+-10 79 -18 0
+88 -81 61 0
+-6 -14 -26 0
+-41 96 -60 0
+-17 -36 90 0
+-58 -5 4 0
+73 -56 -91 0
+-36 -70 -95 0
+-22 -6 87 0
+-80 -6 42 0
+95 41 99 0
+88 63 -98 0
+56 -95 -75 0
+38 -66 -53 0
+-98 61 1 0
+-61 -84 -78 0
+-67 88 -48 0
+44 -63 69 0
+84 16 94 0
+-95 -31 -10 0
+33 58 37 0
+95 83 23 0
+-15 92 -94 0
+11 94 88 0
+-53 25 52 0
+-15 -53 7 0
+87 -56 -6 0
+40 -13 -45 0
+-5 6 -48 0
+-13 64 2 0
+13 -40 74 0
+42 -77 -91 0
+-1 -26 -45 0
+-63 2 46 0
+67 -75 24 0
+-44 40 -18 0
+-5 -7 44 0
+-53 -19 32 0
+95 -40 29 0
+-62 -61 15 0
+30 -36 -54 0
+100 -3 -90 0
+75 7 -1 0
+-33 98 18 0
+1 -100 -73 0
+-30 -14 -100 0
+-67 60 -100 0
+40 -77 -61 0
+19 -16 -61 0
+49 -77 -98 0
+-86 22 -95 0
+-84 72 15 0
+-37 68 -94 0
+60 -26 -91 0
+19 11 44 0
+-98 18 -57 0
+-47 -86 -33 0
+-78 5 29 0
+47 -61 63 0
+4 100 -35 0
+82 14 -83 0
+100 52 71 0
+94 -91 44 0
+59 8 -6 0
+-45 -48 87 0
+46 76 15 0
+14 -73 85 0
+-39 76 68 0
+20 -44 19 0
+-86 35 -92 0
+10 4 9 0
+52 -31 -2 0
+60 -15 -62 0
+-40 96 42 0
+-64 -21 56 0
+96 95 -59 0
+86 42 -89 0
+82 33 36 0
+49 4 76 0
+71 61 -68 0
+76 -42 -53 0
+22 -61 7 0
+84 -64 -57 0
+54 20 69 0
+34 98 69 0
+60 100 56 0
+-77 -55 -91 0
+-8 -47 36 0
+-30 21 -28 0
+-6 -83 -52 0
+88 -44 75 0
+-74 33 62 0
+-37 -23 72 0
+79 16 59 0
+61 -20 -91 0
+-87 81 -18 0
+68 -97 5 0
+54 -96 43 0
+64 -47 -46 0
+30 13 -78 0
+95 -11 -52 0
+-85 -38 71 0
+-10 21 -27 0
+83 10 -41 0
+-87 -62 7 0
+-35 -76 41 0
+61 -72 49 0
+-63 70 -37 0
+84 5 93 0
+-18 -85 -24 0
+18 42 95 0
+-64 -100 -55 0
+58 -30 -7 0
+-30 -56 81 0
+-72 -5 -90 0
+50 4 97 0
+50 -71 -24 0
+-74 -24 -12 0
+69 -99 19 0
+55 24 -10 0
+-99 68 100 0
+20 -61 77 0
+26 39 66 0
+1 88 -35 0
+24 92 10 0
+29 34 96 0
+34 -48 68 0
+53 -17 -71 0
+-54 -55 77 0
+-74 98 5 0
+11 -59 73 0
+-14 19 49 0
+-14 -81 57 0
+74 52 66 0
+-63 -13 -37 0
+6 25 -78 0
+26 -30 -28 0
+20 40 23 0
+77 90 99 0
+-90 42 75 0
+62 -43 -66 0
+19 -80 -6 0
+13 6 4 0
+-68 86 -31 0
+-4 -1 2 0
+-19 81 -84 0
+77 16 66 0
+-34 6 -33 0
+36 1 -5 0
+-6 -13 66 0
+-2 89 85 0
+45 23 35 0
+-40 77 -41 0
+46 -81 -56 0
+-14 -89 81 0
+-84 -73 -38 0
+87 2 6 0
+-56 51 -27 0
+53 68 52 0
+-76 32 -23 0
+6 -94 66 0
+28 -48 24 0
+83 24 86 0
+80 -73 -75 0
+-66 56 24 0
+82 -18 -28 0
+-69 89 36 0
+27 5 12 0
+-94 -20 -25 0
+-56 9 -79 0
+85 -71 -6 0
+-34 -94 -67 0
+-60 -24 5 0
+-67 -90 18 0
+-83 45 -12 0
+21 96 -25 0
+-1 75 -77 0
+-60 -90 -98 0
+88 31 58 0
+8 -4 92 0
+-75 85 100 0
+-82 -11 15 0
+33 37 -35 0
+-98 -88 28 0
+-3 1 54 0
+-98 -94 3 0
+-37 75 24 0
+96 -65 39 0
+-28 92 27 0
+-5 50 20 0
+-76 41 33 0
+91 74 100 0
+-17 -21 -98 0
+93 79 84 0
+-39 -38 80 0
+98 71 -63 0
+-56 -39 -73 0
+-87 70 -17 0
+-76 17 -46 0
+-90 76 17 0
+-92 -31 82 0
+54 -16 69 0
+22 58 92 0
+-7 -17 -33 0
+31 65 -44 0
+59 -25 -8 0
+71 -32 -83 0
+-62 79 -11 0
+69 -24 68 0
+70 -6 7 0
+-91 -11 64 0
+66 -21 74 0
+2 -22 8 0
+64 44 48 0
+-73 15 -28 0
+-19 20 91 0
+-25 84 62 0
+28 35 43 0
+60 10 61 0
+-31 -13 21 0
+39 -10 -68 0
+69 16 -31 0
+-41 -35 95 0
+36 91 -73 0
+75 42 99 0
+-71 43 15 0
+-68 -50 -70 0
+50 -4 -5 0
+56 -15 77 0
+6 -33 -48 0
+-51 36 -23 0
+66 3 -7 0
+5 -51 -74 0
+-96 -50 68 0
+78 -83 59 0
+5 37 -59 0
+-84 69 -96 0
+59 8 47 0
+-85 -13 -91 0
+78 -63 51 0
+60 92 -73 0
+%
+0
+

benchmarks/uf100/uf100-010.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 99 -57 -46 0
+-91 -62 19 0
+-59 22 63 0
+-20 -26 -98 0
+6 57 88 0
+89 30 82 0
+20 -23 -94 0
+59 42 96 0
+-70 -58 48 0
+51 -59 74 0
+64 70 -33 0
+-79 -23 -88 0
+46 20 13 0
+64 -9 -8 0
+29 -26 -19 0
+6 -29 -69 0
+-3 53 -94 0
+-61 71 74 0
+23 -75 -22 0
+91 14 -22 0
+-9 -21 -15 0
+48 -61 -41 0
+-95 -12 37 0
+81 8 23 0
+99 28 22 0
+7 44 58 0
+-10 68 76 0
+-17 -4 38 0
+2 -53 -29 0
+-33 -53 93 0
+92 80 -73 0
+64 -11 -61 0
+66 77 73 0
+-25 -31 -97 0
+20 88 -4 0
+42 -33 -57 0
+-7 -46 68 0
+37 -51 5 0
+53 79 66 0
+100 -52 8 0
+80 5 -83 0
+-94 -25 -9 0
+-90 29 -44 0
+-30 90 76 0
+15 38 59 0
+-72 -21 27 0
+18 51 -70 0
+-20 -2 90 0
+60 26 -16 0
+42 -36 92 0
+22 -30 52 0
+-94 1 -60 0
+25 46 -74 0
+-42 69 96 0
+12 45 52 0
+-35 67 40 0
+-95 -9 24 0
+26 96 -100 0
+52 -72 -66 0
+-20 34 -23 0
+32 83 44 0
+55 -29 93 0
+22 -73 -17 0
+-84 49 52 0
+13 43 66 0
+92 -39 -91 0
+-73 -40 24 0
+-82 87 -75 0
+85 -3 100 0
+69 7 -66 0
+43 -32 -12 0
+-30 38 36 0
+55 -84 87 0
+-80 68 8 0
+-1 72 8 0
+-40 -50 81 0
+-47 -13 -85 0
+-82 21 -71 0
+-74 28 20 0
+-83 -8 96 0
+39 -13 51 0
+65 -10 46 0
+35 73 -32 0
+-58 -15 9 0
+-1 -77 -22 0
+98 5 -8 0
+83 89 -80 0
+-40 -73 -43 0
+-52 35 -98 0
+-75 13 69 0
+-92 -7 -41 0
+69 -38 -52 0
+-19 -6 62 0
+44 -29 -73 0
+33 -63 98 0
+-37 50 -14 0
+-41 -17 -7 0
+82 84 -78 0
+-81 87 -83 0
+38 -60 -33 0
+-43 -97 -40 0
+26 13 -5 0
+-4 86 -53 0
+36 -9 83 0
+88 100 69 0
+11 78 -25 0
+38 -59 10 0
+-12 -95 1 0
+61 12 -37 0
+54 17 97 0
+-52 -47 10 0
+-74 -35 -3 0
+-98 -89 -88 0
+-26 -14 76 0
+-60 11 -22 0
+-89 -84 6 0
+41 34 37 0
+37 15 -2 0
+-88 -38 69 0
+-68 59 -37 0
+-49 4 53 0
+-56 -42 -46 0
+5 21 -77 0
+61 -33 26 0
+-56 -63 -84 0
+61 -1 2 0
+-26 10 45 0
+34 7 -50 0
+99 74 26 0
+50 58 84 0
+33 11 -37 0
+-37 50 100 0
+-10 -56 8 0
+-53 -65 -93 0
+-100 -38 54 0
+-20 4 14 0
+47 -75 87 0
+-48 65 63 0
+-75 -76 -93 0
+64 54 -19 0
+20 57 94 0
+-70 59 -5 0
+64 53 24 0
+54 82 -22 0
+27 13 -30 0
+35 -49 23 0
+-59 51 -93 0
+23 -70 -50 0
+93 -49 -39 0
+90 -22 100 0
+85 1 -78 0
+41 87 9 0
+-31 72 -84 0
+-36 10 28 0
+-61 13 44 0
+-90 15 11 0
+-25 -62 34 0
+26 -46 32 0
+40 -72 -38 0
+75 7 5 0
+-25 -52 92 0
+35 -88 -50 0
+-55 -7 29 0
+100 41 77 0
+-88 -42 23 0
+31 81 -39 0
+-39 -32 5 0
+-24 -100 -31 0
+-82 11 -46 0
+82 -88 -25 0
+-52 -97 60 0
+45 39 35 0
+-50 30 -27 0
+-50 -94 -7 0
+79 -70 39 0
+83 24 1 0
+-45 58 40 0
+7 57 -76 0
+30 -86 -82 0
+87 -59 39 0
+30 -44 36 0
+-32 31 7 0
+-17 16 70 0
+-80 78 -92 0
+-31 100 -32 0
+81 -54 37 0
+-65 -16 -53 0
+-85 -2 78 0
+-61 74 4 0
+-26 65 16 0
+-50 15 -94 0
+-8 -95 -94 0
+-22 52 -81 0
+25 67 -48 0
+-46 45 -47 0
+-2 51 95 0
+-74 44 -20 0
+45 25 38 0
+100 -49 11 0
+-28 -23 -74 0
+55 -85 -26 0
+-75 54 6 0
+81 -65 -35 0
+-62 89 -6 0
+-1 63 -5 0
+-50 92 -73 0
+37 16 6 0
+53 -90 87 0
+70 68 50 0
+42 66 38 0
+65 94 -98 0
+77 -50 -57 0
+-72 50 58 0
+-27 18 -52 0
+9 -85 22 0
+89 81 -45 0
+5 65 52 0
+-96 74 -5 0
+56 58 -72 0
+91 -34 -77 0
+59 -46 -45 0
+98 80 25 0
+-82 -99 -23 0
+41 7 12 0
+5 70 81 0
+-75 73 89 0
+74 26 72 0
+-5 -28 -43 0
+32 -86 8 0
+48 4 13 0
+-73 -95 -11 0
+-9 -45 83 0
+1 -71 38 0
+40 93 3 0
+90 85 7 0
+-40 86 -21 0
+-8 55 36 0
+1 -36 73 0
+-55 -18 -28 0
+-61 -54 -49 0
+93 95 -47 0
+5 52 -48 0
+-42 -19 15 0
+-34 -15 77 0
+52 -32 -89 0
+12 81 -98 0
+-30 78 39 0
+11 60 40 0
+74 -73 50 0
+-91 17 60 0
+30 -47 -27 0
+-17 -1 30 0
+77 80 8 0
+51 78 -19 0
+-29 -18 100 0
+-35 -26 -81 0
+14 70 51 0
+-91 1 99 0
+-45 -67 80 0
+46 -96 25 0
+-79 -19 -47 0
+-10 93 -69 0
+-81 26 94 0
+-82 69 77 0
+-69 77 40 0
+-14 -1 42 0
+60 69 14 0
+23 -10 -74 0
+26 71 -67 0
+-46 -1 -74 0
+-8 -96 -50 0
+-28 -24 83 0
+-79 -63 6 0
+-21 -69 -22 0
+54 41 -52 0
+54 -32 -9 0
+49 -10 -61 0
+-84 -25 98 0
+98 97 69 0
+87 3 76 0
+98 3 43 0
+84 -73 40 0
+37 61 27 0
+34 -36 98 0
+38 -43 -49 0
+-24 -78 100 0
+96 66 -95 0
+-37 -46 -32 0
+-64 13 -6 0
+-8 -53 -4 0
+-53 -89 62 0
+-75 -51 10 0
+-40 -21 66 0
+42 47 -58 0
+9 -15 -25 0
+-96 -23 79 0
+1 49 -84 0
+-30 57 -89 0
+-41 70 18 0
+-70 26 39 0
+-85 -33 32 0
+-97 -90 -55 0
+48 30 -28 0
+8 -65 26 0
+-50 32 69 0
+97 -12 37 0
+-35 71 15 0
+-60 98 -44 0
+-43 -41 -33 0
+-12 15 -27 0
+85 100 64 0
+-48 62 -8 0
+77 -10 -56 0
+89 40 -29 0
+16 -20 8 0
+-94 84 9 0
+96 53 98 0
+61 91 -58 0
+5 100 93 0
+27 -35 20 0
+-44 71 3 0
+-89 23 -60 0
+-35 87 -65 0
+45 7 -76 0
+-38 67 30 0
+-77 44 -80 0
+-86 -27 48 0
+-7 40 -87 0
+-43 -50 38 0
+-18 -56 -62 0
+52 -100 45 0
+-19 -81 75 0
+-88 -60 67 0
+-36 -100 58 0
+-6 -98 -2 0
+-36 -24 -57 0
+28 74 -34 0
+-29 -27 45 0
+-4 36 -2 0
+9 -14 -79 0
+68 -16 75 0
+76 23 4 0
+95 53 -69 0
+42 52 4 0
+25 22 26 0
+54 99 22 0
+-59 98 -39 0
+-4 1 -15 0
+40 82 14 0
+-56 -50 -47 0
+87 7 -77 0
+-25 -93 95 0
+25 58 2 0
+1 69 23 0
+-40 67 97 0
+65 34 -56 0
+39 66 83 0
+35 -53 93 0
+-77 93 91 0
+47 70 -44 0
+98 -50 49 0
+78 -56 -20 0
+-46 37 -48 0
+-57 21 -60 0
+4 74 31 0
+-40 5 -97 0
+26 21 44 0
+1 -77 -64 0
+-18 -14 13 0
+-39 74 13 0
+17 61 -23 0
+1 74 87 0
+72 -20 -95 0
+27 -86 66 0
+-78 -2 9 0
+9 88 90 0
+-98 2 12 0
+-1 -17 50 0
+47 79 -3 0
+-47 -96 67 0
+-85 95 26 0
+12 23 -28 0
+53 7 90 0
+21 -49 20 0
+-89 -6 32 0
+94 46 11 0
+-45 -31 -60 0
+44 7 -73 0
+-74 -30 -23 0
+-30 -41 88 0
+-79 90 95 0
+-26 52 -45 0
+50 -67 5 0
+96 -74 -43 0
+-100 -97 36 0
+36 37 21 0
+-44 52 80 0
+86 -68 90 0
+4 41 47 0
+21 -3 78 0
+-43 97 -30 0
+16 74 37 0
+-89 95 -7 0
+82 7 14 0
+70 -49 -23 0
+-56 -100 80 0
+-42 -87 -75 0
+-18 -79 -24 0
+-39 88 11 0
+-37 64 53 0
+39 -19 16 0
+66 -77 -93 0
+-61 45 55 0
+-81 41 23 0
+-21 45 1 0
+9 -67 39 0
+42 -55 -5 0
+-9 60 16 0
+99 25 -58 0
+-59 37 10 0
+79 19 -3 0
+45 84 47 0
+21 -26 5 0
+54 88 -73 0
+-77 69 25 0
+23 7 -52 0
+-18 69 -78 0
+11 -38 19 0
+63 28 96 0
+24 15 73 0
+%
+0
+

benchmarks/uf100/uf100-0100.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 31 76 42 0
+-58 82 -83 0
+77 -24 50 0
+-24 27 -22 0
+30 -62 90 0
+-54 1 83 0
+25 67 -10 0
+89 -25 79 0
+84 -89 -65 0
+-70 2 34 0
+67 -77 5 0
+-78 96 80 0
+41 92 53 0
+57 13 -7 0
+94 88 80 0
+32 -13 79 0
+49 39 46 0
+57 -65 -40 0
+27 -41 -82 0
+-11 -56 87 0
+-93 15 45 0
+-20 99 -45 0
+-13 -85 35 0
+21 -20 58 0
+-1 -63 -76 0
+-19 46 73 0
+70 36 22 0
+84 -14 34 0
+-36 -86 -47 0
+-13 -88 62 0
+47 -93 -60 0
+-42 27 12 0
+13 25 -27 0
+-73 -79 19 0
+-85 53 -79 0
+-19 53 -38 0
+2 -41 -43 0
+68 -79 -1 0
+-89 49 92 0
+44 -67 -88 0
+-34 -12 -72 0
+90 -2 93 0
+100 33 48 0
+-99 -53 12 0
+2 34 -8 0
+51 38 -22 0
+-72 15 85 0
+-11 -47 -72 0
+-78 55 -28 0
+10 13 -28 0
+6 80 91 0
+-10 73 -31 0
+33 48 -23 0
+80 -83 33 0
+2 -81 -57 0
+-82 3 -66 0
+89 39 -40 0
+95 -66 24 0
+97 -50 -11 0
+74 -57 -63 0
+-17 67 -64 0
+-50 27 -32 0
+-66 -40 -30 0
+17 -54 48 0
+-9 -56 61 0
+-32 -2 -13 0
+88 33 79 0
+83 -88 63 0
+-11 94 -74 0
+63 30 -11 0
+-70 33 -97 0
+34 15 14 0
+-35 16 -24 0
+-18 -39 94 0
+-46 -60 44 0
+52 53 77 0
+29 -69 -18 0
+78 14 -67 0
+-1 29 33 0
+-8 65 -90 0
+-95 73 -26 0
+-75 -49 29 0
+43 -68 23 0
+4 -69 -62 0
+-66 70 -46 0
+-29 -15 -39 0
+15 -60 -9 0
+-52 95 67 0
+-8 7 -4 0
+-51 -10 -35 0
+63 94 -70 0
+-61 62 -16 0
+68 58 -62 0
+-70 39 72 0
+-38 -58 -24 0
+-28 17 82 0
+-54 79 -91 0
+-37 15 -54 0
+63 -19 24 0
+-50 29 90 0
+62 30 -60 0
+-73 81 55 0
+60 -86 -17 0
+98 -47 -85 0
+53 31 4 0
+86 66 -34 0
+-21 82 -42 0
+77 -5 -94 0
+16 -8 44 0
+90 19 22 0
+-18 -89 61 0
+-82 80 -62 0
+35 -30 -28 0
+-62 -98 31 0
+89 5 -71 0
+-38 16 -57 0
+81 93 -40 0
+-72 -47 22 0
+86 -55 -10 0
+65 -42 99 0
+-32 -99 -41 0
+66 78 -47 0
+98 -86 11 0
+31 -71 59 0
+35 -52 54 0
+-59 20 15 0
+-54 -74 89 0
+-64 -77 -90 0
+79 -27 45 0
+50 2 -84 0
+19 -94 -91 0
+45 46 -72 0
+38 -9 27 0
+1 -62 49 0
+-78 -49 -17 0
+33 71 44 0
+-21 -49 82 0
+-44 20 36 0
+93 -47 -81 0
+-57 70 -28 0
+-23 -64 -50 0
+-3 -8 84 0
+43 4 -46 0
+6 -96 45 0
+-3 -58 52 0
+-99 52 81 0
+-68 45 37 0
+62 88 -25 0
+72 -6 -71 0
+-40 55 15 0
+22 -29 -55 0
+-36 61 -38 0
+94 -73 -69 0
+-93 -52 75 0
+21 -7 81 0
+39 20 -93 0
+57 93 23 0
+23 -77 73 0
+-33 -8 17 0
+-16 -81 24 0
+-90 98 73 0
+-67 75 97 0
+-94 -26 77 0
+9 -99 40 0
+-67 -10 -95 0
+-25 49 -70 0
+-2 -98 -63 0
+-99 81 -93 0
+8 -55 -57 0
+-61 46 60 0
+-28 -61 -69 0
+85 -60 -98 0
+15 57 65 0
+65 -40 66 0
+72 48 91 0
+51 31 87 0
+19 -13 -4 0
+-1 -75 -19 0
+76 -45 -91 0
+-86 -38 25 0
+-2 21 -58 0
+34 -59 -98 0
+99 75 32 0
+-67 -15 57 0
+-35 41 61 0
+87 19 -50 0
+30 -41 48 0
+85 -75 96 0
+-29 59 50 0
+-8 50 -47 0
+98 95 -81 0
+-37 -70 29 0
+6 -82 -80 0
+-37 26 30 0
+92 -18 94 0
+-100 84 97 0
+-69 -67 6 0
+-2 -57 -83 0
+-53 -94 7 0
+27 71 35 0
+22 -8 4 0
+-55 -58 -1 0
+61 56 -8 0
+24 -90 60 0
+-47 98 10 0
+2 -39 26 0
+39 -11 72 0
+-91 -31 81 0
+64 98 -7 0
+-62 -73 -76 0
+90 -55 -31 0
+30 99 -98 0
+27 29 -99 0
+25 91 -70 0
+-9 75 70 0
+76 35 79 0
+-94 -79 -37 0
+-60 6 3 0
+-30 -37 20 0
+-97 -77 -7 0
+-90 37 87 0
+6 37 -15 0
+16 87 100 0
+-47 -75 49 0
+99 70 -93 0
+57 -26 90 0
+-79 98 -69 0
+-87 -55 83 0
+99 -20 -1 0
+-64 -85 -44 0
+-10 -46 -5 0
+-31 -67 96 0
+-95 46 -90 0
+4 -31 -82 0
+78 -40 51 0
+2 5 -86 0
+-4 34 42 0
+34 28 -47 0
+-85 8 -9 0
+-33 89 26 0
+24 12 27 0
+84 22 -64 0
+-27 -54 25 0
+-52 62 36 0
+-47 60 36 0
+95 -66 -57 0
+52 -59 97 0
+12 -10 71 0
+65 -35 9 0
+-47 43 95 0
+-28 10 -3 0
+-60 -82 35 0
+72 9 28 0
+-89 9 45 0
+32 56 -82 0
+-63 65 6 0
+-42 -8 18 0
+94 -35 -23 0
+-31 -65 -76 0
+-15 93 -40 0
+-93 81 -42 0
+-34 -87 -98 0
+-65 -56 -96 0
+53 -8 -37 0
+-12 -97 90 0
+-28 -84 88 0
+-60 -16 -19 0
+19 30 37 0
+86 -69 20 0
+19 -9 -98 0
+16 -88 -74 0
+-36 -16 70 0
+-35 91 -66 0
+84 91 51 0
+6 31 56 0
+-93 -55 -3 0
+-21 93 75 0
+-27 -82 39 0
+74 37 34 0
+71 45 77 0
+42 41 70 0
+-4 28 -20 0
+-27 45 -48 0
+8 10 -36 0
+-87 5 -21 0
+79 73 9 0
+-76 22 -43 0
+61 -27 6 0
+8 100 -53 0
+19 -28 91 0
+8 69 95 0
+-32 -92 34 0
+36 -47 -61 0
+84 63 -52 0
+23 -25 20 0
+36 -71 -79 0
+-43 -18 -86 0
+-11 -28 -19 0
+-24 -53 36 0
+-69 12 66 0
+-98 -61 -100 0
+-71 34 -4 0
+29 -21 -24 0
+-20 -16 45 0
+-97 60 -47 0
+-91 46 33 0
+-76 92 -58 0
+-75 77 -88 0
+90 -43 -96 0
+69 -94 -48 0
+87 47 -41 0
+-43 -12 55 0
+-68 -65 79 0
+35 -53 44 0
+-18 -57 -35 0
+60 -58 -37 0
+63 20 -84 0
+-20 87 39 0
+99 77 53 0
+83 -24 -97 0
+8 48 26 0
+-16 11 22 0
+73 48 -29 0
+-12 -44 -47 0
+5 -69 -77 0
+-68 94 -12 0
+95 -53 -71 0
+-59 24 -46 0
+57 46 35 0
+56 14 -88 0
+96 -81 67 0
+-68 56 39 0
+43 -31 -84 0
+-86 10 8 0
+-44 33 -15 0
+-72 -27 -54 0
+-47 -68 13 0
+23 94 50 0
+-80 -8 25 0
+15 40 76 0
+-17 -86 47 0
+27 -12 -13 0
+59 20 -58 0
+23 -5 -89 0
+-91 7 24 0
+86 53 -25 0
+-79 -51 -2 0
+56 -48 19 0
+-95 79 49 0
+-67 -17 -49 0
+-30 -68 -38 0
+44 -79 -11 0
+-45 26 48 0
+-7 33 83 0
+97 -83 25 0
+-29 -3 -74 0
+26 1 52 0
+-36 -90 -47 0
+-87 59 19 0
+77 -10 -16 0
+-7 83 92 0
+54 74 -49 0
+-27 46 85 0
+-59 -16 95 0
+12 -60 -19 0
+16 67 55 0
+55 1 -76 0
+-97 32 -33 0
+17 64 -77 0
+21 -52 -19 0
+-11 95 -46 0
+67 -56 -93 0
+-29 55 30 0
+-22 -52 98 0
+-57 84 -91 0
+56 -33 -64 0
+-94 63 -21 0
+84 -34 -33 0
+48 16 -20 0
+-83 71 -68 0
+43 2 22 0
+-71 -96 -82 0
+69 -66 20 0
+-70 -27 30 0
+72 54 -14 0
+29 -69 -61 0
+68 46 59 0
+-36 5 -6 0
+-70 -76 -12 0
+-42 -37 55 0
+-4 33 75 0
+-21 -52 95 0
+-5 -93 41 0
+30 74 37 0
+70 75 56 0
+39 53 -51 0
+50 -26 -9 0
+79 -1 -89 0
+-45 90 -61 0
+-1 87 73 0
+-74 -50 -25 0
+-11 -5 -91 0
+-33 -100 -75 0
+-97 -49 22 0
+78 -53 93 0
+7 -13 -88 0
+13 85 -71 0
+-89 73 70 0
+24 -21 79 0
+-65 76 -97 0
+-71 15 73 0
+-25 -58 -32 0
+66 48 -44 0
+66 -35 -89 0
+-89 44 -62 0
+46 72 84 0
+-65 55 86 0
+68 -16 93 0
+-80 -16 38 0
+55 48 -61 0
+-85 -79 -33 0
+-97 -63 -17 0
+27 82 20 0
+-18 48 -61 0
+-40 -56 -37 0
+39 -68 -30 0
+-3 -27 -8 0
+12 -13 -56 0
+54 -68 36 0
+90 93 -99 0
+%
+0
+

benchmarks/uf100/uf100-011.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 100 -48 -17 0
+-63 -98 13 0
+-78 -30 -91 0
+-12 7 -3 0
+91 -70 -27 0
+-36 -57 -99 0
+24 -37 68 0
+50 69 -74 0
+25 51 -72 0
+20 -26 63 0
+-98 -4 76 0
+65 80 -87 0
+76 65 -45 0
+-15 -28 -36 0
+80 74 -96 0
+61 17 69 0
+-87 77 3 0
+-50 85 -82 0
+79 49 -13 0
+-84 -15 -41 0
+44 -17 -77 0
+36 40 -65 0
+56 -62 -58 0
+23 34 -40 0
+3 31 89 0
+-4 -53 62 0
+68 100 -54 0
+-5 93 -28 0
+-55 -52 -17 0
+-69 90 94 0
+-1 36 57 0
+77 83 -20 0
+97 -19 -50 0
+7 36 31 0
+-88 -98 7 0
+85 55 -76 0
+-61 93 -73 0
+-38 20 -6 0
+-65 -50 -22 0
+12 61 49 0
+59 -26 -57 0
+-25 27 -67 0
+-84 44 -9 0
+-75 -95 -1 0
+-48 1 -34 0
+-98 78 -100 0
+-28 36 -93 0
+-83 17 -43 0
+42 -81 -68 0
+16 25 -58 0
+24 -18 -55 0
+-90 -100 2 0
+81 -76 -51 0
+-96 8 37 0
+-20 66 -37 0
+54 -38 75 0
+-74 50 46 0
+-11 12 -15 0
+-18 -31 89 0
+66 -13 4 0
+60 -44 56 0
+81 26 -67 0
+-65 -11 9 0
+60 90 -73 0
+-88 9 -79 0
+-9 71 -13 0
+81 86 -89 0
+-45 -76 -1 0
+-96 -15 62 0
+35 50 13 0
+-83 50 -94 0
+58 95 -84 0
+37 87 71 0
+-9 36 39 0
+-75 -40 -51 0
+10 35 -41 0
+-3 87 -50 0
+-81 70 79 0
+76 -15 -54 0
+-17 60 98 0
+-59 -57 85 0
+55 63 1 0
+-96 -30 3 0
+92 -57 24 0
+4 -88 70 0
+51 14 73 0
+49 -68 95 0
+-83 67 -73 0
+95 -32 -10 0
+-28 -81 69 0
+-13 -33 -38 0
+18 -17 -19 0
+56 -49 -28 0
+29 26 -91 0
+-74 -83 -41 0
+-83 -97 -2 0
+-85 82 -71 0
+-52 96 15 0
+60 58 35 0
+-22 77 -20 0
+26 -30 80 0
+79 -82 -26 0
+8 30 -68 0
+-32 68 -54 0
+3 -39 -34 0
+-6 -25 11 0
+-30 -89 55 0
+87 96 -94 0
+40 -72 -43 0
+9 28 33 0
+37 53 23 0
+52 34 -19 0
+33 99 -82 0
+-16 -48 58 0
+-58 -62 75 0
+4 -30 -56 0
+-57 3 93 0
+62 -42 4 0
+-29 83 58 0
+34 -100 -73 0
+-11 94 95 0
+25 -77 -49 0
+23 -14 -99 0
+-37 -86 -49 0
+-6 5 -90 0
+43 -23 -73 0
+83 13 69 0
+-88 -53 -34 0
+-52 16 75 0
+-90 -15 -51 0
+58 -35 -85 0
+-22 -55 86 0
+11 -74 69 0
+35 11 -63 0
+56 -100 -86 0
+-69 -36 -13 0
+26 -87 39 0
+-28 88 -98 0
+43 -66 -68 0
+-76 30 -78 0
+-40 -4 -91 0
+-37 -83 42 0
+-100 21 6 0
+54 -59 -3 0
+-100 39 7 0
+33 -40 45 0
+79 29 -83 0
+39 -3 97 0
+-81 -53 72 0
+-60 -75 -73 0
+-7 85 13 0
+52 86 33 0
+11 -44 38 0
+-20 -68 -90 0
+-25 -10 -39 0
+-71 82 -75 0
+88 84 -69 0
+-57 28 18 0
+32 55 73 0
+85 -70 34 0
+-14 38 90 0
+71 9 6 0
+13 -86 -52 0
+36 11 -41 0
+-32 17 55 0
+-73 54 -60 0
+-85 -12 89 0
+-14 -64 -2 0
+-51 29 92 0
+77 70 -39 0
+53 -8 -32 0
+-92 54 85 0
+-97 58 -99 0
+-80 -73 -21 0
+94 -40 -27 0
+10 24 68 0
+-14 27 92 0
+34 4 93 0
+23 -82 -87 0
+1 -46 -90 0
+-89 88 84 0
+-93 43 -46 0
+20 74 -56 0
+26 -28 -39 0
+-63 -72 36 0
+-13 87 1 0
+-15 36 71 0
+-13 -39 -85 0
+-25 -76 -16 0
+-54 51 -58 0
+2 16 -44 0
+31 -27 23 0
+-12 -100 81 0
+85 -92 -7 0
+87 -8 45 0
+2 -99 -64 0
+-32 31 -2 0
+-96 43 -88 0
+8 23 -46 0
+-9 -11 8 0
+-1 57 2 0
+39 -33 -32 0
+28 -83 6 0
+69 -66 -68 0
+14 88 -1 0
+25 42 12 0
+-28 -44 47 0
+23 12 -15 0
+73 95 39 0
+31 23 5 0
+-87 -68 -86 0
+-12 -22 35 0
+91 4 -30 0
+80 5 -51 0
+35 76 82 0
+-85 -94 -71 0
+-5 -10 97 0
+-54 95 45 0
+-39 -32 51 0
+91 -52 93 0
+-15 53 -12 0
+47 50 -9 0
+58 66 94 0
+-2 64 51 0
+-63 11 79 0
+-74 56 89 0
+-84 88 -83 0
+-91 -88 -61 0
+-4 91 -49 0
+-81 -6 79 0
+-95 35 76 0
+-17 -2 4 0
+-95 -83 21 0
+-40 70 1 0
+57 -4 50 0
+55 58 -45 0
+46 -58 -65 0
+83 52 41 0
+14 45 -77 0
+57 90 -4 0
+-17 80 -24 0
+-24 55 -22 0
+-46 -86 31 0
+-94 2 81 0
+-70 -72 4 0
+-40 -94 7 0
+28 -78 -71 0
+-28 -12 59 0
+-94 -93 -49 0
+-89 32 36 0
+19 45 -7 0
+42 -36 39 0
+85 -13 17 0
+91 65 -7 0
+3 28 1 0
+-51 -38 57 0
+5 -94 -56 0
+2 -90 -77 0
+-35 -25 -98 0
+76 91 -68 0
+64 47 -24 0
+-38 14 -77 0
+54 -31 45 0
+20 -10 -30 0
+-84 -59 51 0
+-35 38 48 0
+-93 -61 -8 0
+-39 -22 6 0
+88 -7 40 0
+90 49 16 0
+64 55 -46 0
+42 -2 53 0
+11 -27 -65 0
+-27 -83 -68 0
+100 77 5 0
+-23 -81 -80 0
+60 -34 -91 0
+56 94 -5 0
+80 37 -82 0
+4 3 -47 0
+34 39 44 0
+-2 -66 -70 0
+-71 -33 -46 0
+-74 -33 -91 0
+-26 -83 97 0
+-35 24 -52 0
+-15 38 24 0
+-37 -100 -35 0
+37 49 -19 0
+22 29 -80 0
+-31 35 95 0
+-41 29 -69 0
+-66 50 -97 0
+86 -68 19 0
+-2 17 -52 0
+52 65 87 0
+77 -88 29 0
+42 17 91 0
+10 2 -90 0
+51 -7 2 0
+54 -39 1 0
+-40 62 -35 0
+-10 -48 3 0
+22 96 21 0
+-95 -75 33 0
+32 -31 59 0
+79 -10 5 0
+100 -87 58 0
+22 8 -40 0
+-67 13 39 0
+-20 -40 46 0
+22 -50 25 0
+-37 -63 -89 0
+-38 87 83 0
+-41 -95 13 0
+94 -14 61 0
+-55 14 81 0
+-81 -76 -8 0
+45 -8 -59 0
+28 26 -81 0
+61 98 -89 0
+53 -91 93 0
+-78 50 -8 0
+57 -65 -86 0
+-3 -20 -96 0
+58 21 97 0
+26 94 -25 0
+-51 -4 -44 0
+37 -45 28 0
+-92 63 -40 0
+-86 4 -19 0
+16 -76 -54 0
+-34 45 -84 0
+-40 -41 -16 0
+87 54 -40 0
+25 27 89 0
+-3 -25 14 0
+36 -98 -53 0
+90 -13 -97 0
+83 -67 -14 0
+-7 -16 -80 0
+33 62 -13 0
+-54 75 -7 0
+62 60 68 0
+-7 -32 -71 0
+-14 -65 73 0
+-34 67 52 0
+-4 -18 -12 0
+38 -27 -33 0
+54 -75 -83 0
+-2 -87 -33 0
+79 92 -53 0
+35 47 -14 0
+-20 -59 -7 0
+-4 17 49 0
+-54 44 -7 0
+72 97 -57 0
+20 61 -45 0
+-12 -26 -18 0
+-82 6 -40 0
+20 90 68 0
+77 4 -90 0
+-20 -91 -33 0
+-65 23 25 0
+74 82 -18 0
+74 -68 -55 0
+-74 -51 -65 0
+-51 71 -84 0
+84 -87 3 0
+21 -43 85 0
+-4 -31 -1 0
+-19 46 -25 0
+-78 60 -46 0
+42 27 56 0
+49 -56 67 0
+-67 -97 54 0
+-42 -74 -71 0
+-41 -35 -38 0
+55 -38 7 0
+34 -32 -96 0
+-25 -31 87 0
+-3 39 -15 0
+-52 46 6 0
+-70 -87 40 0
+17 30 53 0
+-2 55 48 0
+30 36 -83 0
+15 61 -33 0
+-22 -20 50 0
+83 12 76 0
+-52 27 -61 0
+-44 29 26 0
+2 98 45 0
+43 -66 59 0
+85 -74 -80 0
+-72 24 47 0
+14 -83 68 0
+-53 -71 2 0
+-6 34 -14 0
+69 21 48 0
+-35 -11 70 0
+-20 95 -90 0
+-92 -87 30 0
+-40 -90 -55 0
+-29 -22 -12 0
+-22 -5 62 0
+-98 -5 -37 0
+-47 -83 57 0
+-97 -15 -30 0
+-43 -97 -5 0
+-5 -94 -79 0
+8 -82 -68 0
+-15 -16 43 0
+12 88 -32 0
+23 83 -97 0
+-2 40 63 0
+43 -13 -28 0
+71 12 13 0
+-54 91 -62 0
+18 13 58 0
+-46 89 -25 0
+-6 -63 79 0
+-34 -70 -62 0
+30 -64 53 0
+-41 -6 -72 0
+-31 43 87 0
+23 42 84 0
+51 37 -13 0
+-4 -42 48 0
+71 -6 47 0
+%
+0
+

benchmarks/uf100/uf100-012.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -16 -31 -93 0
+90 71 2 0
+22 33 17 0
+-80 66 -9 0
+100 -28 -86 0
+-92 83 18 0
+-62 -25 -74 0
+93 11 10 0
+-20 7 45 0
+-91 63 -100 0
+-84 13 5 0
+-30 73 -81 0
+-85 -37 68 0
+-31 -96 -15 0
+-90 -78 14 0
+-76 53 57 0
+-87 50 78 0
+-25 28 58 0
+1 52 30 0
+-66 16 -94 0
+-23 -80 17 0
+-83 47 87 0
+82 39 -56 0
+72 32 -29 0
+18 -13 -70 0
+-74 -14 54 0
+27 76 -61 0
+-42 -17 14 0
+74 27 76 0
+57 -45 36 0
+-1 30 41 0
+68 -46 9 0
+4 -100 60 0
+61 -70 -42 0
+-60 -28 -14 0
+-22 54 98 0
+95 76 63 0
+47 8 21 0
+-21 85 -86 0
+31 -81 85 0
+12 -96 -92 0
+-28 -52 -76 0
+11 1 88 0
+48 -28 96 0
+-91 -20 -98 0
+14 -75 68 0
+-6 12 77 0
+60 13 32 0
+-59 92 -66 0
+-71 -16 75 0
+40 6 -12 0
+33 -17 8 0
+-40 57 -22 0
+-10 62 -57 0
+31 -87 -98 0
+-42 95 94 0
+-50 34 21 0
+-66 -83 -75 0
+52 64 -41 0
+-90 -69 -43 0
+-76 -15 -91 0
+-74 -17 -27 0
+-12 39 51 0
+65 -78 69 0
+-61 76 -3 0
+38 64 -91 0
+-79 48 -9 0
+-85 -60 29 0
+36 63 2 0
+1 -25 85 0
+-3 24 97 0
+-76 -9 -75 0
+-62 66 54 0
+24 72 2 0
+34 12 -74 0
+51 17 84 0
+75 -85 22 0
+-44 30 68 0
+36 -44 -75 0
+-87 1 98 0
+21 70 28 0
+18 91 -21 0
+42 -83 19 0
+-13 -15 82 0
+-74 -38 -51 0
+82 20 -38 0
+-45 -42 -66 0
+22 67 73 0
+44 60 94 0
+-4 50 -93 0
+-56 -67 -100 0
+-9 32 -99 0
+28 -34 -50 0
+12 8 -55 0
+48 43 -16 0
+3 72 30 0
+-57 45 -52 0
+-38 47 -99 0
+82 -59 71 0
+3 -11 -52 0
+81 -53 -40 0
+-30 -11 20 0
+46 -4 84 0
+-7 73 -89 0
+87 11 63 0
+6 9 66 0
+21 48 -32 0
+-78 75 -2 0
+-92 25 -65 0
+-33 88 85 0
+-7 -31 21 0
+94 97 86 0
+22 -14 89 0
+-16 68 31 0
+54 -80 20 0
+-50 -81 -76 0
+-8 -47 -48 0
+-8 93 -98 0
+3 31 -41 0
+-66 64 68 0
+30 51 -22 0
+56 29 -22 0
+-88 30 86 0
+-58 -28 32 0
+-86 28 6 0
+94 43 -58 0
+91 4 8 0
+-5 -94 -59 0
+90 37 -12 0
+-64 -20 1 0
+77 -65 55 0
+14 -71 6 0
+51 -86 -6 0
+92 -65 -20 0
+-77 50 73 0
+90 97 -10 0
+-47 -45 60 0
+-64 16 27 0
+-53 17 -67 0
+-27 -97 3 0
+-44 63 -19 0
+42 54 -95 0
+-43 70 77 0
+71 -92 17 0
+-90 -91 33 0
+14 -34 -68 0
+-83 28 29 0
+39 72 5 0
+16 11 -34 0
+-68 37 -88 0
+-5 -43 -11 0
+-48 58 -25 0
+12 -74 -26 0
+-58 4 76 0
+-89 3 -60 0
+-55 -8 31 0
+-62 28 -63 0
+-40 16 -72 0
+30 -89 -63 0
+-29 69 1 0
+77 -100 -10 0
+-13 26 17 0
+74 51 -37 0
+-5 -45 56 0
+-66 -80 5 0
+-68 -46 50 0
+-67 66 -40 0
+5 -15 1 0
+-8 65 61 0
+99 -98 -91 0
+53 31 -4 0
+-17 -76 -22 0
+7 64 78 0
+-23 -13 2 0
+-95 -75 -31 0
+44 31 25 0
+4 50 -9 0
+-89 12 32 0
+2 42 49 0
+-37 19 -100 0
+-61 -47 8 0
+19 98 -90 0
+94 -12 7 0
+61 -79 -66 0
+35 -18 9 0
+11 46 -59 0
+-58 -50 47 0
+-70 -85 -48 0
+-55 40 38 0
+99 40 36 0
+-43 70 -6 0
+-18 50 -8 0
+-6 -94 65 0
+-25 43 -66 0
+89 6 -27 0
+-71 81 21 0
+34 58 -70 0
+-21 -27 -89 0
+-12 -3 19 0
+-65 -53 -32 0
+-43 47 -50 0
+-84 -56 -47 0
+48 18 -94 0
+12 -14 76 0
+56 -93 -88 0
+-90 16 -6 0
+-37 -95 43 0
+-37 8 -4 0
+84 24 -51 0
+-70 71 -83 0
+13 -8 68 0
+-15 -97 -100 0
+-67 -23 99 0
+-46 -78 33 0
+-87 61 18 0
+-21 30 44 0
+-94 64 -1 0
+-84 -87 10 0
+91 -2 -82 0
+-70 -84 -34 0
+-23 -75 81 0
+-70 56 93 0
+-58 33 -100 0
+-72 5 -57 0
+-27 -96 -38 0
+-11 -6 66 0
+20 41 84 0
+25 70 -66 0
+79 -9 84 0
+90 89 -7 0
+-19 58 -95 0
+-12 -69 6 0
+-29 6 87 0
+-74 8 -32 0
+-69 -33 82 0
+-64 -78 88 0
+24 -74 -4 0
+47 -98 89 0
+-58 66 -26 0
+-83 -92 -2 0
+-94 -31 -39 0
+17 12 73 0
+-5 88 40 0
+11 -79 98 0
+6 51 -12 0
+-67 -9 5 0
+6 9 78 0
+31 -37 -59 0
+-35 37 88 0
+-77 -54 -20 0
+-50 -77 7 0
+59 -71 -12 0
+55 -28 -98 0
+-5 -86 -92 0
+100 33 50 0
+17 65 -95 0
+27 77 31 0
+-99 -68 55 0
+51 -85 91 0
+-39 -76 -80 0
+7 12 -59 0
+-61 -54 92 0
+-96 33 -74 0
+-43 -99 70 0
+24 51 -95 0
+20 -56 48 0
+-81 51 78 0
+-91 45 -76 0
+43 -79 -88 0
+28 88 -13 0
+-12 20 13 0
+-83 -21 54 0
+-3 84 -48 0
+-67 91 62 0
+16 -30 14 0
+-85 64 -33 0
+-1 -6 -93 0
+58 69 68 0
+88 -14 6 0
+-76 84 -37 0
+2 -97 -53 0
+-7 95 82 0
+-83 7 -17 0
+-66 99 78 0
+78 24 30 0
+-4 13 37 0
+33 -54 -25 0
+-62 -35 -80 0
+42 51 89 0
+-66 99 -60 0
+-36 -17 85 0
+2 5 85 0
+-100 -80 -71 0
+-69 100 7 0
+-95 -85 26 0
+26 -15 55 0
+42 88 32 0
+63 -14 -30 0
+-90 61 87 0
+24 -13 -91 0
+89 92 -85 0
+70 -44 -59 0
+-52 -33 -86 0
+-68 -56 -39 0
+-60 76 69 0
+21 -14 27 0
+76 27 73 0
+-7 -79 75 0
+70 -27 97 0
+64 -41 25 0
+-67 12 64 0
+-23 94 -46 0
+38 35 53 0
+53 96 39 0
+99 -66 -60 0
+74 -65 -63 0
+56 -81 73 0
+75 13 -35 0
+-38 77 -56 0
+-95 26 24 0
+-4 -23 86 0
+46 14 -24 0
+-19 90 11 0
+-14 54 12 0
+-28 -24 64 0
+-72 81 -35 0
+100 92 8 0
+22 -28 12 0
+-66 -95 81 0
+-16 91 34 0
+-92 13 27 0
+-70 29 28 0
+14 66 -62 0
+-11 41 -70 0
+-3 94 14 0
+-74 47 -15 0
+20 -86 81 0
+-97 91 84 0
+46 45 -70 0
+95 36 67 0
+32 -91 -48 0
+-98 -11 50 0
+-97 54 -17 0
+-10 -57 97 0
+53 -67 -64 0
+-21 -5 -72 0
+-33 49 72 0
+9 24 -83 0
+-76 -14 50 0
+-1 -47 -88 0
+46 -87 67 0
+-79 -88 -66 0
+-80 77 16 0
+55 78 33 0
+26 51 72 0
+75 -61 -24 0
+58 56 66 0
+16 86 12 0
+-50 2 91 0
+-8 31 92 0
+16 -19 68 0
+18 1 83 0
+-57 92 29 0
+38 40 -32 0
+28 76 -64 0
+-22 -38 -37 0
+-79 -14 -82 0
+79 -11 81 0
+-48 -37 59 0
+52 -84 -78 0
+85 -11 35 0
+-3 51 -45 0
+-74 -91 10 0
+73 45 31 0
+-76 -84 11 0
+-76 -84 -43 0
+-99 6 18 0
+57 8 26 0
+82 -50 -79 0
+-45 50 63 0
+64 16 -19 0
+-79 -11 96 0
+-50 5 -38 0
+-41 59 50 0
+-98 82 91 0
+17 37 44 0
+-100 -59 -96 0
+7 -2 97 0
+-15 -2 -63 0
+-92 52 -77 0
+-8 21 -35 0
+-68 42 -41 0
+-56 -44 -94 0
+57 -2 56 0
+-15 58 -61 0
+88 -47 86 0
+5 65 69 0
+37 84 48 0
+85 92 36 0
+49 26 -59 0
+-75 4 45 0
+-87 -30 6 0
+60 11 -17 0
+-41 -26 -43 0
+79 14 -80 0
+-35 -98 99 0
+20 -45 53 0
+-58 -59 -39 0
+-25 -6 -5 0
+22 -61 84 0
+-96 33 -5 0
+-17 -30 7 0
+97 -13 64 0
+14 -12 34 0
+-88 1 -78 0
+-77 -96 7 0
+44 -6 48 0
+56 72 15 0
+-47 19 -12 0
+-98 -25 -90 0
+-50 -73 -87 0
+75 97 -81 0
+24 2 27 0
+38 68 -52 0
+39 46 13 0
+20 70 80 0
+-81 1 -31 0
+18 -46 -79 0
+77 -21 67 0
+16 8 -61 0
+%
+0
+

benchmarks/uf100/uf100-013.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 5 -10 -95 0
+-47 35 -51 0
+-88 -77 59 0
+-51 10 -23 0
+45 70 91 0
+-1 -19 54 0
+-48 15 -50 0
+57 -2 59 0
+27 46 34 0
+42 -49 13 0
+76 55 46 0
+-43 -98 29 0
+75 -53 44 0
+-58 94 -84 0
+35 85 -36 0
+74 92 -45 0
+-33 -64 -92 0
+4 -30 40 0
+-86 20 100 0
+-58 -45 27 0
+84 -66 -36 0
+23 -18 -20 0
+2 83 -4 0
+48 -16 -86 0
+91 44 42 0
+-61 20 -99 0
+-52 -70 -1 0
+46 85 -62 0
+16 74 -7 0
+98 12 -36 0
+-72 -90 92 0
+-54 37 -9 0
+-33 53 77 0
+-84 18 -76 0
+83 -16 8 0
+-90 -27 25 0
+19 50 -47 0
+-19 36 8 0
+-98 13 27 0
+-69 85 60 0
+13 -92 41 0
+-47 91 -87 0
+-49 37 -26 0
+-65 30 -66 0
+-35 72 -53 0
+9 -60 47 0
+-86 44 9 0
+-63 86 -64 0
+41 -6 26 0
+75 31 100 0
+82 -34 8 0
+-47 68 -48 0
+83 -3 71 0
+-43 31 17 0
+-97 11 -43 0
+-45 20 -1 0
+56 94 -50 0
+-89 -32 -93 0
+-72 -21 13 0
+1 -86 -60 0
+11 -27 -17 0
+93 35 58 0
+33 -27 39 0
+7 58 38 0
+68 -46 -13 0
+24 100 22 0
+-4 3 -35 0
+68 78 -99 0
+-23 9 -42 0
+-87 95 33 0
+94 -46 21 0
+16 89 -34 0
+22 17 -57 0
+5 46 -68 0
+-34 -93 90 0
+88 85 57 0
+-39 -17 -31 0
+51 88 96 0
+67 -14 -64 0
+29 -93 -62 0
+-30 -46 38 0
+-28 -93 55 0
+37 16 9 0
+52 90 -30 0
+85 -52 82 0
+-99 86 -37 0
+-11 -33 29 0
+6 14 -57 0
+90 26 -3 0
+90 -100 74 0
+-35 -67 99 0
+-46 62 -72 0
+-23 -36 83 0
+-54 -64 -45 0
+48 -58 -93 0
+34 -29 -28 0
+72 46 -39 0
+-11 43 -5 0
+-12 76 42 0
+49 -79 -68 0
+2 -34 -91 0
+7 -37 -36 0
+15 -90 98 0
+-97 95 38 0
+99 5 -16 0
+-42 38 -67 0
+77 40 93 0
+-36 -9 -45 0
+-51 86 -60 0
+-36 -91 51 0
+-17 32 -95 0
+-63 -74 -44 0
+-21 -1 -36 0
+25 79 60 0
+-48 50 35 0
+26 41 -61 0
+71 -90 -69 0
+5 -94 -62 0
+-40 93 32 0
+-44 -53 96 0
+-7 -76 -62 0
+62 -67 -78 0
+-91 86 45 0
+6 -66 5 0
+-84 -9 63 0
+-100 -94 -89 0
+49 -23 51 0
+77 -43 17 0
+34 1 -9 0
+48 23 -82 0
+23 -2 62 0
+95 12 -45 0
+-76 14 39 0
+34 -69 43 0
+-55 -95 -97 0
+-87 -99 27 0
+92 73 -93 0
+12 -24 -27 0
+-37 28 -94 0
+-94 -88 -61 0
+56 39 82 0
+-28 -90 22 0
+-76 -24 -36 0
+-15 9 -90 0
+-87 -31 -16 0
+33 -22 29 0
+-44 86 35 0
+75 25 57 0
+-6 18 -48 0
+-51 -98 21 0
+-39 8 -26 0
+13 66 69 0
+81 5 44 0
+76 20 -63 0
+14 65 71 0
+-38 70 -53 0
+46 -50 -40 0
+-33 78 -74 0
+-22 91 8 0
+57 -27 87 0
+72 -98 86 0
+98 6 -73 0
+-6 52 -47 0
+-67 49 -52 0
+-96 89 -92 0
+-98 87 50 0
+-7 8 15 0
+-49 51 86 0
+57 -97 -62 0
+-73 66 -82 0
+-16 45 -83 0
+-75 35 2 0
+24 -63 97 0
+23 -15 -84 0
+-95 59 -58 0
+74 -50 37 0
+14 13 -31 0
+26 90 -74 0
+57 -62 23 0
+-16 78 -74 0
+-27 9 29 0
+93 -61 19 0
+-100 89 -35 0
+-73 80 43 0
+-11 35 3 0
+-64 -35 -47 0
+98 91 55 0
+-61 -14 6 0
+77 -59 8 0
+45 64 -62 0
+85 11 5 0
+-26 100 93 0
+99 -76 20 0
+33 -47 65 0
+68 -10 81 0
+100 -41 40 0
+-7 -99 -42 0
+6 -78 33 0
+-32 -15 50 0
+-13 -23 -24 0
+-22 -51 -21 0
+2 -61 -91 0
+100 -66 48 0
+-35 22 -44 0
+99 30 -21 0
+3 44 -24 0
+16 7 -39 0
+77 -49 -64 0
+-53 -16 -77 0
+94 98 23 0
+88 23 -90 0
+90 -61 100 0
+-27 -43 -98 0
+45 19 -94 0
+14 9 90 0
+-82 11 -32 0
+-65 11 37 0
+12 -65 47 0
+-88 99 32 0
+-74 -32 -54 0
+73 50 87 0
+81 85 -18 0
+-21 -61 -68 0
+58 -74 -12 0
+-12 -24 -11 0
+46 -42 -74 0
+30 -47 -100 0
+68 55 -76 0
+16 82 24 0
+-85 31 40 0
+-83 -51 72 0
+38 -30 -81 0
+-92 -44 -31 0
+19 95 -37 0
+-58 6 -86 0
+-28 84 40 0
+34 77 70 0
+-90 -5 -20 0
+91 -63 -11 0
+-91 -90 52 0
+15 74 82 0
+-48 90 91 0
+-51 -7 -26 0
+-45 70 57 0
+-22 -93 31 0
+-15 96 95 0
+18 57 -98 0
+-44 69 -6 0
+64 85 -55 0
+61 50 91 0
+49 26 7 0
+-63 92 12 0
+-14 79 17 0
+-47 3 56 0
+27 3 -62 0
+29 86 -17 0
+-49 -93 -43 0
+-70 -77 31 0
+87 -6 -51 0
+54 98 95 0
+6 -43 17 0
+73 -26 40 0
+-67 56 79 0
+-47 -29 44 0
+-90 25 13 0
+16 -45 70 0
+79 -39 -73 0
+-19 21 -13 0
+-35 -65 -83 0
+94 52 78 0
+33 -52 62 0
+50 -62 67 0
+-79 -98 -41 0
+47 30 -23 0
+-83 2 -37 0
+77 41 24 0
+66 92 69 0
+-52 -92 45 0
+-51 -31 -69 0
+-59 42 -78 0
+-68 79 -25 0
+-98 83 -59 0
+-13 -66 64 0
+-97 -9 78 0
+41 40 -79 0
+-2 -60 -27 0
+-91 -58 52 0
+70 -38 86 0
+-24 -4 11 0
+-29 26 47 0
+-62 65 -75 0
+46 -99 18 0
+-72 9 -26 0
+22 -9 69 0
+-38 -19 41 0
+32 -41 -11 0
+-73 40 50 0
+-31 13 29 0
+-15 33 42 0
+99 -79 54 0
+-86 -94 -73 0
+-48 -71 8 0
+18 91 -62 0
+80 61 6 0
+55 -43 -26 0
+41 -68 -81 0
+-81 11 50 0
+-37 -27 1 0
+-72 -52 -9 0
+24 27 -95 0
+37 -76 44 0
+97 -69 18 0
+-56 -94 52 0
+4 64 77 0
+-64 65 76 0
+-35 -51 -87 0
+85 64 44 0
+-29 65 -94 0
+-5 24 -48 0
+30 -100 -53 0
+-16 -93 -2 0
+-56 -47 20 0
+-87 20 -14 0
+-72 -64 47 0
+-83 -99 -87 0
+2 48 -68 0
+-80 73 -97 0
+20 -17 71 0
+-32 56 -74 0
+-13 -91 72 0
+53 -80 -74 0
+-71 -62 -65 0
+-20 80 -13 0
+-1 44 -52 0
+47 35 52 0
+45 87 -9 0
+-11 78 52 0
+-71 -64 92 0
+79 54 -47 0
+91 -75 4 0
+-71 -38 24 0
+69 67 -8 0
+33 -12 -16 0
+-27 73 -24 0
+42 94 26 0
+83 -6 57 0
+37 -54 79 0
+96 7 32 0
+81 56 -98 0
+-55 71 93 0
+-100 99 34 0
+69 -42 72 0
+-68 -81 -52 0
+24 -72 -37 0
+21 31 -37 0
+-42 -11 -51 0
+-93 -35 -98 0
+-10 50 -64 0
+-42 -71 27 0
+-43 12 33 0
+-32 67 55 0
+39 -34 56 0
+-19 -8 87 0
+-38 -10 -5 0
+-67 30 9 0
+-43 40 100 0
+-18 -61 -75 0
+-11 -15 81 0
+32 -35 59 0
+33 -66 -75 0
+-74 7 24 0
+-14 -22 6 0
+61 5 16 0
+89 -34 48 0
+-93 3 -12 0
+-51 -17 -83 0
+20 -3 7 0
+26 -51 6 0
+55 80 41 0
+-49 -19 -13 0
+35 37 -72 0
+3 -30 -64 0
+10 80 -4 0
+-23 -75 -73 0
+-75 -25 18 0
+42 19 -40 0
+74 37 81 0
+-90 -56 14 0
+-87 -94 -9 0
+-59 32 -11 0
+79 -60 12 0
+69 -46 84 0
+-84 -72 98 0
+52 48 41 0
+-69 36 45 0
+-13 -42 41 0
+30 -71 59 0
+84 83 -40 0
+99 -84 11 0
+79 -25 73 0
+-45 -91 44 0
+-96 5 2 0
+97 99 84 0
+7 -46 -5 0
+55 -33 -17 0
+-29 -100 -85 0
+3 82 -63 0
+-6 -33 77 0
+10 -76 69 0
+7 -48 55 0
+18 -3 -10 0
+60 -78 77 0
+-1 -88 45 0
+1 -88 -69 0
+8 28 -46 0
+48 -5 -65 0
+9 56 36 0
+32 26 93 0
+-10 -90 -93 0
+70 99 1 0
+71 77 -7 0
+96 -35 -42 0
+-80 98 5 0
+-76 -17 -98 0
+41 -65 88 0
+-44 -51 94 0
+-36 82 54 0
+-57 -93 18 0
+-69 40 41 0
+55 -49 -1 0
+%
+0
+

benchmarks/uf100/uf100-014.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -7 76 67 0
+26 100 -73 0
+-25 85 -36 0
+79 -17 -27 0
+37 98 26 0
+42 44 8 0
+-15 -36 -21 0
+86 -80 -47 0
+94 -49 11 0
+1 88 4 0
+-58 -64 -85 0
+86 -87 -31 0
+68 -59 65 0
+9 -74 83 0
+25 94 21 0
+-70 78 -7 0
+-50 29 65 0
+66 4 -97 0
+65 26 49 0
+81 -70 -36 0
+44 67 -34 0
+-28 -71 5 0
+31 17 -43 0
+-3 -12 86 0
+94 39 -100 0
+86 83 -64 0
+-96 -61 56 0
+-40 83 -24 0
+42 -13 82 0
+-58 79 -57 0
+-74 1 17 0
+-89 94 -57 0
+28 29 -87 0
+-52 50 -39 0
+-36 -72 -57 0
+-46 33 76 0
+64 15 3 0
+-85 30 77 0
+-27 -90 -64 0
+-43 -5 49 0
+75 -42 -51 0
+-68 -82 63 0
+73 -13 87 0
+70 41 64 0
+-77 14 -90 0
+-52 39 -3 0
+24 -87 25 0
+85 83 22 0
+97 -74 85 0
+-8 97 16 0
+37 59 -52 0
+2 37 45 0
+-61 -33 97 0
+-4 -57 -3 0
+14 -95 -83 0
+-42 -15 -48 0
+-51 -55 98 0
+9 41 79 0
+35 26 -94 0
+24 -27 -75 0
+96 -97 68 0
+4 40 -75 0
+47 44 95 0
+-62 83 -43 0
+36 44 83 0
+63 -45 34 0
+51 -90 -64 0
+-80 -37 -42 0
+92 -23 -73 0
+-90 14 -37 0
+10 87 30 0
+-67 -6 30 0
+70 -33 -69 0
+-36 -17 31 0
+59 9 60 0
+-40 19 -75 0
+-49 -1 -96 0
+-6 62 25 0
+-32 42 34 0
+87 -70 -37 0
+-92 40 88 0
+-57 71 23 0
+-44 54 -75 0
+86 60 22 0
+-47 -9 2 0
+52 46 -41 0
+-60 68 -33 0
+-96 63 -35 0
+-51 16 22 0
+4 -81 51 0
+6 -15 -51 0
+9 -13 30 0
+-22 -91 12 0
+18 -11 -58 0
+82 -86 73 0
+-38 97 52 0
+-51 18 80 0
+-13 -2 -40 0
+87 -73 39 0
+7 40 4 0
+-77 -26 -91 0
+-15 19 12 0
+-22 -23 -26 0
+-43 78 60 0
+12 10 -54 0
+55 -26 -9 0
+-40 -6 96 0
+-75 -22 29 0
+87 25 98 0
+61 18 -10 0
+97 87 -84 0
+-83 71 -80 0
+84 -96 -100 0
+33 83 8 0
+30 90 -31 0
+-98 99 -50 0
+56 -87 -53 0
+14 -48 -71 0
+96 92 -48 0
+17 -51 -66 0
+-11 -88 -68 0
+-42 -25 58 0
+69 -74 70 0
+-4 -83 21 0
+-29 3 -93 0
+63 60 71 0
+-1 -62 66 0
+80 -24 -99 0
+-78 66 -69 0
+41 45 57 0
+-16 2 -65 0
+-27 -32 46 0
+17 70 -24 0
+-1 -97 -50 0
+-23 -36 -12 0
+85 -84 -52 0
+-34 -97 14 0
+80 5 -73 0
+88 -19 -89 0
+5 -10 -19 0
+67 73 71 0
+1 55 38 0
+-17 13 30 0
+-82 4 -67 0
+-54 -45 -64 0
+60 28 24 0
+71 -46 1 0
+-33 -77 -47 0
+-10 48 66 0
+-31 71 51 0
+-45 2 -39 0
+14 2 -30 0
+-48 43 65 0
+56 -14 -78 0
+-27 20 66 0
+89 58 10 0
+11 -39 -44 0
+-29 -99 -95 0
+23 -49 12 0
+-96 -97 21 0
+-69 -63 90 0
+-21 2 54 0
+17 -70 -4 0
+10 -85 44 0
+23 81 -10 0
+-76 -10 47 0
+81 -9 -38 0
+39 -88 49 0
+-38 9 -95 0
+95 -53 60 0
+89 71 -11 0
+72 17 -7 0
+88 89 -67 0
+47 68 75 0
+-21 44 -58 0
+-81 -37 -23 0
+-90 -42 75 0
+75 -39 13 0
+-7 -22 -11 0
+87 -84 -4 0
+97 45 -88 0
+-78 24 -1 0
+-78 95 -91 0
+33 43 87 0
+3 -10 -33 0
+58 -50 -41 0
+4 -47 100 0
+56 -77 14 0
+-11 99 92 0
+-48 44 -25 0
+77 -7 -28 0
+-93 -56 43 0
+11 -15 -18 0
+-74 -72 82 0
+80 -17 68 0
+83 -74 -24 0
+7 -83 -31 0
+90 85 -6 0
+-91 82 38 0
+-96 27 24 0
+81 14 -94 0
+80 -30 66 0
+1 -68 24 0
+72 65 -15 0
+16 -34 88 0
+-59 -77 -31 0
+35 -61 -83 0
+-40 -71 29 0
+96 -48 68 0
+-72 73 38 0
+76 70 -11 0
+60 -57 52 0
+4 -97 -94 0
+34 -56 -18 0
+6 -38 -47 0
+-78 -72 27 0
+81 -38 -6 0
+55 84 59 0
+18 49 75 0
+-9 -56 -78 0
+12 -77 45 0
+-88 -46 60 0
+55 -33 23 0
+32 98 86 0
+46 -41 -90 0
+97 7 66 0
+63 34 -77 0
+-62 -80 -89 0
+20 24 -67 0
+-40 76 30 0
+96 -42 84 0
+100 20 92 0
+-83 25 35 0
+-86 -42 -71 0
+-31 46 8 0
+-78 -40 -84 0
+-75 -76 90 0
+13 79 -60 0
+51 30 -19 0
+-90 51 -36 0
+40 87 -19 0
+-93 -23 -71 0
+-17 1 -46 0
+-54 99 20 0
+-62 8 -90 0
+-77 -45 86 0
+-91 59 56 0
+-27 58 -45 0
+-62 -88 91 0
+20 22 17 0
+-8 -95 66 0
+-27 81 92 0
+-27 68 90 0
+-63 -1 -11 0
+-62 100 93 0
+-1 17 -6 0
+-99 37 76 0
+23 45 83 0
+36 79 22 0
+17 -94 3 0
+20 72 27 0
+-20 37 -74 0
+-11 -50 -38 0
+16 97 -32 0
+40 -60 57 0
+-53 87 100 0
+-17 31 75 0
+83 37 51 0
+73 -46 -9 0
+67 -23 -11 0
+-51 -18 -65 0
+-88 13 7 0
+63 85 -69 0
+25 -78 45 0
+-84 -49 51 0
+73 -22 33 0
+13 60 42 0
+52 -85 30 0
+-20 -23 -11 0
+93 40 41 0
+-59 6 33 0
+-21 -55 -65 0
+7 26 -71 0
+-70 66 91 0
+72 -23 86 0
+-23 25 -24 0
+61 -37 -21 0
+-12 6 -20 0
+51 -11 -32 0
+-87 -62 84 0
+91 -97 -74 0
+80 13 27 0
+95 49 -31 0
+81 -83 -12 0
+-9 34 56 0
+-71 -4 -78 0
+-64 68 94 0
+-59 -54 50 0
+-54 -66 -5 0
+-37 -96 11 0
+-97 46 -21 0
+42 -94 45 0
+54 -17 -4 0
+26 44 53 0
+7 45 35 0
+-34 33 -55 0
+-32 -48 79 0
+25 37 54 0
+-15 -67 -88 0
+7 2 -41 0
+50 52 11 0
+-90 38 65 0
+-5 -38 83 0
+-2 80 -90 0
+84 -53 87 0
+2 43 -57 0
+-29 36 1 0
+39 -8 51 0
+45 -66 95 0
+19 -38 -95 0
+-10 -64 -30 0
+29 -4 13 0
+-43 -34 -24 0
+8 100 54 0
+43 -51 46 0
+-25 66 72 0
+31 -61 50 0
+-59 32 79 0
+70 32 -34 0
+-32 76 -17 0
+-86 -37 -38 0
+-4 -21 30 0
+-99 21 -51 0
+12 -72 6 0
+12 26 14 0
+1 89 -63 0
+8 49 74 0
+56 -1 -58 0
+-80 91 32 0
+23 -48 -53 0
+63 76 -44 0
+-80 -22 37 0
+90 13 41 0
+7 -99 10 0
+65 6 -93 0
+72 6 -44 0
+4 -11 79 0
+80 -53 -50 0
+39 6 66 0
+-94 8 -55 0
+-54 96 3 0
+55 -15 45 0
+70 -34 -61 0
+-86 92 66 0
+-100 33 17 0
+-52 -72 37 0
+88 -23 62 0
+41 25 50 0
+60 -30 95 0
+-34 81 -66 0
+91 87 55 0
+74 -29 46 0
+-51 1 -27 0
+-3 -62 -99 0
+-31 -21 -60 0
+80 -61 81 0
+57 -62 49 0
+4 47 11 0
+-100 49 -73 0
+78 -76 80 0
+32 -51 -10 0
+-33 42 -59 0
+91 -48 1 0
+-13 -78 96 0
+44 -53 -17 0
+-73 21 39 0
+80 65 64 0
+-93 37 56 0
+40 49 -11 0
+-77 78 39 0
+81 -73 -48 0
+42 -34 -45 0
+-12 -64 -27 0
+1 96 12 0
+97 -7 24 0
+62 -81 -97 0
+90 40 -85 0
+24 57 -20 0
+13 24 71 0
+-71 -31 9 0
+18 27 -89 0
+64 -26 -28 0
+4 83 -28 0
+-98 -46 75 0
+-71 41 39 0
+-87 -52 -30 0
+-63 -29 -92 0
+-61 80 -33 0
+40 -100 -12 0
+-23 39 -22 0
+-66 -4 -8 0
+-61 41 -100 0
+2 -91 -55 0
+1 19 56 0
+93 56 -62 0
+-71 -83 -82 0
+49 -38 1 0
+-25 91 -21 0
+-36 27 18 0
+-15 31 6 0
+55 -15 -5 0
+-97 -41 19 0
+28 -13 99 0
+-47 28 -51 0
+14 34 -19 0
+41 65 -78 0
+27 -98 -11 0
+-53 -22 12 0
+76 -17 32 0
+15 94 -83 0
+-97 -54 -57 0
+-44 -26 55 0
+-53 -23 72 0
+-69 -50 58 0
+50 91 32 0
+-25 -20 -98 0
+-39 -38 -23 0
+-44 -15 -8 0
+39 -14 76 0
+5 83 -58 0
+%
+0
+

benchmarks/uf100/uf100-015.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -3 45 40 0
+-43 27 -37 0
+-63 -16 58 0
+-47 -4 -59 0
+-29 46 -64 0
+84 8 -32 0
+-28 48 98 0
+-40 -63 26 0
+-9 -2 -11 0
+60 -83 37 0
+10 -36 -48 0
+14 85 1 0
+22 -89 64 0
+-55 -95 -21 0
+56 20 92 0
+-53 44 80 0
+8 87 34 0
+-40 24 98 0
+41 -4 38 0
+-62 85 -68 0
+-86 -79 20 0
+98 -80 7 0
+-65 38 -66 0
+-80 65 17 0
+-32 -28 -96 0
+70 33 91 0
+-33 -85 -18 0
+-29 20 -25 0
+-71 -8 79 0
+16 -9 51 0
+-82 -63 37 0
+84 -30 27 0
+-61 22 -29 0
+-85 -84 -81 0
+-86 -68 36 0
+78 23 77 0
+33 51 -45 0
+-94 -66 -83 0
+64 62 -36 0
+13 17 62 0
+-89 90 -45 0
+83 72 -15 0
+-82 -100 25 0
+-20 -42 -65 0
+50 82 13 0
+-34 -18 -15 0
+-43 -66 25 0
+16 75 30 0
+43 59 50 0
+3 -65 99 0
+-41 -10 46 0
+8 -30 -94 0
+-63 3 -61 0
+100 -86 -59 0
+-66 96 38 0
+93 51 24 0
+-67 13 40 0
+46 -7 -29 0
+-6 98 58 0
+-38 -12 -45 0
+89 69 6 0
+-22 74 -23 0
+88 -79 -73 0
+88 -90 68 0
+95 -91 -25 0
+-95 -54 -69 0
+10 88 -49 0
+-99 -36 59 0
+42 -40 -33 0
+23 79 77 0
+47 13 -96 0
+90 -23 -48 0
+-19 53 -32 0
+-21 -65 23 0
+39 98 86 0
+-56 92 17 0
+-12 97 52 0
+-56 53 -58 0
+-71 51 46 0
+-99 -42 -17 0
+88 -12 -53 0
+-33 75 -56 0
+89 -90 -43 0
+-27 47 23 0
+91 38 68 0
+70 10 -35 0
+81 47 71 0
+-26 -19 -94 0
+-40 -92 -18 0
+-89 -54 95 0
+80 -31 26 0
+-11 -34 85 0
+-86 -95 -34 0
+-50 -2 -91 0
+25 54 -8 0
+-35 89 -100 0
+-99 -13 -86 0
+99 -78 50 0
+32 -7 -14 0
+-76 99 32 0
+52 31 12 0
+45 89 -95 0
+-16 94 -25 0
+-79 -19 -78 0
+-51 -29 -36 0
+20 100 39 0
+42 77 -31 0
+-28 29 -68 0
+-9 80 -91 0
+-40 -84 -15 0
+-62 71 84 0
+-42 -44 92 0
+46 -7 34 0
+-86 -69 15 0
+-62 -95 -32 0
+61 31 -54 0
+-60 72 -100 0
+-56 90 86 0
+25 -88 -14 0
+87 25 63 0
+-2 62 -63 0
+12 65 -11 0
+-71 -98 75 0
+85 87 34 0
+10 -73 -64 0
+-30 35 -58 0
+96 5 16 0
+-96 -91 22 0
+90 -35 -8 0
+-25 -68 29 0
+84 25 -38 0
+92 5 82 0
+-32 -7 93 0
+-74 -66 78 0
+-37 13 -3 0
+69 85 23 0
+-83 17 37 0
+-67 56 54 0
+-2 -82 -96 0
+14 -100 -97 0
+15 34 82 0
+70 -23 24 0
+54 53 4 0
+36 -13 -94 0
+15 5 56 0
+-9 -36 -56 0
+97 44 17 0
+-68 3 -57 0
+-83 -46 -80 0
+-33 92 -74 0
+-10 12 31 0
+-61 99 -47 0
+81 -88 99 0
+-4 41 53 0
+53 50 20 0
+-22 48 34 0
+56 73 -35 0
+-98 -30 -41 0
+-4 -71 -40 0
+86 7 6 0
+-28 55 90 0
+98 -63 75 0
+86 -62 55 0
+-25 62 92 0
+21 4 -52 0
+-69 -37 40 0
+61 96 -9 0
+60 14 -35 0
+35 65 -55 0
+72 -49 -77 0
+8 43 22 0
+95 -61 16 0
+76 -55 -57 0
+3 -60 57 0
+100 37 -6 0
+-31 -54 13 0
+-73 14 -48 0
+-51 64 48 0
+63 -35 -3 0
+-49 -64 27 0
+-46 -17 91 0
+91 67 -58 0
+-30 -93 77 0
+15 -96 23 0
+84 23 -40 0
+84 25 68 0
+-33 86 70 0
+-1 -21 66 0
+97 88 -23 0
+-32 5 4 0
+48 -26 -37 0
+-28 -100 -42 0
+-34 72 -90 0
+26 -46 -50 0
+31 -96 77 0
+-47 15 45 0
+-38 -59 -13 0
+49 -90 55 0
+-1 -14 49 0
+-22 94 -9 0
+-17 -74 91 0
+-73 -95 80 0
+68 -22 25 0
+-25 61 -27 0
+-86 33 83 0
+-70 47 84 0
+-81 -80 34 0
+96 -33 -29 0
+-32 -79 -50 0
+47 38 93 0
+39 -2 -69 0
+-62 43 55 0
+2 98 52 0
+-19 49 84 0
+29 -54 73 0
+44 21 -7 0
+88 -4 11 0
+62 100 12 0
+19 49 -77 0
+38 -45 37 0
+15 9 -39 0
+-89 8 -85 0
+13 11 82 0
+52 42 -59 0
+13 -82 -20 0
+68 6 94 0
+-88 15 -22 0
+54 26 82 0
+46 2 -47 0
+-78 -43 -72 0
+-83 -60 -68 0
+91 54 8 0
+-83 80 -48 0
+69 -60 99 0
+-7 41 -72 0
+40 -21 -23 0
+2 -87 -43 0
+-31 81 -47 0
+-74 13 -20 0
+-1 35 -23 0
+-36 -52 -81 0
+-47 -61 -63 0
+57 -1 -41 0
+-65 52 98 0
+-67 -24 -61 0
+50 -32 -25 0
+-7 36 45 0
+-31 -82 -16 0
+-57 50 -44 0
+80 -2 -92 0
+13 -41 18 0
+-22 78 -43 0
+-81 79 49 0
+89 -6 84 0
+-100 -40 19 0
+-78 94 50 0
+3 52 99 0
+-13 -99 -25 0
+-95 83 80 0
+96 15 -80 0
+-23 -84 -53 0
+-94 82 -36 0
+-38 40 52 0
+36 -96 30 0
+55 -68 -60 0
+94 -5 49 0
+-30 -71 10 0
+-18 -99 -77 0
+16 96 73 0
+90 -65 -14 0
+-14 93 -99 0
+91 69 46 0
+38 52 -6 0
+-92 -37 -62 0
+9 71 37 0
+17 -33 -28 0
+91 -86 -36 0
+44 24 21 0
+-16 -29 -78 0
+-49 1 29 0
+21 -40 -81 0
+-15 -46 61 0
+19 -26 70 0
+-80 -92 35 0
+16 17 -28 0
+-92 -22 90 0
+47 84 -90 0
+54 -53 -98 0
+-30 72 65 0
+92 -44 -50 0
+-71 -79 73 0
+-5 98 -26 0
+-67 -59 13 0
+38 -11 77 0
+-35 -67 49 0
+36 58 -15 0
+-49 23 -63 0
+34 83 25 0
+51 -84 -17 0
+-32 21 60 0
+16 41 3 0
+-96 -97 -43 0
+-26 -5 -42 0
+-57 1 -72 0
+65 59 -78 0
+-70 -54 -23 0
+93 81 67 0
+94 64 -41 0
+-22 71 92 0
+51 8 79 0
+12 -2 -71 0
+-5 67 -35 0
+7 94 -37 0
+39 50 -21 0
+50 95 72 0
+44 -34 -6 0
+69 73 45 0
+76 -50 -39 0
+-63 -36 -17 0
+47 15 -54 0
+22 -87 -11 0
+-6 -68 -51 0
+97 -46 43 0
+2 20 76 0
+79 -50 -56 0
+9 90 -84 0
+98 -23 52 0
+-42 70 69 0
+-25 7 46 0
+-40 5 -99 0
+-94 -46 -57 0
+61 63 -96 0
+35 53 40 0
+-29 -62 -52 0
+23 -1 81 0
+87 -89 63 0
+17 27 91 0
+82 -74 -54 0
+65 -5 53 0
+-93 1 14 0
+-91 -9 -98 0
+-81 -68 91 0
+72 -61 -3 0
+-16 -46 -83 0
+-82 54 -62 0
+4 -17 92 0
+-66 49 -11 0
+-85 91 51 0
+66 -32 78 0
+-10 -81 93 0
+55 -79 36 0
+-89 47 -53 0
+90 -87 -63 0
+73 -39 9 0
+-89 -97 -82 0
+-22 43 35 0
+-56 -70 -92 0
+-45 58 27 0
+58 -70 12 0
+-97 53 -8 0
+78 41 14 0
+51 64 -6 0
+7 64 -35 0
+36 7 -35 0
+-67 -11 -44 0
+-46 -65 4 0
+96 -28 -76 0
+78 77 59 0
+77 -45 15 0
+3 59 40 0
+9 79 -92 0
+-24 32 -97 0
+-94 11 -43 0
+-60 99 -97 0
+4 -12 -48 0
+-70 -66 -59 0
+30 2 -28 0
+92 95 -70 0
+-86 -7 91 0
+71 85 -13 0
+-98 -97 36 0
+-52 87 16 0
+39 4 -12 0
+-1 24 66 0
+92 -77 -32 0
+75 92 55 0
+25 -100 98 0
+-57 17 -14 0
+-28 25 -75 0
+-41 8 -58 0
+-31 -87 -44 0
+-98 -21 -91 0
+5 -18 85 0
+70 14 34 0
+-26 48 -57 0
+-35 51 -55 0
+-69 34 72 0
+28 -34 49 0
+-21 -22 -48 0
+-4 -92 2 0
+-27 -9 73 0
+32 55 -42 0
+-35 -42 -4 0
+-18 75 77 0
+21 -33 35 0
+44 -19 17 0
+-24 31 -58 0
+36 -69 -13 0
+-95 70 -42 0
+15 -56 -3 0
+-57 20 13 0
+76 59 -43 0
+5 -60 -44 0
+84 -93 -65 0
+-97 79 56 0
+93 -84 -52 0
+-17 -32 -46 0
+-35 -69 28 0
+74 -71 -20 0
+-39 -92 -62 0
+-26 -84 72 0
+64 -5 60 0
+78 -97 -94 0
+-32 -49 51 0
+-34 25 38 0
+-85 44 -12 0
+85 -84 -4 0
+69 63 74 0
+-87 93 -55 0
+98 76 -85 0
+%
+0
+

benchmarks/uf100/uf100-016.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 92 -62 -97 0
+-79 -73 44 0
+50 6 2 0
+-37 -17 -15 0
+98 54 -4 0
+-87 13 46 0
+-53 -1 -73 0
+36 19 70 0
+-55 -83 35 0
+25 -76 -69 0
+-12 -82 1 0
+58 18 -24 0
+-95 -49 -12 0
+84 40 41 0
+-33 -95 -2 0
+71 70 92 0
+86 -52 38 0
+-11 -14 43 0
+-58 39 -42 0
+9 80 55 0
+-1 10 14 0
+6 24 -100 0
+75 50 -78 0
+-19 -83 -15 0
+-21 -66 -41 0
+19 -76 90 0
+-80 73 -51 0
+44 91 -39 0
+97 -27 45 0
+73 -7 69 0
+-92 1 -20 0
+-9 -12 -60 0
+-49 -34 -67 0
+-51 -52 -2 0
+-98 35 -96 0
+10 39 77 0
+-16 -28 21 0
+51 35 -46 0
+-93 -72 51 0
+-83 65 -47 0
+55 -40 -32 0
+-41 -84 -79 0
+72 10 99 0
+-17 20 -92 0
+80 -97 -22 0
+-20 -30 -91 0
+-3 -2 43 0
+45 -34 11 0
+-63 67 -56 0
+13 67 -35 0
+59 71 77 0
+-13 -33 -79 0
+-38 -28 90 0
+-44 -45 -82 0
+10 90 -18 0
+-30 -86 6 0
+8 -94 -20 0
+38 -16 88 0
+-62 39 95 0
+69 5 64 0
+42 18 52 0
+89 21 -7 0
+-7 -58 11 0
+8 -37 -42 0
+49 -64 -62 0
+-36 -17 12 0
+100 -52 -45 0
+1 -67 -23 0
+-15 -68 35 0
+-14 19 -93 0
+-69 -67 84 0
+4 -54 -99 0
+14 -60 -25 0
+-34 85 53 0
+-99 54 -42 0
+59 -98 -39 0
+-90 81 46 0
+-47 -42 65 0
+56 -12 -19 0
+-31 -79 13 0
+-44 -29 39 0
+75 61 96 0
+-26 -96 66 0
+24 22 54 0
+1 60 -12 0
+-55 -76 -10 0
+8 -33 -42 0
+-27 -79 -86 0
+-35 92 73 0
+22 34 -63 0
+14 -2 69 0
+4 3 59 0
+35 33 -91 0
+72 58 -50 0
+47 -67 -17 0
+-3 14 -66 0
+-98 -40 -63 0
+-69 19 1 0
+-17 -11 82 0
+-50 3 -94 0
+-31 -14 7 0
+57 83 -82 0
+-88 -9 85 0
+-12 -84 -35 0
+21 -100 92 0
+8 -97 17 0
+57 -50 85 0
+-5 57 -33 0
+13 56 84 0
+37 -71 -34 0
+32 93 -97 0
+50 64 40 0
+-59 -7 65 0
+-90 -9 65 0
+7 92 -84 0
+41 -52 -61 0
+-27 -49 31 0
+74 42 39 0
+47 -23 -42 0
+26 2 89 0
+78 83 -60 0
+7 -46 -37 0
+86 -32 8 0
+-71 -86 -83 0
+8 84 -68 0
+95 8 -36 0
+-40 -73 -1 0
+-46 -70 -22 0
+-95 64 -71 0
+57 -53 -36 0
+1 -64 -69 0
+31 36 -68 0
+21 57 22 0
+-28 -5 79 0
+-51 -38 77 0
+46 -64 10 0
+-9 -30 -41 0
+-29 82 10 0
+65 52 24 0
+67 -100 43 0
+-88 31 -69 0
+3 54 -98 0
+96 59 -40 0
+25 74 -15 0
+-53 82 64 0
+-1 13 80 0
+37 -12 78 0
+92 -51 -66 0
+95 81 -48 0
+74 -81 -45 0
+-86 76 -82 0
+-90 81 -3 0
+76 6 -8 0
+-16 32 -44 0
+-27 -15 52 0
+41 38 4 0
+13 -93 29 0
+-72 -36 -49 0
+-43 -92 -18 0
+58 -82 73 0
+37 93 -61 0
+88 27 56 0
+58 -13 52 0
+92 34 -20 0
+67 -77 57 0
+62 -23 2 0
+85 -51 -43 0
+57 24 -97 0
+36 22 56 0
+96 19 -87 0
+-97 26 19 0
+39 54 44 0
+-29 34 8 0
+80 -43 100 0
+5 3 17 0
+-36 32 8 0
+57 -59 73 0
+1 91 -44 0
+-52 29 -8 0
+-82 -43 95 0
+9 -18 -32 0
+35 28 -10 0
+-18 29 63 0
+27 89 -41 0
+26 21 20 0
+-21 27 -19 0
+5 -78 18 0
+87 -2 75 0
+61 90 100 0
+-79 -50 -60 0
+100 90 6 0
+9 -47 25 0
+73 -47 -12 0
+-57 -64 58 0
+37 55 34 0
+96 -39 -52 0
+85 12 -86 0
+-91 32 -5 0
+43 -71 18 0
+-36 -94 67 0
+-3 95 39 0
+15 -17 -36 0
+-58 52 -89 0
+24 -81 65 0
+53 -17 16 0
+-19 89 10 0
+82 -58 60 0
+-75 -16 72 0
+58 1 -91 0
+-44 93 -87 0
+-73 -31 62 0
+-24 -70 62 0
+-4 62 34 0
+-85 82 -12 0
+46 47 -44 0
+-6 -78 -86 0
+71 -84 43 0
+-52 70 92 0
+97 -30 -8 0
+-51 45 -3 0
+-88 -27 43 0
+-25 70 -59 0
+-9 5 -79 0
+-91 -79 -98 0
+-34 60 17 0
+-11 -61 -58 0
+66 34 41 0
+-6 -1 43 0
+34 -85 -31 0
+-51 -8 -46 0
+71 -1 -23 0
+-12 -63 -33 0
+1 70 55 0
+76 -58 33 0
+93 -26 13 0
+1 -62 4 0
+-23 -2 64 0
+-9 -54 97 0
+11 -72 -79 0
+-49 70 -78 0
+-64 8 32 0
+69 54 -24 0
+-60 -17 30 0
+-77 91 -98 0
+-8 82 -44 0
+-55 -7 -59 0
+7 -43 -44 0
+7 -35 70 0
+-61 68 -40 0
+-33 29 -55 0
+-27 -68 -4 0
+76 -60 -21 0
+72 96 31 0
+91 -93 89 0
+-3 -83 -39 0
+-54 -86 -19 0
+-34 -46 31 0
+-51 -38 17 0
+-3 -70 -40 0
+-1 72 -40 0
+-11 -16 -9 0
+-1 -32 11 0
+-5 34 -48 0
+-88 -82 34 0
+80 82 95 0
+10 49 40 0
+99 -17 -57 0
+-42 -76 -88 0
+83 49 -82 0
+40 8 -44 0
+-60 -37 31 0
+-25 -54 63 0
+34 -5 -9 0
+21 -76 19 0
+64 -32 -54 0
+89 26 -17 0
+66 49 -26 0
+-61 -64 -93 0
+-39 5 -62 0
+-3 -71 -86 0
+-37 -66 78 0
+-26 51 78 0
+43 32 7 0
+32 79 2 0
+-9 -18 -60 0
+52 48 -50 0
+-88 -99 -26 0
+3 21 97 0
+-55 79 93 0
+60 25 43 0
+-16 -63 60 0
+-40 -87 -7 0
+29 -54 -6 0
+39 -18 31 0
+-56 -34 -73 0
+-12 69 46 0
+-79 73 -32 0
+-71 -67 -37 0
+-29 -30 -18 0
+-7 17 -25 0
+62 -27 -46 0
+-52 -76 -83 0
+32 55 1 0
+-36 76 18 0
+-1 -54 34 0
+41 -96 56 0
+-99 69 -85 0
+46 -62 -29 0
+-47 -4 -50 0
+73 -100 41 0
+-16 -20 -6 0
+-5 65 -67 0
+-64 91 58 0
+66 84 29 0
+2 21 26 0
+-52 42 -24 0
+55 -18 22 0
+-71 91 76 0
+28 -12 -30 0
+-45 80 -83 0
+-39 -47 -10 0
+-50 -77 -54 0
+-89 55 -45 0
+-65 -44 84 0
+51 32 23 0
+20 -57 75 0
+-29 -2 -11 0
+-37 62 -49 0
+52 -91 -9 0
+79 -35 27 0
+30 87 -2 0
+39 45 55 0
+-43 63 89 0
+-56 95 -4 0
+-60 9 -23 0
+32 41 -76 0
+87 84 -35 0
+-68 -75 -25 0
+-70 -22 -62 0
+-61 46 1 0
+73 -64 -52 0
+-40 84 80 0
+-36 93 -86 0
+-28 -17 -73 0
+-81 51 3 0
+94 -7 -99 0
+42 -94 80 0
+33 -4 97 0
+70 -91 -61 0
+100 61 2 0
+38 -36 -43 0
+33 22 -92 0
+16 -76 64 0
+56 64 -18 0
+-68 5 59 0
+6 -46 36 0
+45 14 -39 0
+-96 -41 57 0
+86 9 13 0
+-1 -93 23 0
+-60 67 -76 0
+12 -60 -70 0
+-31 -92 -36 0
+37 36 97 0
+-68 -40 -15 0
+-21 -58 -44 0
+53 65 18 0
+-17 44 -6 0
+41 68 92 0
+-60 -84 -71 0
+-52 -94 -27 0
+-53 -42 -44 0
+-84 81 2 0
+45 74 99 0
+66 71 -99 0
+6 -97 -67 0
+-12 44 -97 0
+13 -98 -41 0
+46 -32 -47 0
+-60 -33 -28 0
+-31 75 -70 0
+53 -19 4 0
+10 87 16 0
+-23 -46 34 0
+-26 50 33 0
+-27 38 -77 0
+-56 87 -2 0
+-77 -46 -63 0
+95 -18 -8 0
+-28 -12 -47 0
+63 -93 92 0
+23 44 14 0
+-100 -80 -96 0
+25 -66 -8 0
+-31 -22 -7 0
+31 -45 -64 0
+-50 7 -96 0
+13 -31 78 0
+99 18 14 0
+1 -80 29 0
+79 88 55 0
+-94 60 -46 0
+-87 36 -7 0
+13 43 -17 0
+-33 -51 47 0
+71 -36 90 0
+65 -72 -60 0
+-87 48 -19 0
+93 24 -6 0
+77 83 -5 0
+25 14 -97 0
+-16 4 46 0
+-58 -100 -54 0
+40 -86 89 0
+100 -72 -20 0
+-66 19 77 0
+-38 49 19 0
+90 -82 32 0
+-9 97 10 0
+-35 41 -76 0
+-17 -11 88 0
+9 -11 -69 0
+-60 83 74 0
+16 35 -28 0
+30 67 -10 0
+-73 38 66 0
+81 -40 49 0
+42 -26 15 0
+-33 87 74 0
+-87 84 53 0
+%
+0
+

benchmarks/uf100/uf100-017.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 30 44 64 0
+-74 -7 -84 0
+87 57 -23 0
+-29 58 -92 0
+-14 12 -41 0
+-30 -62 35 0
+41 -3 30 0
+-91 27 49 0
+-24 2 -15 0
+5 42 83 0
+-17 70 -62 0
+97 -77 62 0
+-52 -71 57 0
+23 -90 3 0
+-8 86 74 0
+-91 -48 85 0
+-11 95 -99 0
+-3 -73 50 0
+-60 95 -5 0
+-96 40 72 0
+-84 -19 51 0
+-91 -81 -44 0
+68 55 37 0
+32 73 4 0
+-23 -31 75 0
+97 -83 -22 0
+96 42 74 0
+4 97 -80 0
+-49 -46 66 0
+-87 -5 31 0
+-64 96 -12 0
+-79 -39 5 0
+-77 82 32 0
+49 70 -90 0
+15 -9 -77 0
+-74 34 71 0
+-50 98 52 0
+88 -26 10 0
+-64 31 1 0
+25 60 -31 0
+76 -78 -34 0
+59 -13 -50 0
+39 -54 23 0
+-80 -36 -35 0
+2 13 38 0
+-32 90 -20 0
+-17 94 -96 0
+-63 -41 -16 0
+89 69 24 0
+2 -49 25 0
+81 -12 -28 0
+-84 -92 -56 0
+-42 20 -100 0
+-46 94 57 0
+81 -18 53 0
+-44 38 45 0
+-34 22 -12 0
+48 43 -88 0
+-35 46 86 0
+96 -20 -48 0
+44 -15 25 0
+48 -75 56 0
+84 19 12 0
+-65 -90 -56 0
+-75 -12 -99 0
+18 -3 4 0
+80 29 4 0
+100 23 39 0
+95 -5 33 0
+-1 58 36 0
+-79 -50 -26 0
+31 -60 10 0
+62 75 -36 0
+-44 99 -81 0
+100 49 -23 0
+-59 27 -4 0
+-65 -41 44 0
+87 37 -95 0
+-99 -80 97 0
+-45 -56 94 0
+21 49 -70 0
+-8 -97 -19 0
+-71 -57 -30 0
+-64 -78 47 0
+-6 -1 57 0
+42 89 96 0
+90 -20 -24 0
+2 42 49 0
+98 70 -5 0
+46 35 62 0
+50 -76 18 0
+-72 -76 49 0
+88 86 -60 0
+-64 -14 -35 0
+-30 4 100 0
+21 -55 -10 0
+67 -71 -72 0
+-34 -55 -42 0
+-60 55 72 0
+-59 52 33 0
+92 63 -93 0
+-97 -68 63 0
+-24 17 -83 0
+-22 -70 -29 0
+-23 3 -56 0
+-71 9 -86 0
+68 -77 -40 0
+59 -75 51 0
+45 54 52 0
+61 40 -6 0
+-9 -91 -61 0
+70 -29 46 0
+77 23 -79 0
+51 89 17 0
+6 87 -74 0
+64 11 84 0
+93 -74 75 0
+-43 60 -21 0
+37 94 100 0
+45 -7 57 0
+20 83 43 0
+-98 2 74 0
+40 100 37 0
+63 98 -19 0
+47 25 -59 0
+-23 -53 -41 0
+-1 -74 71 0
+90 93 11 0
+-45 -81 13 0
+-16 29 -54 0
+-32 54 40 0
+42 -19 89 0
+22 82 -35 0
+-47 51 34 0
+89 30 -45 0
+-30 36 31 0
+-85 -50 -68 0
+-16 83 42 0
+3 62 99 0
+-52 -9 43 0
+73 81 -83 0
+52 35 40 0
+79 -23 -84 0
+-69 76 -60 0
+81 -64 89 0
+-70 33 -21 0
+-43 87 4 0
+84 34 -67 0
+73 -83 25 0
+20 58 93 0
+-13 -51 53 0
+-7 -72 26 0
+73 -61 -71 0
+4 -38 -60 0
+33 97 12 0
+57 52 -81 0
+-31 23 38 0
+-93 85 75 0
+-41 -28 -77 0
+-54 89 -49 0
+-95 -69 -40 0
+-40 -9 -78 0
+-91 58 -75 0
+-5 -61 -26 0
+-33 -15 -70 0
+70 73 51 0
+64 -87 37 0
+31 55 -58 0
+3 24 40 0
+-11 38 -15 0
+62 -89 66 0
+-42 61 -100 0
+79 33 17 0
+-15 -41 -60 0
+-55 -79 1 0
+62 20 8 0
+40 -74 -65 0
+2 -30 99 0
+54 81 77 0
+-78 -90 -24 0
+99 19 2 0
+-11 86 -8 0
+42 25 -90 0
+-77 97 -37 0
+98 -88 61 0
+3 -65 -37 0
+39 -82 -68 0
+-6 100 -16 0
+-50 -17 -55 0
+58 -66 53 0
+-36 -90 -85 0
+56 -32 -38 0
+14 -84 94 0
+88 28 50 0
+-7 -72 -84 0
+-80 -26 -60 0
+-19 -54 -85 0
+51 90 46 0
+77 6 -52 0
+45 54 38 0
+-99 -93 52 0
+-12 75 -4 0
+59 81 -68 0
+-29 2 92 0
+-47 -72 93 0
+-10 -98 62 0
+-68 -29 -15 0
+22 -39 62 0
+55 -65 -39 0
+-82 -64 -70 0
+75 62 73 0
+-48 85 55 0
+57 -70 52 0
+66 -51 -80 0
+-82 67 -36 0
+-26 6 -60 0
+-25 -90 62 0
+92 9 -79 0
+58 -93 25 0
+10 79 78 0
+44 -55 -14 0
+81 -77 -45 0
+52 -46 7 0
+5 -47 26 0
+41 93 1 0
+27 -81 85 0
+96 65 -13 0
+38 -59 14 0
+78 94 48 0
+26 -64 -25 0
+57 7 43 0
+-78 -43 -92 0
+-58 22 -71 0
+43 -40 -21 0
+-72 26 76 0
+-56 -13 80 0
+-74 -3 -98 0
+-23 -7 -54 0
+-66 -16 39 0
+38 34 26 0
+51 -88 44 0
+37 58 -6 0
+-31 44 -98 0
+84 -3 86 0
+22 26 80 0
+79 90 -99 0
+26 -57 -40 0
+22 21 5 0
+-90 89 45 0
+22 -32 -59 0
+12 -57 87 0
+91 5 -63 0
+-91 -57 -74 0
+-38 67 -68 0
+-15 -62 -9 0
+-71 -74 44 0
+64 74 -28 0
+-79 -95 -19 0
+-32 28 62 0
+-76 -25 65 0
+72 68 -100 0
+-39 88 -57 0
+28 93 55 0
+42 -78 -73 0
+-5 52 7 0
+-96 7 -71 0
+78 61 -83 0
+94 -53 89 0
+-93 40 -12 0
+48 -40 -54 0
+12 82 28 0
+85 -64 6 0
+-13 42 91 0
+55 80 37 0
+67 -70 63 0
+78 98 20 0
+29 90 -87 0
+35 -21 -17 0
+-51 -37 -36 0
+-11 23 27 0
+11 21 10 0
+53 -55 4 0
+15 23 33 0
+88 -99 51 0
+81 -95 -30 0
+20 78 94 0
+44 -60 -75 0
+-59 13 86 0
+-7 -31 32 0
+-64 34 -12 0
+-65 -61 -57 0
+-78 -34 23 0
+-15 40 -34 0
+-34 -37 -8 0
+-82 58 95 0
+72 -15 -96 0
+91 50 20 0
+-34 17 -40 0
+-44 49 8 0
+12 -96 59 0
+41 -59 -23 0
+23 -77 45 0
+-43 -24 -62 0
+-53 -34 27 0
+62 97 36 0
+-28 -43 -82 0
+45 3 89 0
+-87 57 -97 0
+-21 -81 1 0
+-42 -62 -77 0
+89 -7 82 0
+-84 89 94 0
+7 -19 84 0
+-79 -8 -11 0
+-21 -30 38 0
+-97 80 -8 0
+27 -2 82 0
+47 -81 33 0
+-60 63 28 0
+-47 -62 46 0
+-86 56 16 0
+-87 -60 36 0
+83 -26 -90 0
+-35 -15 -37 0
+78 31 -40 0
+-59 -1 -54 0
+9 82 46 0
+54 33 51 0
+-17 82 21 0
+-31 21 35 0
+69 -2 51 0
+-9 86 -26 0
+80 83 -8 0
+-37 -42 -36 0
+-61 -25 99 0
+-46 -64 44 0
+-41 95 6 0
+42 -29 19 0
+3 -97 -86 0
+17 14 -5 0
+-57 -55 63 0
+20 -92 -43 0
+-61 100 -22 0
+22 -51 77 0
+-88 6 -43 0
+-92 -77 -7 0
+4 97 50 0
+-39 -82 -7 0
+40 -82 -6 0
+-46 -77 100 0
+41 61 -97 0
+-6 -19 -69 0
+-63 -3 72 0
+24 1 13 0
+24 -64 78 0
+43 92 8 0
+-13 -45 41 0
+72 62 -7 0
+-73 -54 -69 0
+-87 7 49 0
+11 72 93 0
+-40 24 -76 0
+-85 76 -37 0
+58 -91 21 0
+-12 62 10 0
+-61 -37 11 0
+-84 -95 45 0
+-34 59 24 0
+-37 7 32 0
+-61 45 -69 0
+9 65 -31 0
+-41 -100 -79 0
+-34 -93 -11 0
+99 -100 -67 0
+38 -17 44 0
+100 96 12 0
+-14 56 -28 0
+-45 76 80 0
+-16 -32 -42 0
+81 100 15 0
+-72 5 97 0
+12 48 68 0
+26 85 5 0
+56 50 -88 0
+19 11 100 0
+-14 -20 98 0
+9 1 -78 0
+-73 -25 -72 0
+25 -21 38 0
+-98 76 -60 0
+-99 32 94 0
+-6 -37 -47 0
+71 57 -12 0
+-31 -59 -98 0
+-18 -69 31 0
+52 -64 80 0
+92 66 45 0
+25 -20 86 0
+14 -92 80 0
+-66 -78 -18 0
+45 -7 47 0
+-33 -43 72 0
+-6 5 40 0
+-13 -56 -94 0
+41 -32 59 0
+-72 93 -89 0
+28 -86 -67 0
+11 70 27 0
+15 67 -22 0
+47 -65 -7 0
+48 -64 85 0
+-31 -87 -14 0
+84 2 -49 0
+-38 18 -27 0
+34 -71 24 0
+33 -23 79 0
+-46 -89 23 0
+-37 -69 15 0
+-45 -16 -36 0
+30 8 -54 0
+-81 -28 -47 0
+43 -75 6 0
+39 28 -34 0
+68 -21 87 0
+68 -3 -75 0
+89 31 -8 0
+18 -72 69 0
+-42 11 -56 0
+27 1 -82 0
+59 6 79 0
+%
+0
+

benchmarks/uf100/uf100-018.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -96 53 6 0
+-57 44 -58 0
+58 3 61 0
+-39 72 -91 0
+72 -35 84 0
+24 50 -78 0
+-35 -86 -37 0
+76 29 89 0
+-86 -72 80 0
+-71 -27 -45 0
+-79 80 -48 0
+-50 44 61 0
+-72 11 -61 0
+69 32 67 0
+59 79 48 0
+1 -12 -84 0
+-24 17 -37 0
+-16 74 84 0
+71 -3 -62 0
+58 10 -49 0
+-8 -13 -93 0
+84 -83 -77 0
+-92 -83 -52 0
+-5 -29 89 0
+-36 23 -50 0
+-66 34 75 0
+-19 8 -18 0
+73 -19 66 0
+-10 -99 53 0
+-39 -100 -40 0
+50 100 -24 0
+26 -31 -75 0
+93 -77 25 0
+27 69 1 0
+-63 32 57 0
+100 -65 22 0
+-82 99 76 0
+15 12 -9 0
+-88 -55 -47 0
+-6 -41 10 0
+85 91 -90 0
+51 -96 -61 0
+-58 68 91 0
+-45 -94 -73 0
+-70 88 -93 0
+-5 34 -74 0
+58 90 84 0
+-98 72 4 0
+-8 -83 -4 0
+32 45 73 0
+-7 29 -55 0
+-69 -81 -84 0
+-89 -97 70 0
+2 -92 -91 0
+-90 4 9 0
+83 34 -62 0
+32 84 -67 0
+-13 25 62 0
+-90 19 38 0
+-45 -12 13 0
+86 -57 -74 0
+-33 26 72 0
+64 53 33 0
+71 25 -68 0
+18 49 -3 0
+71 88 32 0
+33 -68 -52 0
+13 -30 -45 0
+-95 26 4 0
+-53 -51 -57 0
+-30 -51 -46 0
+88 28 48 0
+-31 -45 -43 0
+-55 84 -23 0
+66 -99 -7 0
+80 83 39 0
+-5 -31 -62 0
+65 -100 38 0
+5 -30 -11 0
+-84 -53 55 0
+79 -53 89 0
+51 82 64 0
+6 97 33 0
+-69 9 38 0
+-36 21 -77 0
+-97 90 -4 0
+-18 -58 -63 0
+15 75 -92 0
+-56 -86 4 0
+-17 -100 -61 0
+45 -86 -62 0
+-30 -89 -26 0
+-86 85 -70 0
+-73 -87 72 0
+-17 -96 36 0
+49 -34 -11 0
+78 12 71 0
+-98 -89 -26 0
+53 38 44 0
+-61 30 19 0
+21 -56 42 0
+-12 43 35 0
+23 43 -26 0
+5 -63 28 0
+71 -47 -89 0
+-63 -33 -38 0
+-6 -40 96 0
+-9 27 58 0
+61 -98 77 0
+-78 -32 -88 0
+-63 37 -97 0
+-61 36 34 0
+88 -32 -45 0
+-95 -48 -78 0
+-88 -33 -94 0
+41 -62 5 0
+-31 -21 -70 0
+82 64 23 0
+-5 -4 58 0
+45 63 46 0
+5 78 -6 0
+44 45 -88 0
+5 90 28 0
+-38 20 41 0
+-8 -47 78 0
+97 -90 93 0
+-70 -42 -52 0
+20 -59 -50 0
+85 24 -84 0
+40 -26 34 0
+32 -75 7 0
+30 47 82 0
+-24 60 -91 0
+-55 -70 39 0
+20 -13 -58 0
+-68 66 -82 0
+22 -89 34 0
+44 -16 94 0
+88 41 -9 0
+51 -39 -9 0
+-83 43 65 0
+-52 -55 -96 0
+19 1 -4 0
+-51 22 30 0
+-55 98 -88 0
+63 -88 5 0
+35 -3 93 0
+19 7 -51 0
+11 69 -6 0
+-89 83 -51 0
+38 10 -44 0
+-80 72 -99 0
+-22 20 92 0
+-56 -52 79 0
+-15 -81 90 0
+-21 94 -46 0
+-60 -15 -53 0
+43 -9 74 0
+45 -36 -67 0
+30 -12 -38 0
+-55 -98 88 0
+82 -21 37 0
+-89 -22 32 0
+77 100 47 0
+1 -52 55 0
+33 25 -29 0
+-42 5 -11 0
+2 -27 -10 0
+-45 65 -66 0
+-35 8 40 0
+20 -78 -34 0
+38 39 63 0
+37 -20 28 0
+-12 -98 -80 0
+65 23 95 0
+14 -32 19 0
+-5 -18 -55 0
+-68 3 91 0
+-11 61 41 0
+-78 1 -52 0
+13 -18 -96 0
+47 69 -93 0
+-72 -4 62 0
+6 -9 71 0
+75 77 9 0
+-90 -61 -30 0
+-60 38 -63 0
+-11 -10 -2 0
+-83 78 8 0
+-61 100 84 0
+81 -16 -93 0
+-4 60 -22 0
+-64 -24 69 0
+-64 78 19 0
+-79 -91 -43 0
+-94 40 -83 0
+-70 52 -43 0
+50 81 -78 0
+-60 -9 -51 0
+-22 59 72 0
+32 -13 71 0
+97 -69 -72 0
+-94 9 69 0
+-44 -88 23 0
+76 -88 -60 0
+79 -83 -93 0
+68 94 60 0
+-28 -26 -27 0
+11 41 33 0
+-11 95 -94 0
+-37 29 -66 0
+-54 -20 16 0
+20 -78 60 0
+-27 -16 -55 0
+-92 62 56 0
+59 57 -30 0
+-81 -96 75 0
+-30 8 -4 0
+-2 50 94 0
+-17 -100 6 0
+73 -44 82 0
+58 49 20 0
+-58 -73 15 0
+40 64 -88 0
+-77 37 -96 0
+-8 -81 -24 0
+13 -41 -40 0
+-40 -30 57 0
+-93 -30 82 0
+-77 39 38 0
+-52 28 26 0
+67 -30 49 0
+90 -1 50 0
+65 48 70 0
+-48 -5 -72 0
+-31 27 20 0
+65 -69 66 0
+-34 65 -28 0
+-23 75 -31 0
+-25 -69 64 0
+88 84 -65 0
+45 5 35 0
+-38 51 -73 0
+-48 57 -59 0
+38 -75 49 0
+39 -59 86 0
+71 11 31 0
+-14 59 99 0
+70 -72 90 0
+-8 -88 -14 0
+57 27 42 0
+-69 100 19 0
+46 19 99 0
+-78 75 95 0
+6 -10 32 0
+3 -22 -46 0
+-53 33 -75 0
+12 77 98 0
+34 -99 -77 0
+73 -72 -89 0
+-24 93 76 0
+45 -90 73 0
+-99 -73 80 0
+-98 17 -1 0
+53 17 37 0
+-94 45 -20 0
+-9 -58 46 0
+-85 -76 -80 0
+-66 69 81 0
+-32 95 -41 0
+95 -29 6 0
+70 -7 -77 0
+23 73 -29 0
+66 -3 68 0
+71 -1 5 0
+-73 -63 -69 0
+-98 -47 -73 0
+-28 -85 -34 0
+56 -53 74 0
+33 -70 42 0
+76 53 73 0
+-10 28 -97 0
+-44 29 78 0
+-40 -84 -21 0
+96 52 5 0
+-8 84 88 0
+61 43 -34 0
+-88 -73 -36 0
+13 -97 50 0
+-95 -55 84 0
+14 94 100 0
+-37 6 -56 0
+-62 37 72 0
+64 14 -26 0
+46 41 40 0
+44 -53 -20 0
+57 -91 71 0
+-12 23 -58 0
+13 -83 72 0
+-24 -41 -59 0
+90 -13 52 0
+74 13 -95 0
+65 38 -77 0
+-81 -34 -79 0
+71 -95 -14 0
+-28 -47 -96 0
+-84 -30 -65 0
+33 -39 27 0
+-6 -42 -82 0
+-58 -64 48 0
+54 -21 52 0
+-1 -83 38 0
+-54 94 50 0
+29 -9 53 0
+63 50 10 0
+-15 74 23 0
+75 -22 -5 0
+-23 40 -59 0
+84 -48 -70 0
+-82 20 11 0
+94 44 4 0
+39 -85 48 0
+-8 -19 -74 0
+-28 74 -41 0
+-58 -90 18 0
+98 -74 91 0
+-27 -29 -86 0
+-8 80 -100 0
+75 -73 -64 0
+14 -27 63 0
+-77 -92 17 0
+-68 -20 36 0
+35 -3 87 0
+-25 -58 -6 0
+60 86 -1 0
+-65 -93 -87 0
+89 -28 -100 0
+32 16 -96 0
+-51 -74 37 0
+31 22 94 0
+26 -8 -2 0
+-92 77 -89 0
+-85 -32 86 0
+-59 -1 -9 0
+-4 88 91 0
+6 -44 42 0
+-68 48 8 0
+27 23 -41 0
+-47 -61 92 0
+25 -59 -36 0
+-51 -61 -99 0
+23 -35 2 0
+-39 19 -62 0
+-70 77 -24 0
+10 -57 -39 0
+-1 23 55 0
+-53 -38 57 0
+-94 -7 -66 0
+18 56 73 0
+-22 -27 61 0
+55 -74 -56 0
+-30 -25 -7 0
+-34 73 -81 0
+-96 -45 22 0
+72 -9 66 0
+65 23 -12 0
+-90 61 -8 0
+-71 -81 -60 0
+18 75 32 0
+79 14 -27 0
+-83 10 18 0
+-78 18 -9 0
+73 85 36 0
+19 -54 91 0
+-68 73 -46 0
+89 -1 100 0
+-54 -73 -47 0
+-18 -31 -45 0
+-68 81 35 0
+91 -98 1 0
+27 -80 18 0
+55 40 85 0
+61 -20 73 0
+87 -41 16 0
+49 89 43 0
+-68 -51 -14 0
+-98 32 39 0
+-25 -93 60 0
+33 85 -72 0
+93 54 -59 0
+-69 -72 34 0
+82 55 -43 0
+60 -63 -68 0
+52 93 -50 0
+-94 -33 9 0
+-35 38 84 0
+79 1 95 0
+-96 -81 -94 0
+-29 -52 -47 0
+34 68 -20 0
+55 54 25 0
+-78 100 -45 0
+-4 -16 46 0
+-52 -8 -97 0
+84 -20 -39 0
+91 -16 13 0
+60 31 -34 0
+69 7 70 0
+60 56 54 0
+62 66 41 0
+-38 -36 47 0
+21 -3 -10 0
+30 -26 -93 0
+90 -29 8 0
+80 -32 99 0
+-51 -92 58 0
+3 -29 -12 0
+-56 -10 83 0
+79 -12 -41 0
+100 -14 -74 0
+-69 59 -54 0
+-68 -44 -9 0
+-70 26 -4 0
+86 94 -98 0
+-1 13 -94 0
+70 -1 -20 0
+3 34 -5 0
+5 83 1 0
+-94 20 8 0
+-72 47 -35 0
+%
+0
+

benchmarks/uf100/uf100-019.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -26 6 -48 0
+-8 -71 63 0
+45 -40 35 0
+51 -61 -88 0
+-10 -47 83 0
+-12 -96 -19 0
+52 81 -33 0
+-55 79 35 0
+-100 71 88 0
+-76 15 -88 0
+-72 13 -90 0
+24 -26 -84 0
+-92 -40 15 0
+-80 30 -29 0
+44 48 56 0
+-74 61 4 0
+-15 -55 74 0
+-78 -84 74 0
+-33 45 -62 0
+-29 -55 -43 0
+16 -31 -51 0
+67 9 37 0
+76 -84 -13 0
+81 -9 22 0
+-37 -98 88 0
+70 99 -75 0
+3 84 -77 0
+-68 100 67 0
+-58 -29 50 0
+-12 -8 -17 0
+44 -58 97 0
+-87 80 98 0
+46 -87 -22 0
+54 24 -99 0
+22 14 -78 0
+38 -56 -23 0
+49 61 -79 0
+-69 84 -91 0
+33 -74 60 0
+-58 90 -7 0
+-35 58 -94 0
+-18 92 -72 0
+33 -84 53 0
+84 96 -76 0
+-72 -90 41 0
+50 -22 100 0
+37 -9 23 0
+77 5 -21 0
+31 -11 80 0
+-58 25 -2 0
+40 -52 -10 0
+-70 31 -8 0
+-30 16 85 0
+34 -75 -24 0
+26 39 1 0
+15 77 55 0
+24 -86 81 0
+-12 -7 -35 0
+9 91 54 0
+9 -30 74 0
+-13 -72 88 0
+-18 -20 -88 0
+-18 -63 72 0
+-31 -68 19 0
+-19 8 53 0
+-4 -29 -80 0
+-93 13 95 0
+46 -28 -8 0
+-45 -11 35 0
+86 14 -41 0
+46 -10 -85 0
+-1 -92 93 0
+41 18 31 0
+15 78 21 0
+82 -26 29 0
+-79 9 44 0
+43 35 36 0
+-39 70 -25 0
+81 -33 -37 0
+17 -64 -3 0
+81 64 74 0
+68 70 -43 0
+11 44 -43 0
+-94 -93 30 0
+-12 39 -8 0
+-38 88 -47 0
+30 -84 -98 0
+-43 32 -13 0
+-71 39 66 0
+6 45 79 0
+87 39 91 0
+-89 -30 -88 0
+-58 -5 -8 0
+43 -52 90 0
+49 -58 -67 0
+30 -58 7 0
+24 -81 -37 0
+-88 -25 -3 0
+47 37 -36 0
+59 93 45 0
+-94 -49 -74 0
+7 93 46 0
+42 -91 38 0
+-29 -32 69 0
+-52 -26 6 0
+-12 44 74 0
+-51 -50 35 0
+10 -34 29 0
+79 -6 46 0
+-60 21 -38 0
+-91 28 -33 0
+7 -65 26 0
+79 72 53 0
+-22 98 36 0
+80 -5 27 0
+6 60 -71 0
+15 -30 48 0
+58 -50 -80 0
+-40 80 96 0
+82 26 45 0
+50 -49 -73 0
+-5 2 -26 0
+61 100 46 0
+40 50 82 0
+76 7 -55 0
+34 -64 47 0
+3 89 -36 0
+-25 2 -76 0
+-73 82 -34 0
+83 92 -65 0
+-35 -46 42 0
+15 -54 -14 0
+26 -7 -56 0
+87 49 -79 0
+79 -87 44 0
+58 -44 -65 0
+54 49 -4 0
+29 37 13 0
+17 -61 -89 0
+-16 -51 -70 0
+82 -32 12 0
+36 24 -56 0
+98 -56 24 0
+20 2 -97 0
+-92 54 -11 0
+30 95 -16 0
+49 76 9 0
+91 13 -90 0
+49 -44 77 0
+6 43 -69 0
+1 -33 76 0
+1 22 92 0
+44 16 20 0
+-9 78 87 0
+-1 29 -80 0
+50 -46 -16 0
+40 -61 11 0
+-38 14 -52 0
+-1 56 -59 0
+24 42 -10 0
+87 -60 -100 0
+91 -24 -22 0
+-38 92 -5 0
+70 50 8 0
+9 -59 91 0
+-73 -49 60 0
+-33 42 66 0
+45 -80 -12 0
+1 -38 10 0
+58 -73 -4 0
+48 64 -14 0
+51 70 6 0
+36 68 -29 0
+8 18 -35 0
+-62 84 -73 0
+31 -79 -28 0
+9 -36 -33 0
+-64 88 24 0
+90 -43 -58 0
+-24 -22 -67 0
+-61 -18 -76 0
+-52 -71 98 0
+-41 49 -38 0
+-4 -30 -16 0
+45 -78 -97 0
+-9 36 -1 0
+47 -75 32 0
+93 -99 66 0
+3 66 -36 0
+-93 -73 67 0
+-72 -93 -77 0
+-34 -23 74 0
+83 -60 -32 0
+-54 91 -60 0
+79 -1 60 0
+-87 62 35 0
+63 67 35 0
+69 -16 60 0
+-95 18 40 0
+42 85 48 0
+-43 -16 98 0
+89 -41 99 0
+-24 46 47 0
+-32 -40 28 0
+-18 35 19 0
+3 -78 64 0
+32 -45 -84 0
+61 -91 -6 0
+16 -5 -91 0
+-77 -93 -20 0
+43 -61 -33 0
+49 93 -33 0
+-92 -82 -91 0
+49 4 69 0
+24 -37 -44 0
+-61 56 32 0
+15 10 -52 0
+38 13 43 0
+84 -5 76 0
+-47 -74 -57 0
+89 52 8 0
+-40 -33 -34 0
+-43 -17 -77 0
+-91 -35 82 0
+86 -3 -6 0
+93 82 -50 0
+-25 41 -99 0
+-23 -75 94 0
+-77 51 79 0
+-91 2 39 0
+94 36 13 0
+10 61 -55 0
+-86 42 62 0
+24 -18 -71 0
+-38 -67 89 0
+8 -57 68 0
+-35 9 -65 0
+76 -4 -25 0
+59 6 -83 0
+17 47 -26 0
+37 30 44 0
+-9 -84 -52 0
+-56 -49 -72 0
+-45 -61 -28 0
+-90 15 -12 0
+32 67 -44 0
+45 -100 38 0
+-72 21 79 0
+97 51 -93 0
+11 14 76 0
+-22 -41 -80 0
+-52 21 -95 0
+-96 -9 -88 0
+8 -57 -45 0
+62 91 -83 0
+51 -35 32 0
+25 51 -29 0
+-87 36 74 0
+67 18 -90 0
+-80 81 -60 0
+-53 -69 7 0
+92 24 -57 0
+-85 30 32 0
+-92 -70 -61 0
+51 61 -60 0
+-83 -75 46 0
+-95 -50 68 0
+-47 54 40 0
+-21 -3 -12 0
+60 35 -52 0
+96 28 48 0
+-86 -11 56 0
+64 -8 -78 0
+-45 -6 -92 0
+-48 -46 -11 0
+73 60 -84 0
+-27 87 -11 0
+-6 3 -79 0
+-72 51 -70 0
+39 -54 -2 0
+5 26 -88 0
+-74 -12 -99 0
+61 -54 49 0
+-15 10 82 0
+-16 69 40 0
+-69 -48 -31 0
+45 69 43 0
+84 73 -60 0
+43 -41 -54 0
+-36 26 32 0
+-68 96 -25 0
+-58 92 11 0
+-66 84 -83 0
+-36 57 -8 0
+-91 -38 -31 0
+-58 -81 -34 0
+-51 28 -50 0
+-84 -74 -45 0
+21 -2 18 0
+-28 47 -68 0
+-25 -94 33 0
+-16 -27 31 0
+-27 72 -13 0
+32 -58 81 0
+79 -14 84 0
+99 -95 -14 0
+-34 68 16 0
+3 60 75 0
+-96 62 -70 0
+-14 89 69 0
+18 -33 -34 0
+22 -97 -54 0
+41 -63 -47 0
+-27 -75 38 0
+52 -64 -36 0
+-60 80 -2 0
+79 -32 62 0
+-19 10 -85 0
+-42 51 -38 0
+-27 99 52 0
+32 -78 92 0
+-99 -49 35 0
+-81 -99 13 0
+-28 -5 87 0
+53 -11 -32 0
+16 5 -28 0
+10 -37 47 0
+-47 78 -26 0
+-96 70 -95 0
+15 -87 -89 0
+97 6 67 0
+-23 43 -69 0
+-14 -16 21 0
+68 -27 -6 0
+65 48 73 0
+8 -43 1 0
+55 79 -48 0
+19 60 -2 0
+-50 1 86 0
+38 15 95 0
+45 -34 75 0
+-51 19 -9 0
+-85 -60 15 0
+45 49 -47 0
+-78 -41 12 0
+-3 95 70 0
+7 -91 -54 0
+-70 -73 -55 0
+-31 4 1 0
+-74 -11 -44 0
+-21 -85 90 0
+-26 -68 19 0
+73 53 81 0
+-80 67 -43 0
+84 17 -87 0
+22 54 11 0
+38 -82 -59 0
+89 -17 -46 0
+-96 -19 28 0
+-60 -79 -90 0
+8 2 12 0
+59 -52 -7 0
+83 -56 88 0
+14 67 59 0
+44 -2 -100 0
+92 96 -81 0
+30 -73 46 0
+-7 -72 69 0
+-34 -14 8 0
+13 97 52 0
+-91 22 36 0
+66 -54 23 0
+-25 -97 -83 0
+34 24 97 0
+91 29 -46 0
+82 31 98 0
+-67 -68 -76 0
+-100 -3 -63 0
+-66 -30 -77 0
+-12 61 -21 0
+33 85 -92 0
+53 -68 61 0
+-94 57 42 0
+-10 -5 67 0
+78 98 -99 0
+-69 -86 50 0
+-51 54 4 0
+73 66 84 0
+38 -10 88 0
+-2 -55 23 0
+59 -58 -9 0
+-52 -7 -49 0
+-98 -58 25 0
+-3 24 39 0
+15 49 -70 0
+-61 8 -17 0
+65 68 -78 0
+-72 21 20 0
+-26 -5 -29 0
+80 10 -25 0
+-8 -82 -24 0
+-41 -65 74 0
+25 8 -56 0
+46 14 -90 0
+90 -18 -91 0
+46 73 -70 0
+91 -8 -40 0
+-69 3 -31 0
+35 26 82 0
+-34 53 38 0
+-18 90 -48 0
+-53 -29 -98 0
+-68 42 95 0
+-90 66 -33 0
+-18 45 19 0
+58 34 -26 0
+-96 -74 -93 0
+-85 33 7 0
+87 -21 4 0
+86 -9 -58 0
+-40 22 7 0
+29 22 -1 0
+-88 99 95 0
+-65 49 35 0
+-69 48 -6 0
+-12 -33 86 0
+6 -80 -14 0
+14 -92 78 0
+-40 35 -55 0
+23 -86 -42 0
+%
+0
+

benchmarks/uf100/uf100-02.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 10 -41 60 0
+-45 41 36 0
+78 -25 -84 0
+89 -55 -2 0
+-85 55 -50 0
+7 42 -51 0
+69 -61 -35 0
+-13 -92 36 0
+46 -34 11 0
+-30 -66 -55 0
+71 -70 97 0
+-20 -61 78 0
+7 -9 37 0
+-64 -12 51 0
+75 -89 -97 0
+-85 -39 29 0
+-98 80 -83 0
+-20 -40 -88 0
+73 45 66 0
+-55 94 -14 0
+11 -8 -21 0
+61 -87 -59 0
+23 81 32 0
+65 10 -58 0
+-55 87 -71 0
+-49 -48 -1 0
+-49 76 -8 0
+14 -19 31 0
+88 -65 -2 0
+73 83 50 0
+-89 -68 43 0
+6 -3 9 0
+13 8 64 0
+-88 20 -84 0
+69 10 -63 0
+60 -38 50 0
+36 100 8 0
+-90 -26 10 0
+-72 57 -61 0
+-35 15 -8 0
+79 -92 -94 0
+34 -30 88 0
+-42 62 -27 0
+-92 86 -53 0
+-50 -75 14 0
+14 -50 37 0
+-95 -12 61 0
+84 94 95 0
+-6 -36 95 0
+-57 -37 -9 0
+-16 8 30 0
+85 -10 -19 0
+-78 -76 65 0
+-82 91 44 0
+12 -5 -67 0
+100 92 -69 0
+-37 -29 -94 0
+-26 51 62 0
+99 -5 -37 0
+72 92 -90 0
+-100 12 56 0
+53 77 29 0
+-33 58 -52 0
+-40 -47 -78 0
+61 -60 -51 0
+-15 -99 74 0
+-71 -20 92 0
+-100 -99 81 0
+25 33 -76 0
+61 69 24 0
+73 34 -21 0
+-61 -74 -8 0
+76 -72 -56 0
+47 97 61 0
+10 -74 -47 0
+94 26 -90 0
+-2 -3 -85 0
+-29 -47 -30 0
+69 -17 -90 0
+-53 -76 -69 0
+-69 90 86 0
+35 -31 -17 0
+77 -13 38 0
+-100 -66 -24 0
+-84 48 -64 0
+-13 -16 -49 0
+12 9 -10 0
+-20 4 6 0
+-65 -9 -68 0
+76 81 -10 0
+100 45 73 0
+27 -54 -55 0
+30 -1 -85 0
+37 23 -2 0
+-67 86 80 0
+33 -25 -58 0
+51 100 54 0
+-88 66 -37 0
+-66 38 17 0
+66 -8 11 0
+59 16 61 0
+-16 -71 -33 0
+4 64 34 0
+34 -1 72 0
+-76 -33 21 0
+-22 -36 20 0
+15 67 -10 0
+16 -39 -49 0
+-83 -12 -84 0
+-68 37 -83 0
+93 44 97 0
+-51 -40 15 0
+-46 -2 -88 0
+-79 -34 78 0
+-13 56 -76 0
+-57 37 -42 0
+1 -99 -7 0
+-64 -5 96 0
+-17 78 -80 0
+33 53 -24 0
+-5 -6 47 0
+-60 53 20 0
+-39 16 -9 0
+7 94 35 0
+33 87 -27 0
+-45 -41 -1 0
+4 59 7 0
+37 -73 34 0
+100 -69 -43 0
+-38 2 -62 0
+-59 -86 37 0
+14 81 95 0
+-38 -41 -100 0
+-20 86 -31 0
+-38 57 1 0
+95 80 27 0
+-68 -52 -84 0
+-90 -9 28 0
+-51 -100 99 0
+-80 -99 -76 0
+21 93 76 0
+51 -92 67 0
+21 43 46 0
+-62 -83 -25 0
+-78 43 -85 0
+49 -44 -75 0
+39 -42 90 0
+-43 97 86 0
+14 -7 -100 0
+24 -45 5 0
+-91 -47 -72 0
+-63 10 -5 0
+-95 57 77 0
+-97 -59 -29 0
+-59 21 39 0
+-91 -19 -83 0
+25 -46 -63 0
+-10 -92 -35 0
+9 -69 38 0
+-32 -24 -55 0
+-7 78 -2 0
+43 -65 30 0
+83 -3 -18 0
+97 59 -35 0
+65 47 24 0
+42 11 -8 0
+-74 15 21 0
+-62 -11 -65 0
+76 96 13 0
+80 94 83 0
+9 71 -27 0
+7 -75 -91 0
+74 -15 9 0
+92 -70 3 0
+41 -59 -26 0
+-40 -70 25 0
+43 92 -100 0
+32 92 -68 0
+47 21 31 0
+82 -66 69 0
+-62 -30 -100 0
+12 -39 -75 0
+65 3 84 0
+93 89 -34 0
+33 20 24 0
+32 -88 43 0
+-15 -86 76 0
+-82 -61 -50 0
+78 85 82 0
+-69 41 -40 0
+6 73 54 0
+-87 18 12 0
+-10 -88 -69 0
+52 31 -46 0
+-52 11 94 0
+57 -9 8 0
+37 44 28 0
+57 -16 -22 0
+87 -27 5 0
+-87 11 -57 0
+16 -59 69 0
+-34 -5 -70 0
+96 10 -92 0
+-91 -22 -93 0
+-42 41 -63 0
+58 -36 -23 0
+53 -93 96 0
+-98 -50 -59 0
+55 -58 -15 0
+-99 -95 10 0
+25 -52 66 0
+37 -30 -17 0
+81 50 -21 0
+33 93 -45 0
+17 -38 -94 0
+56 -22 38 0
+45 -6 61 0
+-19 -45 52 0
+90 75 -84 0
+-53 52 -75 0
+-35 72 99 0
+-1 -45 -58 0
+93 -1 -98 0
+-83 -48 -56 0
+48 38 -21 0
+-84 51 -42 0
+-95 -6 26 0
+5 59 -9 0
+83 -86 -14 0
+8 100 -36 0
+99 -6 2 0
+21 82 -14 0
+-54 38 39 0
+28 -23 -27 0
+-39 -69 79 0
+25 96 -6 0
+34 56 74 0
+-27 55 -44 0
+-7 -43 34 0
+-23 35 -91 0
+21 -27 -97 0
+81 18 -63 0
+54 -74 -14 0
+-26 32 -3 0
+-73 38 5 0
+54 55 63 0
+39 82 -42 0
+-70 -63 34 0
+-80 -8 -54 0
+-53 40 7 0
+-93 56 -95 0
+80 44 -78 0
+82 -15 49 0
+-36 -78 38 0
+-58 -12 45 0
+-5 62 3 0
+-94 97 -52 0
+57 99 11 0
+-36 49 86 0
+78 -97 57 0
+-68 -65 87 0
+78 57 100 0
+26 -84 16 0
+45 -25 78 0
+75 -74 -12 0
+57 63 -37 0
+47 11 -56 0
+-63 66 -68 0
+-6 -46 -81 0
+-99 51 -11 0
+-39 9 20 0
+-29 -53 -75 0
+36 -57 -26 0
+20 -4 62 0
+2 30 90 0
+95 50 -45 0
+33 60 39 0
+-65 -70 88 0
+72 3 50 0
+-72 7 -58 0
+98 12 18 0
+-29 -58 10 0
+-99 29 -13 0
+-32 90 98 0
+-9 95 66 0
+-54 -39 52 0
+-26 -22 -11 0
+-91 15 -66 0
+-8 23 -59 0
+-98 -40 -71 0
+98 50 -35 0
+-51 -71 20 0
+-15 55 -20 0
+42 39 76 0
+63 -25 -61 0
+-29 86 -7 0
+-62 85 -24 0
+86 61 -42 0
+58 -83 11 0
+54 -46 -63 0
+-71 -6 -37 0
+-30 31 56 0
+-40 98 62 0
+-53 -61 -86 0
+-2 -47 -14 0
+-16 32 -97 0
+-23 -39 96 0
+81 31 5 0
+45 65 -68 0
+99 -30 -8 0
+-2 -10 1 0
+-63 -85 48 0
+-66 -44 -70 0
+78 -31 -45 0
+7 -59 -2 0
+-84 -73 -6 0
+94 -33 52 0
+80 58 59 0
+-29 -6 75 0
+46 -58 -94 0
+44 56 36 0
+-17 -34 39 0
+83 55 88 0
+-85 32 -21 0
+-94 -51 30 0
+-51 -42 -58 0
+93 -7 31 0
+62 -57 -60 0
+-64 83 -94 0
+-57 36 50 0
+88 -74 -90 0
+-42 -53 -86 0
+78 -45 17 0
+-99 58 98 0
+91 -98 -74 0
+-89 71 70 0
+58 57 -82 0
+4 7 10 0
+35 41 60 0
+72 -24 -99 0
+42 54 -52 0
+40 90 -23 0
+-86 -37 -58 0
+-98 92 -41 0
+-58 95 -98 0
+-38 -82 16 0
+-54 -32 -37 0
+-28 38 -5 0
+85 -29 -53 0
+-99 -44 72 0
+-59 37 -94 0
+-21 -79 -17 0
+26 -82 6 0
+93 -50 -66 0
+-22 -74 -95 0
+-5 28 -30 0
+-83 -23 -33 0
+-67 6 69 0
+-9 -29 -85 0
+26 -95 33 0
+13 -93 29 0
+97 -73 53 0
+-16 38 -37 0
+-19 -2 -4 0
+19 -70 -95 0
+51 -25 -93 0
+-13 7 19 0
+21 76 19 0
+49 50 40 0
+-60 -95 -97 0
+48 3 -17 0
+30 55 78 0
+-82 -58 91 0
+-37 89 -76 0
+37 -8 -74 0
+80 63 -82 0
+-50 -59 30 0
+-78 54 -36 0
+-14 -78 -63 0
+67 91 83 0
+6 4 87 0
+-73 -69 68 0
+47 -19 48 0
+-38 -84 -27 0
+84 -42 34 0
+11 -90 -26 0
+-6 68 32 0
+21 52 91 0
+82 50 -95 0
+2 25 -95 0
+-75 -42 -69 0
+-64 -80 -36 0
+38 74 20 0
+39 100 81 0
+-86 10 -47 0
+60 -20 -28 0
+-83 74 -30 0
+15 1 18 0
+82 18 -29 0
+-1 -36 -98 0
+-41 100 -96 0
+-63 -2 -64 0
+91 94 92 0
+-56 18 -28 0
+35 32 -88 0
+7 53 -68 0
+-92 -83 -89 0
+46 -66 -61 0
+-47 28 15 0
+27 -46 -79 0
+83 -84 -44 0
+37 77 47 0
+-92 77 -87 0
+-50 59 -87 0
+-10 -59 44 0
+79 55 -5 0
+86 -42 -66 0
+53 58 -74 0
+-98 59 -45 0
+83 33 36 0
+-47 99 -63 0
+41 6 -9 0
+-3 90 33 0
+63 26 1 0
+85 93 -56 0
+-28 66 -75 0
+-59 -57 2 0
+-42 66 -28 0
+16 4 -82 0
+-40 95 84 0
+%
+0
+

benchmarks/uf100/uf100-020.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 30 -6 -82 0
+87 -79 37 0
+66 76 -43 0
+-88 -85 11 0
+89 -66 93 0
+-87 4 -6 0
+-62 92 39 0
+-13 3 14 0
+28 -20 -31 0
+-76 80 58 0
+-68 -99 37 0
+-33 29 -34 0
+9 -41 72 0
+-68 -23 22 0
+92 36 -50 0
+71 -2 -19 0
+77 98 -93 0
+-56 -65 34 0
+46 84 -58 0
+-36 -79 -62 0
+-68 -53 67 0
+46 73 -33 0
+1 -76 -22 0
+70 99 66 0
+-98 -79 -88 0
+-24 32 22 0
+-24 64 90 0
+13 4 85 0
+-17 7 -37 0
+-90 -33 57 0
+-46 15 -53 0
+-84 -28 34 0
+-83 97 -40 0
+6 47 84 0
+-20 -18 50 0
+98 39 -55 0
+-20 -90 -86 0
+91 45 -65 0
+-6 -17 -42 0
+-7 -79 -87 0
+-97 52 19 0
+-10 -21 -14 0
+-65 20 30 0
+-100 49 66 0
+-96 86 21 0
+49 -92 20 0
+11 -14 57 0
+70 -52 99 0
+46 33 90 0
+-31 -25 45 0
+32 55 66 0
+43 61 -66 0
+18 100 50 0
+40 92 66 0
+-54 56 -29 0
+44 69 -47 0
+-18 -43 54 0
+80 9 2 0
+63 -66 -38 0
+-32 48 -20 0
+-52 -89 26 0
+92 -15 -70 0
+48 78 -69 0
+96 -70 -59 0
+97 -28 1 0
+-73 39 35 0
+-26 -29 47 0
+55 -21 22 0
+-18 -65 -98 0
+30 94 22 0
+76 -83 -49 0
+-42 7 -13 0
+-33 -56 -8 0
+-83 -96 42 0
+-74 2 33 0
+-5 7 25 0
+-38 58 12 0
+37 80 68 0
+-21 -17 43 0
+1 -70 16 0
+76 70 -53 0
+6 60 -27 0
+-30 -46 -53 0
+-44 -11 -4 0
+100 73 70 0
+62 -83 5 0
+83 89 -86 0
+82 36 40 0
+22 -76 40 0
+-25 -62 -85 0
+29 -39 -73 0
+59 36 44 0
+-39 -27 85 0
+8 83 -94 0
+60 33 -17 0
+35 -56 -33 0
+63 -48 -21 0
+57 31 -91 0
+-59 -17 34 0
+7 -24 74 0
+17 2 57 0
+-34 -72 -94 0
+18 -35 16 0
+-59 -34 41 0
+34 92 -29 0
+-9 -31 98 0
+11 -12 -79 0
+89 -82 -91 0
+-29 49 -1 0
+-75 -77 -3 0
+-91 -21 97 0
+-67 -11 81 0
+-59 57 -28 0
+91 -95 60 0
+-10 57 37 0
+84 -69 32 0
+-6 -79 -14 0
+-34 -10 -79 0
+88 -51 67 0
+81 -96 -4 0
+-52 71 -20 0
+17 -16 67 0
+-81 25 -30 0
+-31 -9 36 0
+43 -36 17 0
+97 -4 -75 0
+-5 3 -100 0
+90 -14 15 0
+5 -3 -45 0
+-61 -43 -35 0
+-81 85 -91 0
+39 -6 81 0
+28 -66 -27 0
+79 89 -1 0
+-22 -90 42 0
+44 47 15 0
+-12 -40 -21 0
+6 62 32 0
+26 -35 30 0
+71 54 -70 0
+71 -66 13 0
+18 -7 50 0
+15 90 -8 0
+75 63 -89 0
+33 82 6 0
+2 -80 -91 0
+-43 3 64 0
+-38 -26 -45 0
+-47 37 87 0
+-83 30 -45 0
+87 19 60 0
+44 6 81 0
+72 43 66 0
+15 60 76 0
+-41 -93 -54 0
+54 -65 11 0
+30 9 19 0
+38 15 -78 0
+43 46 -51 0
+-43 -88 54 0
+-88 26 -97 0
+13 -68 71 0
+67 15 -29 0
+-35 -61 -6 0
+47 21 40 0
+33 5 -38 0
+-92 16 43 0
+76 -13 -35 0
+-64 -92 -13 0
+-22 24 12 0
+73 -57 33 0
+86 77 -51 0
+-49 14 -10 0
+35 81 58 0
+-39 71 -58 0
+79 5 38 0
+-48 1 100 0
+96 -77 -51 0
+72 95 -49 0
+63 80 70 0
+2 9 7 0
+-63 -69 -22 0
+99 -63 -28 0
+-18 -40 81 0
+65 30 2 0
+36 -52 -41 0
+-63 53 -30 0
+-35 -13 60 0
+48 81 67 0
+-51 12 64 0
+84 82 -65 0
+-85 8 15 0
+-3 -34 -71 0
+12 77 -66 0
+91 -36 -64 0
+26 -63 -42 0
+35 70 4 0
+60 41 -59 0
+-29 -16 -32 0
+-94 -47 -91 0
+-34 16 -76 0
+99 88 77 0
+8 -65 60 0
+-67 85 46 0
+54 -88 -92 0
+44 -92 97 0
+-92 56 3 0
+69 10 -93 0
+-43 -14 -46 0
+-89 27 74 0
+43 -81 -42 0
+-54 -91 -53 0
+-84 -27 66 0
+-37 -97 -27 0
+68 -73 -27 0
+91 96 45 0
+-30 89 -35 0
+38 28 -19 0
+17 40 -69 0
+-43 88 -26 0
+-34 19 74 0
+-22 -80 96 0
+-49 100 -68 0
+40 -19 10 0
+-61 -4 19 0
+64 -7 66 0
+45 -6 -95 0
+80 -10 -55 0
+18 15 76 0
+-58 -84 41 0
+-23 -33 21 0
+-3 -14 -10 0
+53 -34 -80 0
+65 98 -71 0
+77 -83 76 0
+-31 -82 78 0
+-55 -72 61 0
+35 23 47 0
+70 94 -26 0
+33 10 -34 0
+53 57 74 0
+77 62 -15 0
+-51 -61 6 0
+25 -46 -29 0
+100 18 -72 0
+-26 79 -55 0
+-41 84 24 0
+39 -72 -10 0
+80 94 31 0
+71 -43 -34 0
+-41 -2 38 0
+-57 -41 29 0
+29 -35 -21 0
+-24 -59 83 0
+71 -38 69 0
+64 21 46 0
+-47 -73 -86 0
+25 81 -16 0
+36 -43 54 0
+44 -69 59 0
+58 37 -60 0
+49 -85 -48 0
+16 85 -80 0
+-27 -66 42 0
+-2 27 -7 0
+-100 -97 -17 0
+-35 -48 -39 0
+83 98 -63 0
+56 -79 3 0
+-38 89 48 0
+-97 25 -44 0
+-91 -72 36 0
+56 -51 17 0
+-79 -35 -9 0
+-22 8 -60 0
+97 -2 12 0
+-37 48 -7 0
+6 -76 -10 0
+-52 -72 -24 0
+-32 74 1 0
+-79 -39 -7 0
+27 -15 11 0
+92 93 -7 0
+91 66 72 0
+8 58 98 0
+14 28 -80 0
+-83 -44 -73 0
+24 -69 -52 0
+30 -61 -32 0
+26 -82 -16 0
+63 3 92 0
+-100 -5 53 0
+-31 20 -97 0
+-48 -79 28 0
+-37 5 -84 0
+17 90 -76 0
+-16 32 -2 0
+-98 35 -18 0
+-61 65 45 0
+-90 80 -29 0
+47 -48 -45 0
+19 72 9 0
+19 37 -47 0
+2 -92 -28 0
+-70 71 -50 0
+-53 90 -30 0
+-75 30 -56 0
+96 68 -33 0
+6 -5 55 0
+-3 21 6 0
+-34 -71 38 0
+48 44 79 0
+99 -23 -96 0
+95 71 -4 0
+-85 -6 -75 0
+-38 -92 64 0
+24 3 76 0
+30 5 -26 0
+25 -31 -61 0
+-83 -64 70 0
+49 -91 -19 0
+45 -91 -75 0
+23 22 85 0
+-39 -72 51 0
+64 82 94 0
+-60 -87 38 0
+51 -43 -94 0
+-6 85 -8 0
+-11 -72 27 0
+-91 -36 8 0
+-31 28 33 0
+-72 -56 74 0
+-51 -87 -21 0
+14 87 -26 0
+-67 38 33 0
+-20 52 29 0
+-82 -92 -90 0
+92 -8 57 0
+-67 80 -19 0
+90 -86 3 0
+-23 78 -77 0
+-85 -12 88 0
+46 -59 51 0
+-35 37 96 0
+19 -1 22 0
+64 -38 23 0
+-100 78 6 0
+20 -3 100 0
+56 10 12 0
+-28 -58 -49 0
+-63 -25 18 0
+77 69 -41 0
+-69 -16 89 0
+-46 99 16 0
+82 -95 -70 0
+26 56 -81 0
+78 -9 -40 0
+-8 28 -69 0
+100 63 -56 0
+57 99 -88 0
+-82 -54 -37 0
+-34 -74 77 0
+-27 -100 -62 0
+53 94 -42 0
+-2 -66 -56 0
+70 73 39 0
+-75 69 9 0
+86 -68 -100 0
+-26 16 -88 0
+-24 25 -61 0
+65 -84 -25 0
+38 64 -28 0
+46 100 -37 0
+39 71 15 0
+-23 62 -64 0
+-36 6 -61 0
+20 -46 14 0
+-18 -38 -28 0
+-54 22 -45 0
+-8 -70 -43 0
+48 88 -90 0
+-59 68 43 0
+1 -33 -72 0
+2 40 75 0
+-28 -16 92 0
+54 34 -33 0
+-40 -1 -48 0
+-17 75 -96 0
+42 4 22 0
+38 77 46 0
+74 100 66 0
+86 -82 -9 0
+-97 -80 -57 0
+-74 9 63 0
+-26 -62 89 0
+-4 -64 -35 0
+-78 -55 57 0
+69 -86 -1 0
+85 52 77 0
+60 73 -62 0
+84 49 -15 0
+-94 -96 39 0
+-71 -51 -12 0
+39 61 -41 0
+-15 67 61 0
+28 99 -54 0
+-26 -10 68 0
+91 31 -1 0
+91 -39 36 0
+-19 68 10 0
+84 70 24 0
+-10 38 50 0
+27 -92 40 0
+3 85 79 0
+-82 35 99 0
+17 98 12 0
+80 45 -61 0
+-38 -48 54 0
+-18 78 32 0
+28 -98 -82 0
+-67 6 93 0
+-1 -25 -72 0
+-23 -92 41 0
+-24 -86 93 0
+-2 9 -6 0
+-79 -2 100 0
+-98 80 70 0
+62 64 -15 0
+18 63 -69 0
+18 19 -60 0
+%
+0
+

benchmarks/uf100/uf100-021.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 56 22 42 0
+-44 -68 82 0
+65 -32 -54 0
+87 -26 70 0
+12 80 -9 0
+-59 -41 -29 0
+-22 30 -55 0
+56 48 32 0
+-87 -32 42 0
+-81 -80 -90 0
+42 39 -4 0
+42 31 -32 0
+96 -42 -88 0
+73 -98 30 0
+21 -78 -99 0
+-46 16 -78 0
+8 -48 -86 0
+27 91 -36 0
+88 3 -90 0
+27 -65 67 0
+-100 -14 -58 0
+32 87 22 0
+12 -52 8 0
+40 -53 -41 0
+-18 97 49 0
+-26 -22 30 0
+-58 32 95 0
+97 61 73 0
+-42 -47 -91 0
+67 -94 -57 0
+-32 -3 1 0
+-71 44 -32 0
+-86 20 41 0
+-97 65 -95 0
+48 14 64 0
+-84 61 42 0
+85 -93 -71 0
+97 44 14 0
+-85 -99 1 0
+50 33 -62 0
+-53 20 -51 0
+-22 89 66 0
+-87 2 -68 0
+37 24 -68 0
+85 -54 86 0
+-36 20 42 0
+60 36 34 0
+50 15 -41 0
+-87 -51 3 0
+-7 72 60 0
+-14 53 -45 0
+1 98 94 0
+73 -72 -37 0
+-92 75 -1 0
+-100 37 -60 0
+84 -42 -29 0
+-87 97 -65 0
+2 3 59 0
+-89 -6 -22 0
+76 -99 87 0
+12 -42 -57 0
+-7 57 -50 0
+58 -38 -83 0
+-63 -64 3 0
+35 -28 -2 0
+-37 75 -1 0
+-46 -22 -27 0
+-75 -51 -1 0
+-55 30 -40 0
+-60 -49 -19 0
+20 -7 -57 0
+91 45 -92 0
+-80 -14 35 0
+-56 -26 30 0
+86 42 -93 0
+87 22 -69 0
+14 32 -12 0
+89 28 65 0
+-24 -62 61 0
+-97 42 -86 0
+52 -32 -10 0
+-89 -88 84 0
+51 82 -59 0
+-51 -28 -12 0
+-79 -25 40 0
+19 -2 -38 0
+28 -63 73 0
+-78 36 63 0
+-44 68 56 0
+9 -27 63 0
+77 -13 34 0
+-4 80 72 0
+79 -84 62 0
+-70 20 -26 0
+83 46 -27 0
+8 53 93 0
+25 -84 -73 0
+80 -74 -61 0
+91 70 -33 0
+80 -26 97 0
+-66 -65 -90 0
+59 12 -78 0
+-30 91 -42 0
+-53 2 62 0
+35 97 -31 0
+68 52 -57 0
+85 -49 -29 0
+46 -51 38 0
+-88 -64 -91 0
+7 -77 25 0
+-6 -47 64 0
+13 -56 50 0
+-37 -17 61 0
+-3 39 -86 0
+88 -18 42 0
+-25 62 67 0
+90 -37 -94 0
+50 -15 81 0
+33 -91 -71 0
+83 -72 -99 0
+46 -9 15 0
+51 86 -76 0
+-9 -74 -68 0
+-21 16 47 0
+-72 16 -1 0
+24 -86 -93 0
+-78 -49 -75 0
+-6 -100 -73 0
+-29 -9 73 0
+5 71 -21 0
+-90 65 48 0
+71 81 -93 0
+44 40 -85 0
+73 42 -82 0
+-50 21 -52 0
+-33 -15 -57 0
+25 67 -41 0
+-2 -56 15 0
+60 -46 -69 0
+-21 40 4 0
+65 43 44 0
+82 -47 7 0
+97 -65 74 0
+38 -10 -92 0
+-90 72 21 0
+-23 8 -74 0
+6 11 43 0
+30 70 4 0
+-78 -31 41 0
+-73 -52 -43 0
+-90 3 48 0
+-60 -42 -86 0
+1 3 -61 0
+-54 21 -12 0
+-17 77 44 0
+-34 -32 -42 0
+25 47 -15 0
+-2 19 91 0
+-44 -77 -54 0
+-48 89 -34 0
+-31 -81 -9 0
+-46 -87 -42 0
+48 -99 79 0
+72 -6 78 0
+82 9 -38 0
+92 31 67 0
+96 49 15 0
+-97 -56 -11 0
+-77 -65 78 0
+4 -71 47 0
+-27 -78 94 0
+73 30 37 0
+-7 -93 60 0
+58 50 9 0
+-16 -9 94 0
+-84 72 -18 0
+98 22 -28 0
+82 39 58 0
+-73 -79 93 0
+28 -6 40 0
+-61 46 -6 0
+-77 20 -5 0
+-36 -47 -27 0
+49 45 -63 0
+-57 41 -33 0
+39 -48 73 0
+-94 90 5 0
+-68 -78 60 0
+64 3 72 0
+-20 -89 47 0
+-19 5 -97 0
+19 16 -56 0
+-36 -81 77 0
+-21 -39 -33 0
+98 84 53 0
+-93 55 24 0
+56 -65 -61 0
+-11 24 54 0
+-18 39 66 0
+-15 -29 14 0
+87 -66 4 0
+56 11 15 0
+90 33 27 0
+71 -38 83 0
+-67 -3 42 0
+29 -57 79 0
+-83 23 -45 0
+1 -28 100 0
+-71 -40 56 0
+66 42 46 0
+-21 -51 72 0
+-33 -66 -61 0
+44 -65 -26 0
+62 35 -17 0
+-80 -53 6 0
+7 25 93 0
+39 74 -91 0
+60 -1 16 0
+-64 -54 -46 0
+41 48 -8 0
+-67 41 6 0
+-90 86 87 0
+-71 -62 24 0
+96 29 69 0
+96 -51 83 0
+-86 64 58 0
+-5 -13 -90 0
+14 63 54 0
+53 -44 -46 0
+57 -80 6 0
+57 -70 -66 0
+18 -66 -1 0
+-99 70 56 0
+70 -60 48 0
+-71 -38 -11 0
+78 34 64 0
+31 -64 90 0
+-24 69 17 0
+84 90 -83 0
+-62 75 -2 0
+67 -27 -12 0
+55 100 -22 0
+91 54 -61 0
+31 17 -71 0
+-77 -9 -50 0
+-57 -47 -27 0
+27 -32 96 0
+40 -68 80 0
+-82 5 -29 0
+-28 -94 -84 0
+77 -30 -11 0
+-98 -24 -20 0
+-19 12 63 0
+11 95 -41 0
+-14 -75 52 0
+-61 28 -54 0
+-59 28 75 0
+73 40 -59 0
+73 -48 65 0
+72 -1 86 0
+48 59 -65 0
+52 -88 22 0
+73 -38 83 0
+-2 -46 -69 0
+-78 -31 -56 0
+-100 2 11 0
+-58 -54 -28 0
+23 -52 30 0
+-26 84 49 0
+49 -27 -39 0
+-57 -90 -95 0
+8 -11 51 0
+-27 13 -82 0
+59 42 -48 0
+-15 -84 24 0
+45 43 -3 0
+-36 -18 -67 0
+-15 78 -69 0
+60 -92 -28 0
+4 -12 46 0
+40 10 -76 0
+-98 -84 -3 0
+-21 -85 -33 0
+75 41 -57 0
+65 -51 67 0
+43 -17 -41 0
+4 57 73 0
+-61 42 26 0
+59 6 -46 0
+70 -72 44 0
+66 25 -38 0
+-95 -47 -54 0
+8 14 16 0
+-39 -66 -52 0
+79 -50 31 0
+-44 -51 -38 0
+78 52 -27 0
+6 -26 94 0
+69 -98 66 0
+79 -61 -96 0
+-23 26 -31 0
+-40 85 -39 0
+46 23 82 0
+40 12 38 0
+51 11 -81 0
+-26 43 -90 0
+-44 41 -82 0
+39 -52 -20 0
+-61 30 75 0
+-19 86 17 0
+-63 58 -79 0
+49 59 22 0
+27 -79 -80 0
+-10 -60 1 0
+91 -78 -21 0
+45 -40 11 0
+4 -40 83 0
+53 96 2 0
+3 51 61 0
+-38 26 -97 0
+12 -77 14 0
+46 3 45 0
+-52 80 -10 0
+55 14 3 0
+35 54 -63 0
+4 24 -73 0
+-22 91 75 0
+81 -71 91 0
+-79 6 -44 0
+-29 -75 44 0
+-63 -11 80 0
+-47 -57 68 0
+-37 40 -39 0
+40 -37 24 0
+62 32 -47 0
+-84 -29 -96 0
+64 -31 -35 0
+80 -34 -33 0
+98 -34 -100 0
+-25 29 88 0
+-57 -33 36 0
+-31 -60 51 0
+-58 -70 -81 0
+-54 85 -8 0
+-10 30 -4 0
+4 58 -86 0
+59 40 42 0
+56 -63 -2 0
+11 -5 -74 0
+-93 -67 9 0
+49 -68 35 0
+-64 17 -58 0
+-29 84 -91 0
+-75 -40 54 0
+-86 65 -42 0
+-31 95 -19 0
+82 65 13 0
+28 65 -17 0
+-99 -4 -92 0
+86 -82 -54 0
+-79 -93 -76 0
+92 -39 -41 0
+-37 6 -42 0
+-6 -23 -74 0
+86 -61 51 0
+-20 -65 -6 0
+72 -53 -2 0
+88 94 84 0
+-99 52 31 0
+-42 -35 -65 0
+5 -93 -17 0
+-72 -59 -31 0
+52 -58 81 0
+-43 -86 80 0
+78 -99 62 0
+95 27 -12 0
+76 73 20 0
+-100 88 -36 0
+73 94 52 0
+29 84 -72 0
+13 -45 -78 0
+92 -32 -87 0
+-40 -74 -82 0
+53 -33 91 0
+33 91 96 0
+71 22 58 0
+16 -29 48 0
+-96 -8 -95 0
+-74 35 87 0
+-76 -72 39 0
+84 -47 70 0
+58 10 36 0
+27 -8 -11 0
+-75 59 -28 0
+9 -98 38 0
+-95 -51 -60 0
+71 -50 -64 0
+9 82 -83 0
+12 78 26 0
+6 -48 45 0
+56 -90 -62 0
+70 25 -3 0
+-9 39 -92 0
+69 -19 84 0
+-13 -5 -75 0
+12 90 48 0
+97 -68 -4 0
+39 -36 1 0
+-88 -62 61 0
+-2 83 22 0
+62 -50 -11 0
+10 73 21 0
+-75 -40 53 0
+-17 57 -7 0
+95 28 -59 0
+38 -65 46 0
+1 -83 -94 0
+-39 71 36 0
+36 63 -61 0
+-20 33 16 0
+75 87 -84 0
+42 -35 40 0
+-31 -94 -7 0
+71 -21 -14 0
+20 -82 86 0
+55 -34 -21 0
+95 89 -34 0
+61 37 76 0
+98 41 -42 0
+-49 86 80 0
+%
+0
+

benchmarks/uf100/uf100-022.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -86 -92 -2 0
+34 -22 81 0
+65 -70 -12 0
+-92 51 32 0
+41 55 -60 0
+38 -12 58 0
+-2 100 70 0
+29 -91 41 0
+-6 -18 -39 0
+31 11 -22 0
+73 48 -44 0
+14 -62 96 0
+31 74 -66 0
+51 59 -12 0
+73 -26 -95 0
+-80 10 25 0
+7 -38 -78 0
+-28 -8 -34 0
+-66 4 33 0
+51 18 72 0
+-26 -5 -44 0
+67 3 -6 0
+5 32 91 0
+13 -91 -48 0
+-92 -17 10 0
+97 87 38 0
+7 4 37 0
+-95 -53 -74 0
+-29 4 -89 0
+-69 40 72 0
+12 99 -21 0
+83 -46 61 0
+61 53 -62 0
+32 67 57 0
+76 -12 46 0
+81 100 -47 0
+58 -32 -31 0
+-27 12 -41 0
+-42 -78 -45 0
+4 73 -99 0
+97 -100 88 0
+-28 -58 68 0
+-47 -2 -29 0
+65 32 51 0
+-98 -34 21 0
+-84 79 40 0
+-7 50 -97 0
+92 54 -73 0
+94 6 -45 0
+13 57 -14 0
+93 17 -63 0
+-88 -28 44 0
+-49 72 55 0
+95 -28 -94 0
+23 8 -100 0
+-23 -62 -45 0
+-56 -87 3 0
+-34 30 73 0
+37 14 -35 0
+16 -46 93 0
+-68 -100 -12 0
+42 -86 -89 0
+-74 97 -63 0
+99 -30 -4 0
+-45 -99 82 0
+27 -76 20 0
+24 2 -4 0
+-2 -16 -67 0
+34 76 -12 0
+26 49 63 0
+28 -34 -14 0
+-65 94 77 0
+39 -9 34 0
+-87 6 -88 0
+62 -68 40 0
+-64 3 -81 0
+52 -14 -45 0
+-47 21 60 0
+-92 12 -38 0
+71 -72 48 0
+57 60 -26 0
+88 -89 -33 0
+64 91 -43 0
+36 27 -12 0
+-86 8 -39 0
+-52 -63 -87 0
+78 87 50 0
+94 67 10 0
+12 -47 -52 0
+-14 47 -96 0
+-14 -94 -61 0
+61 -60 46 0
+29 -64 15 0
+63 11 73 0
+-3 -48 82 0
+-96 13 -17 0
+-15 -73 60 0
+8 12 -93 0
+49 13 3 0
+56 30 -84 0
+-60 -22 96 0
+76 -92 -81 0
+-64 -59 74 0
+48 30 -36 0
+-86 5 92 0
+51 -1 41 0
+54 -52 -10 0
+-97 49 -19 0
+94 52 -28 0
+-93 -87 83 0
+3 -6 -24 0
+-61 5 51 0
+29 34 -86 0
+-47 98 42 0
+52 20 -28 0
+-59 7 88 0
+82 -9 -44 0
+-70 -7 15 0
+-45 -100 16 0
+-28 -26 -63 0
+38 19 72 0
+65 83 29 0
+89 85 -14 0
+22 -84 68 0
+81 -97 67 0
+-9 89 46 0
+100 -79 29 0
+36 -75 -29 0
+-16 100 51 0
+-24 -18 -16 0
+-18 69 -56 0
+9 -48 49 0
+82 -12 -11 0
+78 -76 88 0
+-48 -83 43 0
+-31 -90 72 0
+57 -62 68 0
+-41 -81 55 0
+39 -68 91 0
+-52 43 32 0
+-98 37 94 0
+-89 -80 9 0
+-100 -26 -89 0
+-69 16 46 0
+9 -95 -84 0
+44 -87 26 0
+-84 46 29 0
+-100 -1 40 0
+66 -24 -33 0
+52 91 -69 0
+24 74 45 0
+99 -94 47 0
+-42 -86 49 0
+98 39 26 0
+-4 2 99 0
+-31 60 2 0
+77 8 -6 0
+71 -76 77 0
+22 -54 89 0
+-55 -87 -40 0
+-82 -90 35 0
+-95 -42 -52 0
+-91 -35 63 0
+17 75 -73 0
+-44 77 43 0
+-59 -12 -92 0
+-38 -89 -98 0
+76 78 -97 0
+57 -61 25 0
+84 -10 -23 0
+28 52 -64 0
+-76 -84 46 0
+36 -48 -11 0
+83 -41 -16 0
+-54 -90 77 0
+8 -34 -93 0
+-3 63 96 0
+13 -82 -40 0
+29 -8 -10 0
+-90 30 -81 0
+-96 17 -98 0
+38 46 -39 0
+63 -35 55 0
+98 8 28 0
+-99 34 79 0
+-95 59 40 0
+-20 -47 55 0
+17 -3 83 0
+16 91 32 0
+22 -67 69 0
+-43 60 -70 0
+-99 62 -17 0
+-82 32 -88 0
+-68 -66 -60 0
+34 10 61 0
+-15 53 86 0
+-55 -33 89 0
+57 68 -34 0
+-14 -99 50 0
+68 31 -49 0
+54 48 12 0
+-66 -86 -79 0
+-57 -13 -33 0
+75 71 -62 0
+63 13 89 0
+-70 94 -69 0
+27 -98 85 0
+71 -9 54 0
+66 -74 82 0
+-86 -61 -39 0
+-96 42 72 0
+63 -50 -2 0
+88 25 -62 0
+52 93 35 0
+-59 -6 -93 0
+75 7 47 0
+1 79 51 0
+-36 -58 65 0
+-28 -77 -61 0
+19 -2 -86 0
+90 -56 -57 0
+86 94 -65 0
+40 -78 54 0
+-30 81 14 0
+-83 -60 -12 0
+-19 -64 47 0
+62 85 -34 0
+-22 -60 53 0
+14 -94 87 0
+37 67 -87 0
+-40 54 25 0
+-27 91 10 0
+-37 38 -90 0
+-95 -27 47 0
+-10 90 97 0
+-57 -78 86 0
+7 -91 5 0
+46 -88 -57 0
+89 -72 96 0
+-66 -63 -39 0
+-94 -16 55 0
+-93 4 -10 0
+-16 66 48 0
+42 90 96 0
+87 -91 -11 0
+-2 47 -86 0
+-74 19 86 0
+-44 31 -71 0
+16 -46 -62 0
+-60 -69 78 0
+41 -95 78 0
+-8 24 22 0
+-99 51 -67 0
+42 -58 -16 0
+-90 -28 -67 0
+-99 -39 54 0
+80 -72 28 0
+38 64 86 0
+-75 -84 -90 0
+67 -81 54 0
+34 -18 -67 0
+-90 53 99 0
+28 82 18 0
+-6 -89 -29 0
+82 -33 61 0
+48 1 57 0
+-84 -100 92 0
+15 18 91 0
+77 -56 -94 0
+86 -32 -92 0
+86 14 -59 0
+-82 -12 -69 0
+-83 8 78 0
+-78 18 82 0
+30 -9 64 0
+79 -41 -45 0
+-7 65 -83 0
+36 -20 84 0
+39 69 -41 0
+53 -69 71 0
+-47 69 66 0
+-62 13 45 0
+24 -69 3 0
+-76 -29 67 0
+-49 37 1 0
+11 95 91 0
+63 13 52 0
+27 -26 69 0
+56 37 58 0
+-52 82 -63 0
+-78 -56 -83 0
+-7 20 -96 0
+59 -53 -23 0
+57 -38 -22 0
+40 -11 -36 0
+-91 40 -37 0
+-57 -15 13 0
+-51 -31 -91 0
+-58 16 -9 0
+-33 -69 79 0
+-49 62 -81 0
+-78 93 -2 0
+28 -96 -6 0
+-90 26 79 0
+66 37 77 0
+-86 53 9 0
+-55 15 -38 0
+31 32 78 0
+-100 39 -72 0
+-86 3 13 0
+9 -34 70 0
+-63 55 22 0
+-83 -41 58 0
+-7 -76 -46 0
+-54 39 85 0
+-84 10 -66 0
+-60 -90 19 0
+-7 73 71 0
+71 39 -23 0
+-99 71 15 0
+-16 -20 -25 0
+-46 32 42 0
+-94 -20 4 0
+11 -55 -76 0
+8 -70 -62 0
+-38 69 -18 0
+-15 -95 21 0
+-88 53 54 0
+28 -26 -92 0
+-95 -66 -33 0
+-54 -26 55 0
+-60 -2 -99 0
+-15 46 11 0
+-5 -65 53 0
+-59 61 -77 0
+77 71 -90 0
+35 -1 79 0
+92 -96 82 0
+-28 -69 83 0
+-91 23 10 0
+31 90 97 0
+-98 -55 38 0
+-13 -80 -16 0
+-13 -9 48 0
+-43 79 34 0
+-79 -75 -37 0
+-13 -92 -11 0
+-71 -81 -79 0
+64 -87 -69 0
+-23 -24 -37 0
+3 55 -57 0
+-95 43 6 0
+64 -91 84 0
+13 -51 24 0
+54 -6 3 0
+-84 44 -14 0
+37 45 51 0
+38 -32 -63 0
+-54 -88 100 0
+-38 63 -48 0
+-52 -93 97 0
+-22 -24 79 0
+86 9 60 0
+24 65 -22 0
+69 -87 -41 0
+-69 -5 -84 0
+-100 -92 -95 0
+-7 -50 -75 0
+1 21 -51 0
+100 13 85 0
+32 -98 44 0
+-87 63 -6 0
+47 48 18 0
+-8 14 -36 0
+56 -36 92 0
+79 8 -19 0
+36 -10 -44 0
+9 -37 34 0
+-42 66 -61 0
+56 79 32 0
+-69 99 16 0
+68 -56 48 0
+98 5 75 0
+78 73 98 0
+-34 -5 100 0
+-72 21 17 0
+-26 -76 -93 0
+-11 84 93 0
+18 92 96 0
+36 62 49 0
+-54 -98 22 0
+-7 -10 -4 0
+-87 -94 -75 0
+-3 96 80 0
+-43 -47 -70 0
+92 36 -94 0
+42 13 -88 0
+37 -98 64 0
+-100 -80 37 0
+-87 21 -95 0
+53 3 13 0
+24 58 31 0
+-82 40 -45 0
+50 -96 -23 0
+-16 94 66 0
+-25 8 -55 0
+95 -82 4 0
+88 -25 85 0
+19 -25 -96 0
+-12 69 -63 0
+-20 65 -74 0
+-48 29 -79 0
+-97 -22 -89 0
+-82 73 89 0
+47 25 10 0
+75 -21 14 0
+46 -42 77 0
+-88 -89 -34 0
+40 51 -60 0
+-70 -74 -97 0
+28 57 18 0
+-90 -51 53 0
+77 63 33 0
+-98 79 -53 0
+29 -75 54 0
+23 82 -92 0
+52 -12 48 0
+-49 -55 86 0
+84 62 2 0
+-17 -48 83 0
+%
+0
+

benchmarks/uf100/uf100-023.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -62 89 20 0
+-73 -20 1 0
+-40 -38 -15 0
+60 -29 16 0
+-100 -9 -16 0
+98 59 78 0
+47 -94 -23 0
+-75 -31 -13 0
+-78 -46 23 0
+8 52 27 0
+-13 -37 83 0
+95 100 -99 0
+92 22 19 0
+99 -88 51 0
+-41 88 -54 0
+-92 24 -30 0
+-79 8 83 0
+-66 17 -53 0
+89 21 50 0
+-41 83 18 0
+88 42 -53 0
+-100 -94 -75 0
+-13 36 16 0
+-28 8 -58 0
+7 -88 83 0
+55 -70 -74 0
+74 -87 -82 0
+-47 82 88 0
+-100 -74 -15 0
+-58 48 -40 0
+37 -99 45 0
+-17 73 -16 0
+-11 -24 -56 0
+73 -44 77 0
+88 53 85 0
+99 72 -13 0
+-78 -31 70 0
+60 -6 34 0
+-77 -52 48 0
+-90 -69 95 0
+-88 95 1 0
+-97 16 46 0
+78 -69 46 0
+-16 60 -75 0
+6 -2 25 0
+30 -63 -16 0
+-45 60 -70 0
+-30 3 47 0
+-98 -29 89 0
+-28 -98 -3 0
+-73 -28 42 0
+42 -2 -63 0
+90 -21 91 0
+-66 -93 34 0
+-55 92 24 0
+-35 17 49 0
+80 -47 -7 0
+31 -49 18 0
+-26 50 -4 0
+86 58 61 0
+-30 50 21 0
+-84 5 73 0
+88 -77 -80 0
+17 -23 15 0
+89 -68 -75 0
+-54 -6 -38 0
+-100 -68 67 0
+-4 45 -90 0
+-48 -67 -9 0
+-79 77 59 0
+-42 -79 40 0
+43 53 91 0
+23 29 93 0
+98 59 -9 0
+-98 -73 -57 0
+-93 76 -31 0
+15 82 -45 0
+-47 35 86 0
+-56 4 36 0
+61 -22 4 0
+8 65 77 0
+92 -53 -87 0
+30 -23 -27 0
+-42 -38 77 0
+10 -61 -22 0
+-15 84 -59 0
+-97 -14 48 0
+76 -80 47 0
+-75 35 -66 0
+-52 22 26 0
+67 49 86 0
+21 -36 -69 0
+-93 50 -40 0
+70 -78 -33 0
+73 12 23 0
+12 95 10 0
+57 -70 37 0
+-17 -80 -57 0
+-23 -45 -78 0
+-54 -38 80 0
+100 94 -20 0
+-26 86 23 0
+70 -26 -90 0
+27 -5 -9 0
+-72 -13 -11 0
+-76 -89 86 0
+-50 -24 100 0
+-82 -57 36 0
+36 9 -21 0
+18 84 -94 0
+21 10 -71 0
+21 54 -92 0
+-30 -7 35 0
+81 -14 26 0
+-83 76 -22 0
+58 25 -65 0
+-97 -51 22 0
+67 -1 54 0
+19 47 -45 0
+31 -80 -4 0
+-65 8 -23 0
+-90 -13 78 0
+62 14 -46 0
+73 -92 -8 0
+-52 -76 -94 0
+22 67 -75 0
+-4 -95 79 0
+-26 16 -53 0
+35 15 -90 0
+33 86 61 0
+-78 -66 -87 0
+-20 -84 86 0
+-37 -92 -56 0
+-87 98 13 0
+62 -73 -34 0
+43 76 42 0
+22 48 -6 0
+48 -83 62 0
+2 58 -22 0
+-61 95 34 0
+71 -60 8 0
+34 10 84 0
+-10 -65 -12 0
+96 -69 -40 0
+79 43 -68 0
+44 7 -51 0
+-52 -42 -71 0
+-1 -23 -12 0
+-67 59 33 0
+-63 83 -73 0
+-19 25 1 0
+56 -95 74 0
+26 -86 55 0
+-31 24 3 0
+69 70 25 0
+-99 62 67 0
+31 87 -3 0
+-37 -38 73 0
+36 -5 -53 0
+80 -37 -29 0
+46 -76 -34 0
+21 5 -51 0
+-12 47 -1 0
+-14 74 80 0
+-25 -91 -84 0
+-26 -40 37 0
+-24 -72 15 0
+38 -6 71 0
+-13 -3 -82 0
+40 94 -83 0
+85 72 -16 0
+31 55 38 0
+71 67 38 0
+50 17 -30 0
+24 -49 92 0
+-84 -56 10 0
+65 -7 96 0
+-35 -23 -92 0
+100 13 30 0
+-69 70 -20 0
+-58 -97 68 0
+22 80 4 0
+59 55 21 0
+-31 -32 29 0
+87 44 -19 0
+63 77 57 0
+38 -54 10 0
+-71 -37 97 0
+8 -98 47 0
+86 43 -65 0
+65 12 -60 0
+-51 79 47 0
+-3 -92 61 0
+-15 92 -25 0
+82 14 -25 0
+-30 82 84 0
+82 53 4 0
+52 16 -17 0
+-40 -29 91 0
+-46 71 32 0
+43 48 31 0
+-52 18 -87 0
+-80 97 15 0
+-96 48 58 0
+5 58 18 0
+86 -70 82 0
+50 47 -37 0
+35 -82 -79 0
+79 -73 36 0
+84 65 5 0
+36 87 -2 0
+-36 -52 45 0
+54 -22 27 0
+-19 -50 78 0
+2 -69 1 0
+39 5 -88 0
+-38 57 42 0
+-28 82 50 0
+59 -33 -69 0
+-73 -88 -23 0
+-75 -33 97 0
+-53 -10 75 0
+-21 -20 -85 0
+-90 -33 31 0
+13 41 -5 0
+27 -89 31 0
+42 -3 14 0
+19 -17 -24 0
+3 77 -30 0
+-51 -47 -39 0
+-54 9 -41 0
+88 -73 -94 0
+6 8 -7 0
+-27 13 70 0
+-55 -96 52 0
+-45 -5 -42 0
+-76 -77 46 0
+-60 83 -42 0
+61 -39 66 0
+-35 50 -7 0
+-19 -88 -63 0
+-33 48 28 0
+-14 78 -87 0
+-8 5 38 0
+-84 -69 83 0
+49 74 -13 0
+-62 66 32 0
+-93 58 -27 0
+78 -21 74 0
+49 -77 78 0
+-57 15 5 0
+-54 -87 4 0
+-34 68 7 0
+30 25 40 0
+-12 88 -9 0
+21 75 91 0
+-64 -97 -2 0
+-16 -43 22 0
+6 -14 81 0
+-22 -41 10 0
+-34 87 56 0
+-75 -3 86 0
+73 21 -23 0
+-55 -23 -45 0
+-85 -16 -79 0
+-25 -9 -62 0
+-99 62 66 0
+85 91 -66 0
+71 -93 -98 0
+-73 41 -90 0
+-27 60 -74 0
+52 38 21 0
+62 5 -30 0
+-2 -83 62 0
+-73 71 -59 0
+-27 49 -53 0
+-59 88 28 0
+19 -66 -54 0
+-17 -94 48 0
+-95 65 17 0
+-46 -53 87 0
+89 -12 11 0
+65 -10 -82 0
+84 -75 -67 0
+-77 -47 -24 0
+31 46 -4 0
+-41 32 -67 0
+66 14 68 0
+-21 15 -1 0
+-46 22 -99 0
+20 -45 -44 0
+79 -3 -19 0
+-3 -19 80 0
+-97 -87 -26 0
+49 -19 93 0
+-46 8 52 0
+-76 -10 -16 0
+62 58 -88 0
+-53 25 40 0
+49 70 31 0
+-48 -62 -27 0
+14 27 68 0
+-98 83 80 0
+-38 -76 -32 0
+90 2 22 0
+-40 -91 100 0
+-25 4 -77 0
+-14 31 81 0
+1 54 81 0
+85 20 -36 0
+44 79 -69 0
+-93 -70 -62 0
+68 -74 25 0
+53 -67 93 0
+67 -84 -43 0
+81 -34 61 0
+-9 70 75 0
+-65 -7 -9 0
+29 7 43 0
+-45 6 25 0
+69 89 48 0
+35 47 93 0
+-45 -81 -38 0
+29 99 71 0
+-64 -44 -37 0
+19 -41 99 0
+-83 25 16 0
+-37 -22 -85 0
+-19 90 75 0
+2 73 55 0
+-90 -43 47 0
+12 -73 -49 0
+-74 -1 11 0
+35 -10 -91 0
+-21 1 -73 0
+82 29 39 0
+53 -28 -2 0
+91 -29 -68 0
+-3 22 -68 0
+-93 51 66 0
+62 7 33 0
+30 -88 78 0
+-97 -79 61 0
+-22 -83 -70 0
+55 69 -49 0
+-26 -96 81 0
+-8 -25 -3 0
+-18 53 -71 0
+-27 39 33 0
+95 83 76 0
+-18 -29 5 0
+14 -94 -26 0
+-8 -97 -34 0
+-28 -1 89 0
+68 90 99 0
+-53 50 30 0
+-58 -62 -10 0
+-64 -86 -85 0
+48 -92 -59 0
+-53 -19 -45 0
+-53 -15 -28 0
+99 29 37 0
+-96 -76 -1 0
+-38 -21 55 0
+-52 -9 -25 0
+74 -13 -2 0
+76 94 1 0
+27 -98 -88 0
+91 15 81 0
+-52 -64 46 0
+-63 33 19 0
+37 9 8 0
+50 -49 -7 0
+98 66 79 0
+63 73 -61 0
+-2 -65 -85 0
+2 7 -39 0
+-76 22 26 0
+18 3 2 0
+91 84 77 0
+-30 -80 28 0
+96 84 33 0
+23 88 -70 0
+-71 -56 -78 0
+-89 74 -73 0
+8 32 69 0
+-61 -22 29 0
+41 79 -27 0
+-86 -98 21 0
+51 59 -78 0
+-12 -31 11 0
+-26 27 58 0
+-94 61 -21 0
+57 -18 7 0
+-70 -47 -88 0
+-5 -100 77 0
+-11 93 -71 0
+-59 73 -78 0
+-65 1 16 0
+-81 -88 50 0
+34 -86 -20 0
+-22 81 -78 0
+-77 -4 63 0
+-52 47 7 0
+71 -98 -13 0
+-40 99 -80 0
+44 30 -32 0
+-11 -98 -80 0
+-80 -3 8 0
+11 -42 -22 0
+-18 -2 -85 0
+-48 5 23 0
+56 36 -42 0
+97 -89 -96 0
+29 85 -7 0
+37 27 70 0
+15 -72 -35 0
+81 6 96 0
+14 37 -93 0
+-74 69 -52 0
+48 -55 87 0
+-48 91 83 0
+42 7 -39 0
+41 42 -16 0
+99 24 25 0
+-10 -51 -98 0
+-8 -15 -64 0
+-23 -38 98 0
+-41 14 67 0
+12 -46 40 0
+%
+0
+

benchmarks/uf100/uf100-024.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -36 26 -40 0
+-80 -8 52 0
+-87 -98 44 0
+4 29 -88 0
+-88 -61 -50 0
+-17 4 -92 0
+71 47 33 0
+-35 -90 -11 0
+-94 -80 -13 0
+64 -73 -13 0
+-67 -72 93 0
+11 -33 -80 0
+-56 -89 73 0
+-51 60 29 0
+15 5 87 0
+16 85 -13 0
+41 -54 -7 0
+-4 52 50 0
+-26 69 76 0
+-68 -45 20 0
+97 -88 -23 0
+-84 -37 19 0
+-51 60 -67 0
+-16 61 -54 0
+6 83 -29 0
+-65 34 -87 0
+-53 26 -19 0
+-87 -66 -36 0
+-38 -81 32 0
+75 77 -30 0
+-3 -67 1 0
+-71 -7 -68 0
+66 64 49 0
+72 55 -94 0
+-51 20 41 0
+47 25 -10 0
+-90 -85 70 0
+-41 40 11 0
+-2 12 82 0
+60 66 -48 0
+-44 92 95 0
+-17 -29 -93 0
+34 27 6 0
+-71 18 -58 0
+80 -73 -39 0
+-97 -18 76 0
+-100 -88 43 0
+-58 -7 -56 0
+-10 -21 89 0
+-40 -53 74 0
+62 -77 65 0
+-52 -67 -23 0
+-23 -16 -3 0
+50 -89 74 0
+39 -95 -100 0
+60 -34 55 0
+-59 23 89 0
+-77 40 63 0
+33 67 -31 0
+-53 -43 -81 0
+-30 14 -87 0
+-7 -96 -80 0
+43 54 -35 0
+-48 -66 19 0
+64 -23 65 0
+-96 -5 -33 0
+40 -96 66 0
+14 34 96 0
+1 -87 -95 0
+42 -29 -88 0
+-26 68 -67 0
+-29 90 51 0
+37 -22 76 0
+-61 -71 -2 0
+21 31 -95 0
+71 62 -34 0
+92 48 -73 0
+-84 78 -3 0
+-74 71 43 0
+42 -46 -63 0
+2 -24 -61 0
+-19 -52 -28 0
+-72 77 -47 0
+-46 -10 -27 0
+-20 -26 -98 0
+81 -63 76 0
+22 16 -88 0
+-19 -78 -57 0
+22 -97 -3 0
+-100 -5 -14 0
+49 68 37 0
+60 -31 -50 0
+-28 -98 -34 0
+-77 85 -81 0
+-67 31 -70 0
+-54 77 24 0
+-25 61 63 0
+-30 35 41 0
+48 -96 88 0
+-94 41 -50 0
+20 -74 -55 0
+76 -88 16 0
+81 -92 -59 0
+24 3 73 0
+-29 -26 89 0
+57 -8 82 0
+-66 -26 -34 0
+-4 -44 87 0
+39 -87 -45 0
+60 26 -1 0
+58 -61 97 0
+85 36 73 0
+-13 -21 79 0
+-41 22 29 0
+-61 93 -52 0
+51 99 -16 0
+-95 22 23 0
+-2 -53 60 0
+-23 -93 -63 0
+76 -38 89 0
+-83 -50 -28 0
+85 -91 88 0
+46 59 80 0
+47 62 24 0
+-6 88 38 0
+-24 -97 -87 0
+17 -79 74 0
+32 31 90 0
+-43 -83 90 0
+66 -98 89 0
+40 -15 -100 0
+-9 -83 -72 0
+13 19 87 0
+31 72 -5 0
+23 3 -94 0
+15 -46 -100 0
+-7 -80 49 0
+35 -75 -54 0
+44 8 -55 0
+45 -51 -94 0
+23 -76 45 0
+-88 -96 -36 0
+9 33 26 0
+74 17 -63 0
+67 -95 48 0
+28 31 93 0
+-38 -16 -5 0
+-45 98 95 0
+79 1 -20 0
+96 -89 58 0
+-91 -21 -45 0
+-91 -8 -80 0
+-58 -25 -67 0
+-55 73 95 0
+-38 -10 -5 0
+-8 43 -18 0
+17 -95 -96 0
+69 -100 32 0
+75 -68 20 0
+-86 91 41 0
+89 86 55 0
+-57 27 37 0
+18 8 12 0
+-75 -2 -74 0
+-31 37 -46 0
+-8 6 -74 0
+5 -3 -12 0
+-53 74 -58 0
+70 -97 87 0
+98 -22 -74 0
+32 -100 96 0
+91 68 -45 0
+53 62 -73 0
+-94 95 -93 0
+-17 -36 -5 0
+-80 11 -97 0
+-17 7 26 0
+61 -62 96 0
+29 65 -15 0
+4 -62 -89 0
+5 31 -79 0
+-59 -23 2 0
+19 -43 72 0
+35 4 -7 0
+-3 27 -12 0
+58 39 -94 0
+31 -99 22 0
+44 2 47 0
+-58 51 26 0
+16 -3 76 0
+-90 -51 -49 0
+84 17 -87 0
+-10 93 -71 0
+78 65 38 0
+52 -44 40 0
+-37 61 -84 0
+-74 28 87 0
+-29 -43 28 0
+87 -77 100 0
+62 -31 72 0
+34 -95 3 0
+-87 55 76 0
+8 43 51 0
+-70 -29 25 0
+-97 14 -35 0
+11 -49 -87 0
+62 53 22 0
+-45 -34 78 0
+-43 39 49 0
+71 -5 15 0
+-97 -84 79 0
+-51 -59 97 0
+-7 39 55 0
+-4 76 -62 0
+-53 13 73 0
+-96 -15 29 0
+18 48 -84 0
+-37 26 16 0
+-15 -13 -24 0
+45 -17 -79 0
+-63 -79 10 0
+-16 -71 -56 0
+-78 21 100 0
+-42 26 -22 0
+30 -46 -3 0
+4 25 64 0
+-21 31 -87 0
+51 8 92 0
+-59 42 30 0
+-67 36 77 0
+55 -47 -64 0
+34 -81 9 0
+-91 -7 47 0
+87 -15 -88 0
+47 61 -29 0
+62 84 -18 0
+3 -36 59 0
+-51 47 -21 0
+43 15 -92 0
+-24 78 -48 0
+24 -63 -61 0
+-20 90 -98 0
+92 52 99 0
+-90 91 -43 0
+68 -46 -50 0
+-93 -22 -13 0
+15 -83 -90 0
+-65 -53 -42 0
+92 55 81 0
+-7 4 47 0
+7 -12 66 0
+18 -79 -12 0
+98 55 -24 0
+30 10 -43 0
+-12 49 83 0
+-3 11 -13 0
+97 -48 55 0
+79 -53 100 0
+91 22 -28 0
+-12 43 20 0
+96 -3 -36 0
+85 -67 -12 0
+-85 -54 18 0
+2 -46 -31 0
+100 -91 5 0
+-44 -81 -8 0
+-43 74 44 0
+20 -98 72 0
+-47 83 -73 0
+40 13 42 0
+-49 -75 -7 0
+-34 97 -69 0
+-96 70 -80 0
+-94 53 -44 0
+-17 70 -68 0
+-84 62 74 0
+-85 51 -24 0
+36 -23 43 0
+76 83 1 0
+74 65 100 0
+40 -7 -74 0
+-41 81 -42 0
+-37 -70 -92 0
+28 -60 64 0
+-59 -52 -77 0
+70 33 6 0
+-35 -87 81 0
+45 -88 -84 0
+-16 94 28 0
+-91 80 57 0
+-66 7 81 0
+-72 -84 -14 0
+-67 4 52 0
+20 55 12 0
+52 -24 -14 0
+57 58 -38 0
+-99 -91 78 0
+-18 -54 94 0
+88 -46 -24 0
+-86 -3 71 0
+-51 -49 -80 0
+52 75 78 0
+-72 43 -81 0
+-76 99 -18 0
+56 19 -99 0
+48 63 41 0
+-14 2 90 0
+-18 -3 -58 0
+-71 43 -67 0
+-84 97 18 0
+75 -71 92 0
+31 11 -43 0
+-35 20 78 0
+60 -88 87 0
+26 59 25 0
+-73 16 19 0
+5 -60 28 0
+-22 15 -49 0
+44 -67 53 0
+-58 -19 87 0
+31 -34 -44 0
+-67 2 34 0
+-24 -71 29 0
+-38 13 -1 0
+18 -1 -12 0
+-33 -15 6 0
+-50 32 -3 0
+98 49 -23 0
+-61 58 5 0
+-55 -65 49 0
+39 -2 47 0
+46 27 -43 0
+100 8 17 0
+15 -94 95 0
+67 -10 -8 0
+-48 -13 -78 0
+6 2 -82 0
+16 -50 100 0
+-69 87 -27 0
+6 -73 -91 0
+-89 36 78 0
+-20 -36 -1 0
+99 36 92 0
+-100 -94 52 0
+-69 -71 -23 0
+70 94 -66 0
+-56 60 35 0
+49 -41 -56 0
+66 71 -56 0
+-49 -3 -25 0
+59 -54 77 0
+-24 45 60 0
+79 -50 43 0
+-97 -56 85 0
+-6 21 31 0
+-51 57 -90 0
+-99 -90 49 0
+-36 39 92 0
+67 -84 91 0
+-25 -76 29 0
+-68 -18 89 0
+-46 91 23 0
+43 -84 -51 0
+41 21 63 0
+-39 64 -92 0
+-99 85 -77 0
+21 -86 60 0
+56 -23 91 0
+86 98 65 0
+-64 68 -67 0
+-15 34 69 0
+60 -41 -96 0
+27 40 -97 0
+62 -31 -52 0
+-29 -42 -48 0
+80 13 16 0
+-58 -63 -77 0
+28 8 1 0
+79 87 -78 0
+-11 42 -98 0
+-41 -16 7 0
+-92 -21 -73 0
+30 2 -62 0
+-78 6 -74 0
+11 47 -27 0
+3 46 79 0
+-19 -94 63 0
+45 92 -39 0
+-93 -100 71 0
+-52 -65 -53 0
+42 -74 4 0
+62 -2 -99 0
+-61 37 -53 0
+65 36 75 0
+-41 54 -94 0
+-52 -73 39 0
+-61 -54 23 0
+-20 38 -52 0
+48 2 30 0
+52 -77 85 0
+11 -23 -89 0
+-71 -38 34 0
+-9 -16 -49 0
+-53 -36 87 0
+-14 -10 -100 0
+14 66 -93 0
+82 -86 8 0
+-26 87 20 0
+60 -100 44 0
+-70 -95 -11 0
+40 5 30 0
+2 88 30 0
+13 28 96 0
+-40 61 41 0
+-84 77 17 0
+-59 85 14 0
+-33 17 8 0
+-71 -38 39 0
+8 -10 1 0
+-71 -76 84 0
+96 28 13 0
+30 49 -45 0
+-47 81 -9 0
+25 54 -88 0
+33 -72 56 0
+-44 -54 -52 0
+84 92 16 0
+100 -76 -6 0
+-86 85 5 0
+53 -42 77 0
+%
+0
+

benchmarks/uf100/uf100-025.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -43 78 24 0
+-100 -97 -39 0
+33 35 -83 0
+55 -24 48 0
+38 -21 88 0
+-32 35 84 0
+88 23 11 0
+-90 -47 37 0
+63 -49 -66 0
+34 8 -72 0
+27 -41 98 0
+24 83 -43 0
+-36 -99 -4 0
+-14 33 47 0
+31 -76 24 0
+-66 24 -73 0
+85 -58 -50 0
+-85 -27 57 0
+87 -12 -58 0
+-50 21 -76 0
+-7 -90 96 0
+-46 -38 -87 0
+54 50 4 0
+-36 -25 13 0
+-94 -8 24 0
+42 -87 -36 0
+-67 12 -26 0
+30 -61 -40 0
+34 -7 -1 0
+-48 -94 66 0
+-18 4 -34 0
+-42 -7 11 0
+-57 89 79 0
+-74 -54 -55 0
+-33 47 48 0
+-44 -36 -14 0
+-76 -30 61 0
+-3 54 8 0
+-30 -24 -83 0
+-40 30 28 0
+97 72 -82 0
+64 24 -100 0
+-44 -12 -50 0
+-80 23 24 0
+-43 47 -51 0
+-17 31 -49 0
+-68 5 21 0
+64 73 42 0
+14 -4 -57 0
+57 -9 11 0
+85 -96 75 0
+-31 62 20 0
+80 92 21 0
+55 -19 49 0
+-76 12 23 0
+30 4 -98 0
+20 67 -53 0
+87 98 -73 0
+-52 -74 -96 0
+14 61 -63 0
+38 -77 84 0
+-28 1 88 0
+61 26 3 0
+11 -86 -95 0
+58 99 -40 0
+-1 73 63 0
+-4 36 -44 0
+-96 76 9 0
+20 21 27 0
+94 85 11 0
+-20 -5 19 0
+-26 -93 -63 0
+-51 -80 -54 0
+100 98 83 0
+39 5 -94 0
+95 59 -3 0
+40 66 -84 0
+79 85 46 0
+-95 -43 21 0
+-87 -8 -37 0
+-79 -51 -33 0
+-72 3 -39 0
+-22 83 -57 0
+90 -10 42 0
+-42 -73 -19 0
+-52 31 -25 0
+-57 84 -90 0
+67 60 -76 0
+-22 16 -100 0
+-74 67 58 0
+-66 -95 -41 0
+79 -36 -68 0
+97 -33 37 0
+40 -74 27 0
+-77 65 -70 0
+35 -4 -21 0
+-3 18 -8 0
+-32 -44 -14 0
+96 2 45 0
+35 81 8 0
+84 83 19 0
+-77 -10 -18 0
+-66 -13 -8 0
+-50 -77 -72 0
+37 33 56 0
+-59 21 -88 0
+-78 -2 -5 0
+-60 52 -97 0
+37 -80 -54 0
+84 -10 85 0
+44 -11 -43 0
+25 -66 -70 0
+14 -20 7 0
+88 24 -16 0
+-93 -15 -98 0
+99 98 62 0
+-10 -53 -15 0
+35 96 -94 0
+-78 94 4 0
+-83 27 50 0
+-30 3 1 0
+-40 54 -81 0
+29 67 -59 0
+3 -86 -57 0
+-42 62 17 0
+-94 -71 -22 0
+23 -2 -19 0
+66 85 17 0
+88 10 -11 0
+-36 58 -52 0
+-72 43 63 0
+-58 -59 -27 0
+27 -28 -66 0
+-69 -40 -82 0
+69 -20 55 0
+-12 42 -45 0
+99 -93 40 0
+-7 95 -29 0
+46 -7 20 0
+-24 -54 -79 0
+-84 -36 25 0
+-58 63 45 0
+-90 -26 -74 0
+8 -70 -75 0
+59 -8 -2 0
+17 65 32 0
+-48 -80 -65 0
+37 52 -21 0
+66 -22 54 0
+18 -15 -16 0
+16 69 -60 0
+50 58 63 0
+9 -86 -77 0
+13 -62 -66 0
+19 84 -89 0
+54 4 44 0
+-50 71 88 0
+72 5 -89 0
+-13 -63 -91 0
+52 82 -44 0
+-24 -74 -82 0
+-93 -24 -65 0
+-93 -60 -89 0
+60 -73 52 0
+-10 3 97 0
+31 67 -90 0
+-7 27 -88 0
+55 -99 -35 0
+-33 -39 68 0
+-100 -98 -22 0
+13 -81 -31 0
+-67 -100 -90 0
+-30 -25 -96 0
+58 -1 13 0
+-44 -84 99 0
+-30 92 60 0
+61 -22 14 0
+44 -17 -5 0
+-66 -85 -92 0
+-34 53 92 0
+-28 24 -70 0
+11 -79 14 0
+35 38 22 0
+19 10 -91 0
+-4 34 12 0
+35 61 -68 0
+97 -59 -64 0
+16 -18 95 0
+43 -76 49 0
+93 -90 83 0
+48 19 76 0
+-100 20 -82 0
+21 -46 83 0
+53 -25 15 0
+-50 -90 32 0
+1 92 22 0
+-16 -35 -27 0
+99 -10 74 0
+-66 -16 28 0
+16 -23 -18 0
+94 -77 -83 0
+-60 -8 -33 0
+-77 -85 -8 0
+-64 62 -15 0
+20 -44 -10 0
+28 -85 -62 0
+8 59 62 0
+37 -21 31 0
+-43 35 90 0
+-45 -46 -62 0
+40 10 37 0
+56 -27 94 0
+-64 3 59 0
+23 90 -65 0
+-30 92 37 0
+-43 -86 28 0
+14 -44 74 0
+46 25 -43 0
+-35 -42 78 0
+91 -83 -16 0
+-46 -16 48 0
+-21 8 80 0
+-34 -61 -65 0
+65 -100 -26 0
+-67 90 62 0
+-45 62 50 0
+28 56 -51 0
+48 -84 -27 0
+96 -24 -92 0
+-1 33 -80 0
+96 -59 -58 0
+88 -79 -49 0
+4 33 82 0
+22 -41 64 0
+-3 63 -62 0
+78 -21 -35 0
+-28 -53 -65 0
+-75 94 83 0
+-97 -45 68 0
+-90 61 93 0
+-28 -20 38 0
+48 -82 55 0
+63 -32 -38 0
+73 85 -5 0
+-71 -35 -23 0
+81 -14 84 0
+-20 24 -19 0
+-18 99 -8 0
+15 -16 79 0
+82 -27 59 0
+-69 -71 58 0
+91 -8 -57 0
+-86 -99 91 0
+-87 -67 50 0
+89 -68 32 0
+91 -40 -92 0
+82 -83 -87 0
+31 -77 65 0
+56 -85 5 0
+-9 38 -42 0
+-47 49 55 0
+77 24 -21 0
+-47 -92 -53 0
+23 17 54 0
+-38 46 -62 0
+-43 47 -20 0
+-32 19 -84 0
+-40 81 -91 0
+62 -71 68 0
+-39 36 49 0
+-71 -59 97 0
+50 88 -57 0
+31 -80 71 0
+73 33 -89 0
+-44 -86 24 0
+42 57 -97 0
+76 95 -41 0
+-22 -59 61 0
+-10 -52 64 0
+86 35 -98 0
+47 69 -39 0
+97 82 79 0
+-19 35 65 0
+-11 36 -96 0
+-86 19 22 0
+66 74 17 0
+-89 -15 5 0
+75 71 -53 0
+-83 60 15 0
+-65 20 -67 0
+-34 -69 -68 0
+-74 62 -100 0
+97 4 -22 0
+29 25 -31 0
+-91 -67 -85 0
+51 86 56 0
+4 -9 91 0
+-55 83 -24 0
+-47 61 -91 0
+41 -94 60 0
+-13 2 97 0
+-96 24 41 0
+7 -82 11 0
+-97 -5 3 0
+81 22 99 0
+52 59 -51 0
+81 22 94 0
+-49 14 -3 0
+2 41 65 0
+10 8 67 0
+57 98 -71 0
+-78 26 19 0
+-92 -96 -41 0
+55 -56 -25 0
+64 -69 59 0
+42 34 4 0
+10 -18 75 0
+-55 -81 -18 0
+79 30 -28 0
+55 12 56 0
+18 -83 65 0
+71 5 23 0
+-67 -87 -92 0
+-56 -60 96 0
+69 17 -55 0
+56 -48 -79 0
+26 -39 79 0
+-60 50 -98 0
+18 -89 39 0
+56 -40 17 0
+-6 19 -93 0
+58 65 -100 0
+47 73 -33 0
+-23 -42 54 0
+-61 10 64 0
+24 27 -45 0
+-78 68 -48 0
+-60 -50 -33 0
+58 -16 -98 0
+-35 38 -62 0
+-25 -39 9 0
+-53 34 -86 0
+-60 -71 38 0
+49 20 47 0
+-99 -65 -60 0
+-43 -88 -14 0
+-69 10 3 0
+-43 -69 84 0
+-12 -10 -65 0
+81 56 60 0
+15 59 -11 0
+-98 78 -77 0
+-13 -74 54 0
+42 65 -24 0
+-2 3 -36 0
+-84 -58 9 0
+62 -84 95 0
+-22 -96 -99 0
+90 34 17 0
+93 42 -43 0
+-80 -86 43 0
+6 -41 -13 0
+26 -100 -92 0
+-77 -65 -17 0
+-34 -70 99 0
+61 -77 -87 0
+33 -71 -8 0
+41 96 -85 0
+15 -97 24 0
+-89 -24 -70 0
+-88 -60 45 0
+41 96 79 0
+33 81 -45 0
+78 -27 -62 0
+-2 47 -77 0
+-40 -22 -35 0
+-92 -37 94 0
+-20 17 15 0
+-30 12 54 0
+44 -15 -58 0
+96 26 13 0
+29 -1 44 0
+-56 -91 -46 0
+96 -85 92 0
+61 19 18 0
+-35 31 22 0
+94 39 73 0
+70 -100 46 0
+-35 39 17 0
+-45 -33 40 0
+-72 -7 75 0
+-21 -64 -52 0
+95 -48 61 0
+-66 22 -53 0
+4 50 -99 0
+-89 -84 77 0
+77 -97 -12 0
+89 85 38 0
+63 -90 -47 0
+-82 76 2 0
+51 -7 -97 0
+-75 -47 -68 0
+75 63 -42 0
+-37 -74 56 0
+35 -72 4 0
+50 3 -29 0
+-18 -5 45 0
+-44 -65 -82 0
+52 -13 -67 0
+36 -30 -28 0
+-61 -16 83 0
+89 -80 17 0
+52 -9 71 0
+-25 -46 -61 0
+-47 88 -86 0
+53 -87 67 0
+-47 -65 -8 0
+70 -50 -83 0
+88 -8 -22 0
+-4 45 -62 0
+41 71 -75 0
+36 53 16 0
+-18 86 63 0
+-76 -15 52 0
+72 -67 95 0
+-21 96 -84 0
+-48 -39 -43 0
+77 -100 -45 0
+85 -75 86 0
+-86 -44 -14 0
+%
+0
+

benchmarks/uf100/uf100-026.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -20 70 15 0
+84 -92 -36 0
+-11 -73 -58 0
+-71 20 27 0
+-24 -37 -43 0
+5 16 -42 0
+-28 88 47 0
+-35 -29 -77 0
+-63 61 90 0
+-16 68 45 0
+-31 -45 -58 0
+-27 -92 -48 0
+-77 -89 -94 0
+24 43 -46 0
+-21 47 -56 0
+-7 35 41 0
+-24 33 96 0
+38 83 39 0
+-16 -59 -62 0
+50 -92 40 0
+2 63 -78 0
+47 50 17 0
+92 -58 5 0
+49 -4 -100 0
+3 14 62 0
+-86 -21 81 0
+-47 9 -55 0
+-86 -41 33 0
+31 19 -25 0
+-100 -32 3 0
+-79 59 41 0
+65 68 -12 0
+95 17 -3 0
+-48 -37 92 0
+-62 65 53 0
+84 -5 85 0
+28 74 40 0
+-42 22 -3 0
+-16 64 -68 0
+50 93 -40 0
+97 -23 -50 0
+-49 -14 30 0
+-89 -2 -57 0
+67 -86 -47 0
+-21 23 -68 0
+-26 -33 -9 0
+-32 -3 -8 0
+-97 -79 70 0
+-36 -24 -82 0
+90 -21 25 0
+-76 89 19 0
+83 45 -20 0
+-40 -14 -57 0
+28 -18 20 0
+-66 76 -37 0
+-1 82 20 0
+-34 68 52 0
+17 -16 -96 0
+36 16 10 0
+11 77 -63 0
+1 -2 -36 0
+52 -85 27 0
+41 -78 45 0
+27 -22 -58 0
+61 -77 35 0
+78 -77 -37 0
+-73 -48 74 0
+-29 91 -14 0
+-15 -53 -21 0
+-31 -49 63 0
+1 -50 17 0
+-26 36 61 0
+35 64 2 0
+-47 51 -82 0
+54 53 -19 0
+-56 -18 40 0
+85 -81 -39 0
+-56 -14 -38 0
+-87 -7 25 0
+-37 29 100 0
+-45 -1 -35 0
+87 58 70 0
+99 59 62 0
+9 -3 30 0
+-81 -7 -32 0
+98 -6 77 0
+-23 76 8 0
+41 99 -69 0
+-25 -43 -88 0
+57 64 -88 0
+-35 32 -41 0
+-90 -97 98 0
+22 97 -76 0
+48 73 49 0
+58 5 -70 0
+-10 76 27 0
+41 33 45 0
+45 -36 -38 0
+82 7 -41 0
+36 66 94 0
+1 -21 -11 0
+74 11 87 0
+-60 93 -36 0
+65 95 2 0
+-94 -61 -75 0
+22 -67 -6 0
+-86 67 -73 0
+45 27 9 0
+6 -34 4 0
+-4 -18 -87 0
+11 50 -77 0
+-28 -10 -39 0
+-73 -38 99 0
+-84 -85 72 0
+-1 -98 47 0
+59 98 80 0
+88 -68 31 0
+-98 41 63 0
+34 -5 26 0
+-34 -92 18 0
+-11 -38 3 0
+12 -60 -11 0
+68 -83 19 0
+-71 12 43 0
+17 50 27 0
+39 41 42 0
+-84 -41 -75 0
+-72 -51 42 0
+-29 51 33 0
+7 -63 99 0
+-37 -35 -69 0
+-93 -60 40 0
+-27 25 -73 0
+89 44 3 0
+-70 -22 12 0
+-98 -91 43 0
+65 63 78 0
+-27 56 -55 0
+-52 13 14 0
+3 -4 51 0
+-22 70 -96 0
+-83 100 -28 0
+90 31 13 0
+14 81 -50 0
+57 -37 -86 0
+12 73 -27 0
+-73 -20 -62 0
+-57 68 96 0
+-7 -26 6 0
+39 9 77 0
+82 28 1 0
+71 8 58 0
+-99 65 3 0
+-20 -40 -26 0
+-34 1 -42 0
+39 -45 71 0
+-19 -88 66 0
+50 -59 4 0
+-64 32 57 0
+-54 60 -49 0
+65 56 -10 0
+44 -22 -77 0
+9 -22 30 0
+-30 29 -54 0
+-34 -71 -40 0
+-48 -31 12 0
+48 10 36 0
+95 27 -29 0
+-47 -68 22 0
+79 -88 -10 0
+-74 -18 -6 0
+100 23 -81 0
+-42 -41 -25 0
+-64 12 -32 0
+25 90 72 0
+9 -82 60 0
+-86 -66 57 0
+-65 42 44 0
+-53 -76 21 0
+69 87 21 0
+83 29 -10 0
+76 -30 42 0
+-36 -61 -84 0
+87 -3 72 0
+-38 -56 20 0
+-87 78 68 0
+73 96 41 0
+56 63 97 0
+35 28 50 0
+-39 73 -92 0
+-97 17 -65 0
+76 86 79 0
+52 -56 69 0
+95 30 -38 0
+-81 73 -45 0
+60 -27 92 0
+-8 -67 -92 0
+-93 -34 48 0
+72 76 -10 0
+-1 79 26 0
+-32 36 -93 0
+64 -94 -89 0
+43 -9 -27 0
+-76 -66 40 0
+-66 -87 25 0
+-92 91 -70 0
+-82 -10 -90 0
+-50 1 -74 0
+-45 -81 29 0
+31 -1 -56 0
+-14 -51 -60 0
+80 -6 46 0
+-98 -65 85 0
+18 50 -77 0
+-32 -45 -93 0
+77 -81 -3 0
+92 59 -5 0
+49 -5 33 0
+-81 -96 -52 0
+49 30 -11 0
+94 59 -96 0
+-21 96 -99 0
+6 -8 100 0
+-19 -82 53 0
+-25 9 30 0
+-60 18 66 0
+49 67 99 0
+14 -30 -8 0
+-15 -88 -74 0
+87 -89 -61 0
+-23 -14 -4 0
+-91 17 -89 0
+-78 71 -97 0
+-5 -27 63 0
+-59 78 -76 0
+-97 45 65 0
+-75 -30 -32 0
+52 -71 -44 0
+-37 66 -9 0
+-15 -97 76 0
+52 -68 -53 0
+-31 -27 -95 0
+-35 -41 57 0
+-60 26 84 0
+67 40 -19 0
+51 -81 57 0
+-69 -27 35 0
+50 23 -65 0
+24 61 78 0
+29 96 -42 0
+-36 -89 51 0
+100 60 -75 0
+58 -72 -86 0
+-74 1 -47 0
+-54 -37 71 0
+66 19 -98 0
+64 10 -49 0
+-1 2 42 0
+74 97 20 0
+-95 -2 64 0
+-74 -62 -65 0
+61 -42 85 0
+-81 -30 22 0
+-41 -49 -61 0
+56 -98 -52 0
+-95 57 62 0
+26 -77 21 0
+15 37 78 0
+78 -46 39 0
+-61 -72 -78 0
+76 -23 -37 0
+67 -34 93 0
+-17 27 19 0
+-31 -76 -25 0
+-96 43 70 0
+-48 100 59 0
+-58 7 49 0
+92 -24 -65 0
+-58 -8 -71 0
+-81 71 95 0
+86 -92 -18 0
+60 -35 -64 0
+47 -78 -96 0
+-6 45 -79 0
+29 -7 -26 0
+-42 -43 62 0
+-16 -47 -73 0
+52 2 35 0
+-19 -18 -66 0
+-52 23 -99 0
+48 88 -98 0
+47 63 -32 0
+76 93 -87 0
+-32 -58 17 0
+-90 -7 -33 0
+44 32 67 0
+-26 87 75 0
+43 -81 10 0
+29 23 -6 0
+-56 -11 -67 0
+67 -43 82 0
+46 -10 8 0
+37 9 -93 0
+-95 67 7 0
+60 -67 38 0
+-76 -22 -79 0
+-79 1 72 0
+-98 58 -46 0
+-73 -98 -51 0
+6 -58 -29 0
+-80 59 -5 0
+-20 -95 -60 0
+-28 -77 38 0
+58 40 39 0
+-71 -24 -94 0
+-82 46 -35 0
+46 23 45 0
+85 41 -2 0
+62 -71 8 0
+37 49 30 0
+30 -62 -41 0
+-62 -88 -36 0
+-50 -41 62 0
+33 25 -37 0
+-70 -52 11 0
+4 29 -87 0
+-35 -6 39 0
+-30 -21 79 0
+-21 -25 -56 0
+20 27 11 0
+55 -29 -39 0
+94 -7 -88 0
+70 -7 -80 0
+81 -20 -96 0
+95 96 81 0
+-15 80 35 0
+35 15 -14 0
+-82 -17 -97 0
+32 -45 -15 0
+-82 -76 87 0
+67 95 92 0
+8 83 -28 0
+11 87 -91 0
+3 79 -100 0
+-8 88 56 0
+-6 16 -32 0
+9 25 -61 0
+11 -56 -52 0
+-56 -66 -78 0
+-35 -90 72 0
+-27 -89 -37 0
+-36 94 78 0
+63 41 78 0
+-13 -97 -8 0
+75 -85 -80 0
+68 -2 52 0
+58 -95 -31 0
+58 -53 2 0
+-77 -80 -40 0
+-73 -46 75 0
+-16 -61 51 0
+5 -23 -3 0
+-97 -16 47 0
+-41 27 -93 0
+70 83 9 0
+94 52 62 0
+-53 -24 49 0
+-49 -55 -22 0
+9 -93 99 0
+-65 -42 92 0
+75 -78 -36 0
+75 -20 11 0
+-79 -32 39 0
+-82 77 10 0
+47 -90 10 0
+95 -53 14 0
+93 -49 30 0
+-20 56 40 0
+-69 -11 100 0
+97 -40 38 0
+-42 -54 64 0
+-66 -77 -86 0
+3 -98 19 0
+-66 25 -59 0
+13 100 90 0
+62 47 -4 0
+63 -69 64 0
+12 67 -40 0
+78 74 21 0
+-87 51 23 0
+26 -62 -75 0
+-17 -50 46 0
+-22 9 -77 0
+-58 -16 -59 0
+2 38 48 0
+52 -40 -11 0
+-5 -85 46 0
+61 86 -52 0
+-22 -5 -6 0
+78 84 95 0
+-75 -60 48 0
+81 91 -1 0
+70 1 -50 0
+11 60 -1 0
+-72 18 -67 0
+75 18 35 0
+39 83 -12 0
+-3 -79 -53 0
+48 10 -50 0
+-31 -97 7 0
+72 -37 -67 0
+27 98 -50 0
+90 -39 38 0
+-32 -38 -46 0
+-70 17 67 0
+-26 -85 66 0
+60 -17 -22 0
+69 -43 -96 0
+-42 -17 23 0
+58 68 25 0
+52 -69 23 0
+-42 20 -30 0
+21 98 27 0
+1 45 28 0
+-32 89 93 0
+94 -64 -4 0
+-30 -22 85 0
+-43 5 11 0
+80 21 -58 0
+33 76 -78 0
+%
+0
+

benchmarks/uf100/uf100-027.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -88 -99 26 0
+93 88 36 0
+-71 -55 31 0
+-84 39 -89 0
+7 8 62 0
+-29 -27 8 0
+90 -87 93 0
+54 65 85 0
+-7 87 96 0
+73 -34 10 0
+-31 -1 27 0
+75 -81 24 0
+54 -39 99 0
+46 69 -32 0
+-89 8 -92 0
+17 40 -66 0
+-74 -100 40 0
+31 -54 52 0
+75 -38 81 0
+-65 -67 23 0
+-22 80 -73 0
+-46 -96 -97 0
+98 -24 51 0
+62 28 -80 0
+-58 -99 -24 0
+-13 -77 -68 0
+-83 -10 -85 0
+75 92 -2 0
+68 2 83 0
+5 -2 -16 0
+-15 -94 49 0
+-71 61 22 0
+34 15 7 0
+-91 -8 -49 0
+90 -59 -94 0
+77 -1 69 0
+-37 54 9 0
+-73 -43 63 0
+-27 68 -10 0
+-68 30 24 0
+37 12 -11 0
+-53 74 -47 0
+-11 -5 -98 0
+-76 -11 -44 0
+-50 54 14 0
+-83 -52 -62 0
+85 -10 72 0
+-87 -82 -9 0
+60 30 -4 0
+87 65 -43 0
+50 20 -10 0
+-9 97 76 0
+-85 -14 -28 0
+-85 -57 11 0
+78 47 91 0
+-78 97 -47 0
+53 -17 -55 0
+75 -81 -95 0
+-84 59 49 0
+21 24 55 0
+-38 21 100 0
+-43 -61 24 0
+-78 -64 -2 0
+65 49 -33 0
+-22 -64 2 0
+-79 -12 -66 0
+85 38 35 0
+28 -12 -87 0
+4 -50 2 0
+15 -85 -9 0
+62 41 -94 0
+1 4 -28 0
+59 -40 -73 0
+-98 72 -7 0
+-43 23 55 0
+34 100 -58 0
+17 -28 -80 0
+-6 -21 -31 0
+36 -63 -71 0
+-13 -5 1 0
+84 90 -39 0
+-18 -34 -93 0
+88 -83 77 0
+-17 97 -5 0
+-66 51 71 0
+5 2 15 0
+9 -60 66 0
+57 -45 -26 0
+-75 -80 83 0
+46 -32 -73 0
+-41 2 92 0
+-87 -53 -94 0
+95 -11 21 0
+-18 37 89 0
+-43 36 -82 0
+-98 -34 -64 0
+-40 -30 92 0
+87 94 -38 0
+13 -56 32 0
+-12 -95 71 0
+66 50 37 0
+27 43 -19 0
+21 -20 -99 0
+40 -13 -25 0
+53 59 31 0
+11 -60 -70 0
+-67 5 -26 0
+46 -59 72 0
+-37 -25 41 0
+-22 -18 -64 0
+-87 74 -34 0
+-40 -81 1 0
+-18 -11 -97 0
+-18 -92 -6 0
+64 75 -89 0
+2 -15 26 0
+32 -11 -20 0
+-70 -93 95 0
+-48 -99 -41 0
+25 21 -69 0
+-65 -49 -11 0
+30 15 -92 0
+33 -16 61 0
+77 -29 -41 0
+-11 7 -18 0
+-75 -84 -14 0
+-67 -4 -13 0
+-27 85 -74 0
+-29 90 -85 0
+-68 -17 -73 0
+-50 -71 -76 0
+-61 -23 54 0
+32 -8 91 0
+61 -24 -93 0
+-12 61 16 0
+-76 -96 81 0
+-2 -20 59 0
+-61 25 47 0
+55 92 -65 0
+-46 48 -18 0
+-71 -7 59 0
+88 61 37 0
+85 77 -54 0
+73 83 76 0
+94 76 -59 0
+75 -7 -98 0
+-49 -46 16 0
+-15 77 8 0
+53 80 19 0
+-40 11 -24 0
+-89 97 67 0
+-41 -78 -71 0
+-89 77 38 0
+-32 98 26 0
+99 -65 -52 0
+82 52 -70 0
+73 78 76 0
+5 23 -16 0
+88 -50 -58 0
+55 98 48 0
+81 -3 -62 0
+48 -24 76 0
+-62 72 32 0
+-37 2 -99 0
+78 -69 97 0
+-37 55 -19 0
+-96 -53 -93 0
+81 38 30 0
+-61 51 -45 0
+-58 24 27 0
+-71 -86 -57 0
+58 -80 -14 0
+9 31 28 0
+82 -3 92 0
+85 -20 62 0
+-14 45 -96 0
+31 91 59 0
+-35 -49 -39 0
+-3 -68 84 0
+-32 -79 67 0
+-4 85 -99 0
+5 8 36 0
+83 -96 -84 0
+47 51 -48 0
+-73 23 -61 0
+-69 -16 84 0
+-46 93 -9 0
+26 -25 52 0
+73 -15 84 0
+-15 -29 -51 0
+-75 64 -79 0
+-59 -77 60 0
+-23 -84 -26 0
+-9 -65 93 0
+-100 -94 71 0
+48 -52 -12 0
+65 60 38 0
+55 -1 -65 0
+38 58 67 0
+50 42 25 0
+-53 -64 65 0
+-43 -34 7 0
+-20 21 25 0
+42 88 76 0
+-40 -67 -60 0
+78 39 38 0
+-89 45 41 0
+19 45 -28 0
+61 -70 -65 0
+55 -18 48 0
+89 59 -73 0
+-34 -89 21 0
+82 2 90 0
+-87 6 -86 0
+-34 96 -81 0
+-15 99 22 0
+-62 59 -10 0
+28 15 94 0
+34 -11 -43 0
+-83 -95 -81 0
+26 -90 88 0
+-68 38 71 0
+-70 -47 19 0
+1 97 52 0
+29 -98 -8 0
+-98 86 73 0
+-98 -100 87 0
+-73 47 54 0
+-33 -11 13 0
+98 -82 -25 0
+-89 -88 71 0
+-10 71 -3 0
+-3 12 27 0
+-72 35 -46 0
+11 17 -82 0
+-21 -10 60 0
+-94 -81 3 0
+76 79 -53 0
+-38 -6 90 0
+-84 100 25 0
+38 57 97 0
+42 -8 -32 0
+14 -63 -26 0
+54 -3 -70 0
+-22 92 3 0
+24 84 6 0
+-49 73 41 0
+-53 24 -88 0
+58 94 -88 0
+7 53 -71 0
+-59 -63 82 0
+97 32 -84 0
+62 64 -18 0
+34 99 -52 0
+-100 33 -35 0
+68 -100 36 0
+-61 -50 45 0
+59 -24 57 0
+-42 -63 66 0
+62 -22 -84 0
+100 63 93 0
+-10 -87 61 0
+93 -43 45 0
+63 -92 -73 0
+-77 16 84 0
+17 -47 10 0
+-21 -5 23 0
+2 -51 -49 0
+56 -63 91 0
+-90 68 60 0
+19 -44 54 0
+-64 -73 53 0
+93 56 -62 0
+41 -58 24 0
+75 76 82 0
+-40 -67 53 0
+-42 58 78 0
+-6 -37 -87 0
+-29 19 47 0
+67 -24 -8 0
+57 -97 21 0
+-14 30 73 0
+23 -29 54 0
+98 -25 -51 0
+-77 -43 -22 0
+-39 -47 -75 0
+74 -69 93 0
+64 -82 46 0
+-50 89 66 0
+99 -9 -85 0
+-99 -30 -21 0
+36 63 44 0
+-45 -73 -86 0
+-32 39 -65 0
+39 -37 -5 0
+98 55 26 0
+94 -64 -77 0
+41 37 58 0
+-3 -58 87 0
+-64 93 61 0
+-64 13 -72 0
+-3 -24 -62 0
+65 2 91 0
+-70 -31 74 0
+81 60 21 0
+57 -91 -49 0
+-27 -83 -3 0
+43 27 -65 0
+49 -19 22 0
+-50 -55 79 0
+-5 -52 -97 0
+33 -6 58 0
+-98 -37 -46 0
+-54 17 -13 0
+-94 -88 42 0
+-78 62 -89 0
+50 -48 -74 0
+-26 79 -5 0
+-66 -94 91 0
+66 62 -17 0
+45 -12 -36 0
+-1 34 -98 0
+42 67 -59 0
+20 -4 -93 0
+-39 -48 -24 0
+-29 99 -68 0
+16 32 87 0
+-93 -47 94 0
+51 13 35 0
+5 61 65 0
+-85 45 18 0
+-5 24 -81 0
+18 -31 32 0
+-43 -33 -38 0
+-94 80 20 0
+-77 92 -80 0
+44 48 13 0
+10 -55 -80 0
+66 -8 -94 0
+-63 79 -49 0
+-18 14 -47 0
+-86 -52 -38 0
+47 85 -30 0
+-87 -92 -4 0
+-49 57 67 0
+-53 -57 16 0
+90 40 -75 0
+2 84 -35 0
+27 -97 52 0
+-18 25 3 0
+87 -74 -99 0
+-26 -62 93 0
+-50 89 13 0
+-45 -48 -18 0
+43 -95 19 0
+-87 -65 -13 0
+39 -92 46 0
+-60 42 23 0
+94 -71 -90 0
+6 -9 61 0
+-63 41 -4 0
+60 -65 -62 0
+-39 56 94 0
+-4 22 -90 0
+59 -38 66 0
+-60 -24 -59 0
+-33 -59 50 0
+47 -2 1 0
+59 -66 -50 0
+-5 17 -20 0
+89 -96 5 0
+-32 -92 61 0
+27 -32 -26 0
+56 -30 54 0
+88 -83 -28 0
+-88 -41 60 0
+-94 20 -9 0
+79 -27 -26 0
+92 10 26 0
+-56 2 86 0
+48 -96 -79 0
+25 80 -85 0
+-28 13 -12 0
+-49 -9 -75 0
+-78 -10 -91 0
+-2 41 -94 0
+45 72 -60 0
+14 -32 7 0
+-91 33 -32 0
+55 84 -96 0
+43 48 -29 0
+-15 -72 -47 0
+-68 14 -83 0
+97 -30 99 0
+14 -49 89 0
+97 -36 84 0
+100 -85 -82 0
+-97 -26 95 0
+46 96 -63 0
+49 37 -5 0
+-73 -43 33 0
+66 68 88 0
+28 -10 -73 0
+56 -34 -67 0
+-74 -27 -79 0
+-37 -16 9 0
+58 -50 99 0
+-33 -72 -18 0
+11 -94 55 0
+-2 -98 72 0
+-57 -98 60 0
+-76 -47 -92 0
+20 83 -26 0
+-26 -48 -80 0
+-26 -77 49 0
+41 -14 -7 0
+42 54 -43 0
+87 -48 75 0
+-98 -11 60 0
+-28 16 -11 0
+-86 -54 -82 0
+89 96 14 0
+-23 15 -90 0
+-10 -24 -85 0
+3 28 92 0
+-82 -88 58 0
+23 -69 7 0
+-78 22 -50 0
+42 -29 -100 0
+-1 99 27 0
+%
+0
+

benchmarks/uf100/uf100-028.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 70 57 -71 0
+65 69 15 0
+53 -5 37 0
+-9 -65 6 0
+-81 13 38 0
+-84 96 83 0
+24 78 86 0
+-72 -18 -9 0
+94 62 -78 0
+-52 -43 42 0
+-73 -51 80 0
+-63 -54 42 0
+54 -84 -22 0
+32 -42 39 0
+68 33 -88 0
+35 -83 -7 0
+-17 31 -29 0
+-71 65 -78 0
+69 34 -100 0
+52 10 13 0
+95 -53 -5 0
+76 83 3 0
+-99 10 -79 0
+34 -70 -14 0
+14 -28 -66 0
+-49 -62 38 0
+25 38 86 0
+41 36 -19 0
+-51 -6 -14 0
+97 -11 35 0
+72 39 -57 0
+-49 -39 -46 0
+16 21 6 0
+33 -88 48 0
+-16 -68 41 0
+70 -62 -56 0
+86 34 -95 0
+2 -24 96 0
+-50 90 -20 0
+-28 52 59 0
+85 -72 -11 0
+-97 83 30 0
+-67 15 61 0
+96 -71 8 0
+-6 -95 -94 0
+13 -48 -67 0
+19 -85 -46 0
+86 43 -75 0
+-64 1 67 0
+14 -21 -30 0
+-3 98 40 0
+-33 -40 -13 0
+38 74 33 0
+-9 -84 -38 0
+10 -69 -74 0
+-32 79 -56 0
+99 -80 15 0
+1 96 -75 0
+70 -16 78 0
+61 -1 -34 0
+71 55 48 0
+-41 82 38 0
+-52 36 14 0
+-54 59 86 0
+-22 -50 -19 0
+-48 60 -49 0
+-18 -41 -33 0
+93 44 -8 0
+15 82 -10 0
+19 64 -10 0
+-31 -66 -58 0
+-31 78 -100 0
+35 26 -36 0
+94 47 -46 0
+-64 65 -52 0
+71 32 -37 0
+-88 41 75 0
+79 -39 -32 0
+79 -76 -10 0
+-12 42 20 0
+-33 86 -52 0
+66 -2 3 0
+-46 -67 45 0
+41 -60 -2 0
+5 -94 23 0
+-45 -90 23 0
+-58 -23 38 0
+68 -9 -93 0
+39 -27 34 0
+21 81 -11 0
+79 50 56 0
+-38 -4 -37 0
+-1 32 -7 0
+68 83 -19 0
+17 -43 -75 0
+94 -64 -29 0
+-64 -2 78 0
+98 -77 73 0
+97 37 99 0
+-8 -55 64 0
+-62 76 -11 0
+65 -88 -77 0
+-83 -85 -29 0
+-73 -85 -36 0
+-93 -7 28 0
+3 50 84 0
+-89 4 -96 0
+18 -29 -67 0
+-46 57 40 0
+-54 -21 45 0
+-90 -79 83 0
+81 -27 -76 0
+63 -1 -25 0
+55 -42 -19 0
+-89 -90 1 0
+59 43 16 0
+-12 -16 65 0
+-46 24 37 0
+-51 88 62 0
+26 -12 -20 0
+-60 -41 -27 0
+-14 -84 77 0
+14 -17 -61 0
+71 38 82 0
+-63 -33 -17 0
+-66 -19 39 0
+54 -8 -93 0
+68 99 -81 0
+23 -19 6 0
+10 -13 46 0
+-24 60 -62 0
+7 25 65 0
+4 -9 -8 0
+-56 76 -81 0
+69 39 95 0
+93 -66 -80 0
+-52 8 15 0
+92 -25 51 0
+79 -58 -7 0
+7 -22 -39 0
+-19 48 99 0
+44 -38 64 0
+23 -79 -56 0
+-26 18 -88 0
+-71 -22 27 0
+-91 24 -55 0
+37 -59 -22 0
+-6 -12 55 0
+43 83 33 0
+18 -17 55 0
+52 -79 -55 0
+91 4 29 0
+88 -10 -30 0
+-57 13 71 0
+-22 61 33 0
+-8 -56 -100 0
+-33 -52 -71 0
+79 -51 -84 0
+-96 49 66 0
+82 60 -69 0
+36 45 -29 0
+-2 -39 41 0
+47 -79 55 0
+83 82 95 0
+57 30 92 0
+98 80 -73 0
+-16 18 -57 0
+-36 -95 -15 0
+-49 64 -55 0
+-54 -41 79 0
+77 -65 -79 0
+-18 -98 -76 0
+34 -23 -88 0
+-9 37 32 0
+50 -87 -83 0
+35 42 32 0
+71 61 -9 0
+39 68 19 0
+95 -24 -44 0
+-70 -36 64 0
+-20 98 70 0
+-63 82 74 0
+-67 -76 -86 0
+88 15 35 0
+85 37 76 0
+57 98 -74 0
+71 90 -61 0
+-9 -85 44 0
+86 -66 -50 0
+32 65 -88 0
+-11 -58 -86 0
+71 -36 84 0
+-99 -86 -42 0
+-65 29 -25 0
+17 -74 -64 0
+34 -33 37 0
+89 34 14 0
+-18 -97 -100 0
+-35 40 -92 0
+-36 -42 74 0
+-50 99 -81 0
+16 5 11 0
+43 -41 -18 0
+-6 -35 -34 0
+-97 29 -99 0
+-18 -76 -62 0
+-76 77 82 0
+8 -49 45 0
+-18 -96 -79 0
+9 -89 1 0
+71 -77 -4 0
+-9 49 41 0
+-94 -43 -39 0
+85 -81 62 0
+-45 62 -34 0
+-23 -96 65 0
+-63 -19 70 0
+-46 -96 -9 0
+68 -48 74 0
+-62 -28 9 0
+58 -1 -25 0
+51 -17 -13 0
+35 -15 61 0
+37 -66 -71 0
+-58 -56 -81 0
+94 9 61 0
+12 -81 32 0
+-90 -35 15 0
+74 15 -79 0
+-98 83 -29 0
+-38 -43 90 0
+13 -72 -1 0
+-45 85 35 0
+-73 -8 -26 0
+-24 49 -34 0
+33 -63 -24 0
+42 73 -55 0
+-42 62 -35 0
+88 94 77 0
+-64 67 76 0
+79 -52 65 0
+86 -15 99 0
+91 -98 -78 0
+-94 -61 92 0
+-98 38 2 0
+76 13 73 0
+-66 1 60 0
+-80 -32 -14 0
+56 51 48 0
+-82 -19 -59 0
+-5 69 6 0
+22 -75 -82 0
+-19 -95 -11 0
+-31 2 -45 0
+60 42 25 0
+49 3 23 0
+47 86 65 0
+25 42 -22 0
+-33 48 -75 0
+-43 86 -39 0
+84 78 -76 0
+51 -50 -71 0
+-43 3 -37 0
+37 70 2 0
+9 -89 13 0
+-21 40 19 0
+-82 96 70 0
+-48 53 -50 0
+38 -54 57 0
+-66 74 92 0
+20 42 86 0
+58 -19 27 0
+74 19 91 0
+-10 -40 62 0
+-69 44 100 0
+-8 -41 64 0
+-25 -36 -20 0
+-89 -36 10 0
+87 69 51 0
+-75 -4 -72 0
+-96 -71 34 0
+-60 88 47 0
+-70 28 45 0
+90 94 73 0
+68 -16 -11 0
+-33 86 45 0
+78 -4 97 0
+-34 51 -63 0
+-82 -20 63 0
+-62 -27 21 0
+-46 -98 97 0
+-99 -41 44 0
+-31 -98 76 0
+62 58 -25 0
+-30 73 -10 0
+-61 -90 73 0
+97 -80 76 0
+65 -5 39 0
+-46 -59 -72 0
+-54 -14 -56 0
+38 -25 -90 0
+45 78 49 0
+-62 83 28 0
+-14 69 -84 0
+68 -92 81 0
+23 92 69 0
+81 -46 28 0
+53 -28 80 0
+42 -19 -88 0
+94 49 -36 0
+-40 -94 -49 0
+-31 41 -25 0
+-13 -35 98 0
+-97 4 67 0
+-40 24 -72 0
+55 80 -68 0
+100 62 2 0
+-95 34 44 0
+40 23 9 0
+30 46 63 0
+76 -75 83 0
+5 77 -75 0
+-15 -97 -29 0
+-63 29 -78 0
+-11 -65 -30 0
+-76 -42 25 0
+72 -89 -79 0
+-42 -8 -77 0
+25 -28 94 0
+87 -10 -93 0
+-67 58 -100 0
+-93 88 -72 0
+52 75 74 0
+-93 -70 -66 0
+14 -59 -75 0
+-64 41 14 0
+47 -25 -19 0
+-84 -47 -27 0
+-95 -68 41 0
+-26 -67 72 0
+-57 -37 88 0
+1 -46 44 0
+-70 48 -86 0
+68 -99 -29 0
+-22 -85 49 0
+39 41 -58 0
+-45 11 -2 0
+27 -99 13 0
+73 -62 -15 0
+83 -92 59 0
+53 24 -83 0
+-66 -94 4 0
+34 8 31 0
+-63 -92 -87 0
+52 75 49 0
+52 -59 56 0
+28 34 -99 0
+-64 -36 87 0
+19 45 -99 0
+63 -73 -66 0
+-44 -35 -31 0
+5 97 33 0
+-82 -92 -70 0
+-75 4 95 0
+63 -72 -89 0
+1 26 -5 0
+-29 30 -71 0
+-96 -13 -91 0
+15 55 -81 0
+26 91 61 0
+-86 20 -68 0
+64 79 -22 0
+34 -36 66 0
+-2 15 1 0
+71 -50 19 0
+73 49 57 0
+-33 2 86 0
+-8 -71 -61 0
+20 -97 -74 0
+-49 -48 47 0
+-5 -50 -58 0
+-67 -23 98 0
+77 -86 -5 0
+-97 -79 -96 0
+68 48 -21 0
+-24 -20 48 0
+-78 -47 61 0
+10 76 -25 0
+14 -10 -62 0
+83 -48 9 0
+2 -86 43 0
+87 45 -70 0
+86 30 -43 0
+-94 -57 65 0
+17 -50 -93 0
+-50 54 41 0
+-15 89 -53 0
+-52 23 2 0
+50 -26 -2 0
+-59 98 -18 0
+6 -73 24 0
+54 -79 -15 0
+-79 14 73 0
+25 -58 31 0
+95 -31 10 0
+82 89 -5 0
+31 -88 48 0
+-95 -73 24 0
+72 77 -89 0
+14 98 -92 0
+-56 -92 -62 0
+-29 -28 -84 0
+87 67 50 0
+42 5 -79 0
+-91 20 -80 0
+56 -97 -82 0
+-14 -86 -6 0
+75 -48 -44 0
+26 99 -81 0
+-87 20 6 0
+56 -58 45 0
+16 -88 87 0
+99 -59 -96 0
+-19 8 -53 0
+-86 -99 1 0
+-39 -21 60 0
+-84 -74 22 0
+18 94 64 0
+67 -54 -53 0
+1 39 63 0
+%
+0
+

benchmarks/uf100/uf100-029.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -7 70 28 0
+23 42 18 0
+-31 64 -41 0
+58 -53 -17 0
+-60 -28 -95 0
+18 91 66 0
+-51 -68 -42 0
+-18 19 -29 0
+-40 -60 -21 0
+44 40 16 0
+-33 -39 91 0
+99 34 -3 0
+6 -19 11 0
+2 -16 -73 0
+11 -15 92 0
+27 -85 51 0
+-53 81 -68 0
+-48 -26 -88 0
+71 -61 -80 0
+-96 93 65 0
+99 -45 -100 0
+83 -15 -63 0
+19 -18 -9 0
+70 -46 29 0
+-1 -84 4 0
+-81 69 67 0
+64 1 44 0
+10 -69 31 0
+87 -45 52 0
+26 -95 -23 0
+52 40 -62 0
+-48 84 81 0
+5 19 -99 0
+-42 24 17 0
+-32 -65 -5 0
+48 -46 4 0
+-89 12 9 0
+-99 7 -37 0
+-70 -83 98 0
+98 -7 -1 0
+-66 8 40 0
+94 -5 15 0
+-20 -73 -24 0
+31 40 48 0
+-64 24 -29 0
+-59 -91 98 0
+2 -54 -19 0
+-33 76 65 0
+-21 -63 -74 0
+91 55 23 0
+9 -77 -39 0
+20 -77 53 0
+-31 -25 84 0
+29 -2 -80 0
+2 -60 25 0
+73 -89 -20 0
+-9 -14 -71 0
+-69 -83 -88 0
+69 6 48 0
+10 -98 -43 0
+7 -65 -5 0
+-25 73 70 0
+55 -7 -20 0
+76 -90 -56 0
+-42 8 -91 0
+-70 -48 -32 0
+74 -89 -65 0
+-76 29 -96 0
+82 13 -69 0
+30 -78 74 0
+87 32 63 0
+-10 79 -15 0
+-63 -98 -19 0
+38 74 67 0
+73 -40 81 0
+61 -46 -74 0
+-49 74 -58 0
+-53 -9 -78 0
+-26 5 -44 0
+-95 85 -93 0
+-18 91 -97 0
+71 62 -34 0
+-9 78 -89 0
+-56 -75 -61 0
+53 62 -57 0
+-97 56 -77 0
+-54 18 -52 0
+-67 55 54 0
+-12 -97 77 0
+45 -48 6 0
+-88 -90 98 0
+55 36 63 0
+82 90 64 0
+38 57 -2 0
+-59 -74 45 0
+7 62 27 0
+49 -81 -45 0
+-20 67 57 0
+-88 -40 -59 0
+86 -12 63 0
+-69 -82 100 0
+5 34 -6 0
+-16 65 -58 0
+75 35 -98 0
+-23 10 63 0
+22 10 19 0
+-46 -9 -38 0
+-42 74 -47 0
+-58 -21 -29 0
+-7 -77 63 0
+7 83 13 0
+-29 -49 -26 0
+-48 41 56 0
+88 -97 -22 0
+70 58 53 0
+36 -33 -97 0
+-65 -86 49 0
+73 -99 89 0
+-30 -81 -25 0
+-28 -66 -34 0
+-95 -33 93 0
+91 46 -35 0
+-88 8 -84 0
+4 65 -57 0
+4 44 19 0
+-96 19 49 0
+-38 100 75 0
+58 26 -18 0
+19 6 75 0
+-37 79 -47 0
+-69 21 12 0
+-95 -31 16 0
+-25 -95 -44 0
+-85 2 16 0
+87 72 29 0
+95 -13 -52 0
+-47 64 -12 0
+89 54 -76 0
+29 -5 74 0
+94 -50 80 0
+53 -77 36 0
+-85 -30 -68 0
+-77 81 -51 0
+-25 -41 75 0
+-7 79 -88 0
+10 -53 46 0
+50 41 -59 0
+-14 -15 32 0
+35 -91 -85 0
+-48 96 35 0
+92 -100 -50 0
+86 97 -38 0
+-15 48 -21 0
+14 -5 49 0
+70 -89 65 0
+-8 -61 -12 0
+-36 -83 -64 0
+-62 -99 -45 0
+-47 92 -63 0
+-13 -84 44 0
+90 -96 -75 0
+69 -90 54 0
+-29 24 37 0
+-31 53 5 0
+-49 61 -3 0
+-6 29 87 0
+51 98 -29 0
+-41 58 15 0
+-91 -62 74 0
+15 -3 83 0
+-7 -100 -49 0
+-33 29 76 0
+-52 73 -63 0
+-88 40 55 0
+-83 -50 11 0
+86 -73 -5 0
+-13 -98 11 0
+-94 -11 -16 0
+50 65 5 0
+13 -9 -90 0
+29 -59 -28 0
+16 -6 90 0
+-70 88 60 0
+-50 -93 2 0
+-94 10 36 0
+-38 -61 -69 0
+58 10 -68 0
+-96 -5 -49 0
+-93 -39 -86 0
+-22 -86 92 0
+67 -7 -85 0
+-97 -29 88 0
+-26 72 28 0
+-67 20 55 0
+34 -36 33 0
+49 -60 -9 0
+-12 -90 -9 0
+22 -79 -57 0
+65 -19 3 0
+-66 5 52 0
+100 79 -4 0
+-88 23 87 0
+82 -43 -18 0
+21 -56 -89 0
+41 -64 92 0
+-39 72 47 0
+6 -22 32 0
+-70 80 -51 0
+-17 -39 96 0
+-32 -62 -27 0
+-10 27 1 0
+92 15 57 0
+-36 -11 97 0
+-58 -88 -85 0
+88 -10 -44 0
+-76 90 24 0
+-12 -37 -48 0
+-86 -96 -100 0
+29 -39 58 0
+95 -79 46 0
+-36 69 -16 0
+93 56 -98 0
+29 -10 52 0
+-99 21 -72 0
+92 -29 41 0
+-64 3 79 0
+-55 4 -37 0
+-24 37 -45 0
+-50 49 -6 0
+-10 -53 -35 0
+78 89 76 0
+-96 -40 51 0
+-14 4 -88 0
+-15 80 20 0
+70 -79 51 0
+-24 54 -64 0
+-30 89 -49 0
+100 -20 28 0
+-10 100 -62 0
+-40 -4 -29 0
+-9 22 1 0
+-32 40 -27 0
+-43 -35 -79 0
+-12 74 -63 0
+-51 -83 -93 0
+-56 76 -82 0
+95 -79 -32 0
+-80 -2 58 0
+-83 -39 -84 0
+-7 64 65 0
+-42 -7 -97 0
+-33 -31 -12 0
+-93 -99 -48 0
+47 -4 52 0
+-9 -49 89 0
+35 85 20 0
+23 -71 50 0
+-25 55 46 0
+-41 -64 -13 0
+17 -74 46 0
+18 3 10 0
+56 -57 -19 0
+-53 -16 -35 0
+8 30 -16 0
+-19 38 55 0
+-89 -59 -24 0
+-46 -52 15 0
+-45 10 21 0
+31 16 -38 0
+-27 55 98 0
+3 7 -98 0
+-85 50 46 0
+4 58 13 0
+-33 67 -36 0
+30 39 27 0
+-67 23 -52 0
+58 34 6 0
+7 -36 76 0
+-41 -93 -78 0
+-48 93 29 0
+-18 86 71 0
+25 8 -53 0
+49 19 -20 0
+35 -79 72 0
+-2 28 -30 0
+-93 -33 -47 0
+87 90 18 0
+-65 -20 22 0
+23 -37 74 0
+-35 -92 65 0
+59 -15 -88 0
+7 -87 -72 0
+-87 -8 -96 0
+97 -3 -71 0
+66 84 -13 0
+-71 8 9 0
+-13 -34 -92 0
+-58 43 -88 0
+50 14 57 0
+98 10 -33 0
+5 -11 90 0
+18 -81 51 0
+-90 -22 -49 0
+-31 24 80 0
+-36 -42 -34 0
+50 -55 -84 0
+55 -86 -33 0
+-11 -84 -18 0
+25 -92 -16 0
+-28 -14 -1 0
+35 -30 -6 0
+70 23 -59 0
+98 -39 -37 0
+7 23 -89 0
+-81 54 -80 0
+32 -50 -90 0
+-12 37 81 0
+-23 35 48 0
+57 -56 -67 0
+-11 59 -47 0
+51 71 -12 0
+-99 -20 -16 0
+-88 12 -35 0
+-28 -93 47 0
+-83 -29 87 0
+-22 38 61 0
+60 -67 55 0
+-27 68 95 0
+-42 66 -24 0
+28 -20 -22 0
+64 -14 -27 0
+64 -36 -40 0
+26 -1 63 0
+-52 -4 68 0
+-69 20 25 0
+79 98 29 0
+79 86 40 0
+-14 29 -15 0
+78 -100 -81 0
+-51 43 92 0
+91 11 23 0
+-24 95 30 0
+-76 26 62 0
+67 80 -10 0
+19 75 -27 0
+-36 -40 -71 0
+3 82 -81 0
+65 20 18 0
+37 76 99 0
+-31 -41 98 0
+17 86 -87 0
+-46 -25 54 0
+-43 -88 -64 0
+-5 -72 81 0
+81 -34 1 0
+54 70 -33 0
+-13 59 -2 0
+-12 79 -58 0
+57 51 25 0
+41 81 52 0
+88 71 5 0
+-97 -24 76 0
+68 -1 91 0
+78 -32 -87 0
+-21 9 -69 0
+8 -37 -58 0
+30 -53 -92 0
+17 18 -81 0
+44 20 -88 0
+-19 44 65 0
+73 23 50 0
+-98 -65 59 0
+69 -87 -27 0
+-6 -37 88 0
+48 -86 -54 0
+-26 -45 92 0
+82 -72 -92 0
+-50 -29 47 0
+44 -84 77 0
+-42 24 30 0
+-64 61 45 0
+-82 -19 90 0
+-34 -8 -79 0
+-21 -27 41 0
+-42 -100 -39 0
+72 59 -35 0
+36 -96 90 0
+-75 -2 56 0
+10 3 65 0
+65 42 22 0
+78 85 -75 0
+-84 -36 74 0
+-35 54 77 0
+97 39 -78 0
+11 -81 21 0
+92 -78 -11 0
+-89 -14 83 0
+-83 -9 88 0
+-73 93 63 0
+-51 -50 -82 0
+8 -56 52 0
+-18 49 44 0
+34 -94 27 0
+45 -25 -16 0
+-9 -26 -4 0
+65 4 -24 0
+-47 40 32 0
+8 -72 -36 0
+-57 38 -12 0
+27 53 13 0
+98 7 12 0
+5 -70 73 0
+79 67 -83 0
+2 58 -13 0
+1 -57 -10 0
+21 86 -60 0
+67 12 52 0
+51 27 -77 0
+9 -42 -36 0
+-79 -55 23 0
+42 88 96 0
+83 87 -13 0
+45 76 87 0
+99 18 68 0
+99 19 78 0
+31 49 -33 0
+28 -32 -39 0
+-1 10 40 0
+-14 -30 67 0
+-4 -62 24 0
+%
+0
+

benchmarks/uf100/uf100-03.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 2 -71 -70 0
+27 81 -34 0
+-25 -65 79 0
+-38 60 59 0
+24 58 -74 0
+-14 -77 65 0
+-51 7 6 0
+43 53 72 0
+-34 -64 89 0
+-99 -84 -65 0
+65 -9 47 0
+-55 42 -34 0
+67 -68 15 0
+-68 23 -4 0
+64 -13 47 0
+-99 50 -46 0
+-33 82 -6 0
+-60 -76 81 0
+65 88 -25 0
+84 -15 -34 0
+-11 49 -25 0
+28 -60 -47 0
+-100 12 -29 0
+2 -73 -80 0
+14 -77 -97 0
+22 -99 -44 0
+-10 81 -30 0
+10 -14 94 0
+31 96 -75 0
+-93 -35 44 0
+84 3 -30 0
+99 58 -65 0
+10 -22 -92 0
+-5 91 81 0
+-47 -93 36 0
+-22 -66 -19 0
+-36 92 24 0
+-78 29 58 0
+54 37 8 0
+-36 -62 -2 0
+88 74 48 0
+-73 -60 -32 0
+-32 37 79 0
+8 -60 -47 0
+24 30 -23 0
+-7 -89 -48 0
+95 -69 -33 0
+-77 -96 29 0
+66 93 -95 0
+-74 -32 18 0
+71 63 8 0
+91 12 72 0
+16 -14 31 0
+-80 35 9 0
+-62 20 49 0
+98 87 -67 0
+-9 96 95 0
+15 -36 46 0
+-62 59 -50 0
+88 -94 17 0
+39 -71 19 0
+-88 -85 20 0
+-14 79 -74 0
+75 -85 12 0
+21 -43 38 0
+-69 17 -80 0
+11 -10 40 0
+69 -6 82 0
+97 -39 91 0
+-52 84 -88 0
+-99 -89 82 0
+-34 87 13 0
+-77 86 -10 0
+-63 25 -14 0
+-99 -85 -59 0
+52 72 67 0
+37 -84 29 0
+-54 -32 64 0
+53 85 51 0
+-4 -2 -86 0
+-41 -47 -32 0
+-10 80 3 0
+-13 -68 80 0
+-14 10 24 0
+-92 18 42 0
+-41 47 -63 0
+46 -30 -39 0
+-97 -2 -41 0
+16 -92 7 0
+79 47 38 0
+-37 65 92 0
+-58 83 42 0
+70 27 32 0
+8 -18 -1 0
+-34 -35 4 0
+-17 92 8 0
+48 10 -62 0
+14 -67 24 0
+31 87 -34 0
+78 94 -49 0
+24 12 -73 0
+61 -49 54 0
+18 56 69 0
+72 -12 36 0
+93 -32 19 0
+-7 -87 -50 0
+71 -61 38 0
+69 84 83 0
+-39 96 -20 0
+100 4 -5 0
+57 51 -55 0
+95 1 -15 0
+60 94 -63 0
+-51 70 -83 0
+-43 98 48 0
+17 93 71 0
+-18 23 39 0
+-10 -42 -82 0
+-3 -42 52 0
+-15 -28 -43 0
+78 5 -77 0
+73 -45 -22 0
+30 -5 -11 0
+81 60 26 0
+78 46 39 0
+-5 86 -31 0
+81 6 -3 0
+-72 -47 -2 0
+-66 -38 18 0
+2 -48 94 0
+-66 -72 87 0
+-55 34 25 0
+-55 -8 88 0
+15 56 -83 0
+-81 -48 -100 0
+-76 54 -40 0
+83 -5 -26 0
+49 -16 -68 0
+-81 86 -14 0
+16 -99 -8 0
+83 -49 22 0
+95 -3 40 0
+-51 -80 69 0
+67 -38 -39 0
+-45 54 7 0
+-43 -76 50 0
+79 -81 51 0
+-18 33 95 0
+-12 84 83 0
+-49 58 92 0
+57 61 -93 0
+54 3 60 0
+20 39 -75 0
+60 -37 -77 0
+-81 -36 -48 0
+-90 -48 25 0
+61 8 -52 0
+64 32 11 0
+30 5 -72 0
+96 -28 -95 0
+8 -89 -33 0
+82 -32 93 0
+6 -16 -36 0
+52 -83 86 0
+-82 85 -61 0
+-61 -36 49 0
+-78 -49 51 0
+74 87 -18 0
+-90 54 76 0
+58 -28 70 0
+-94 -91 -79 0
+63 -7 48 0
+6 -75 68 0
+-5 32 91 0
+-88 -66 61 0
+-87 -92 -7 0
+62 -40 -71 0
+59 -78 34 0
+-63 -97 42 0
+88 65 15 0
+-64 -8 -6 0
+35 34 -22 0
+-65 1 -71 0
+9 89 60 0
+100 -30 1 0
+28 41 29 0
+15 -46 -34 0
+-29 17 76 0
+62 -23 89 0
+-57 -71 61 0
+78 12 -79 0
+7 -59 -36 0
+-15 24 4 0
+-91 84 40 0
+-11 60 -82 0
+-9 -94 79 0
+77 6 -82 0
+100 60 1 0
+-21 40 6 0
+-71 30 -70 0
+-19 -9 -80 0
+21 -73 85 0
+-79 -85 90 0
+2 -9 -79 0
+-17 -39 27 0
+-73 10 36 0
+31 28 -4 0
+44 -9 -74 0
+-72 -90 71 0
+-48 -14 -78 0
+2 72 -78 0
+-69 -54 13 0
+62 12 51 0
+-98 -17 28 0
+-7 -15 37 0
+52 90 8 0
+14 -95 -85 0
+69 -28 64 0
+-58 60 -25 0
+9 34 -6 0
+-82 -69 84 0
+21 11 -5 0
+56 6 -100 0
+-27 -81 22 0
+43 74 84 0
+41 -100 -69 0
+35 10 77 0
+11 -70 19 0
+-72 -16 -24 0
+43 -9 -63 0
+-26 97 -81 0
+61 -56 -79 0
+-51 4 62 0
+13 -85 65 0
+-25 20 -40 0
+68 -71 93 0
+-18 -26 -69 0
+89 -14 -66 0
+-100 96 63 0
+96 56 60 0
+31 -11 76 0
+36 -77 67 0
+66 62 44 0
+-11 -23 74 0
+70 -11 -73 0
+-37 64 -52 0
+-95 -99 -59 0
+-65 33 -32 0
+-7 54 81 0
+-93 99 -46 0
+-42 -40 -62 0
+85 -93 -82 0
+-32 -55 87 0
+21 57 85 0
+-37 -29 11 0
+81 36 -54 0
+26 -14 45 0
+61 -88 91 0
+-78 -71 98 0
+-74 -9 -63 0
+-99 72 92 0
+4 39 -34 0
+-83 -7 79 0
+14 -31 -100 0
+45 -67 -81 0
+-65 49 -43 0
+77 -4 95 0
+-1 34 47 0
+7 20 32 0
+-79 -76 90 0
+-31 48 -89 0
+30 -81 92 0
+65 -91 -76 0
+12 -76 1 0
+-67 61 -8 0
+-97 51 38 0
+-73 -54 22 0
+-7 -43 -3 0
+-64 65 47 0
+96 75 90 0
+93 27 -60 0
+-73 85 38 0
+6 56 58 0
+80 -1 -76 0
+56 -60 -58 0
+55 -54 15 0
+98 -57 -11 0
+50 -57 -15 0
+-18 -44 53 0
+-77 26 35 0
+26 -92 -38 0
+-37 -33 75 0
+22 39 -48 0
+46 47 -53 0
+16 42 -47 0
+73 -38 -76 0
+74 -14 -85 0
+81 7 6 0
+-29 80 -55 0
+-51 -35 12 0
+-81 -57 61 0
+-9 -40 51 0
+-60 -69 -42 0
+73 26 -56 0
+97 -56 -9 0
+-32 -33 49 0
+-30 -98 55 0
+-16 49 11 0
+-34 86 33 0
+-64 9 95 0
+64 48 -80 0
+-26 -70 -66 0
+22 66 4 0
+-40 57 3 0
+12 -9 22 0
+53 -44 86 0
+-1 -81 96 0
+22 82 12 0
+42 54 92 0
+-58 38 45 0
+18 97 68 0
+29 -30 -3 0
+-71 18 -45 0
+18 84 13 0
+-46 -86 76 0
+15 82 85 0
+-73 -8 38 0
+86 -16 91 0
+12 87 -17 0
+-25 100 -52 0
+-71 -34 -48 0
+69 50 59 0
+15 5 44 0
+13 -44 4 0
+91 -8 28 0
+-8 67 -80 0
+-6 -90 7 0
+93 10 -30 0
+-54 -28 -6 0
+86 -47 -97 0
+60 -96 -40 0
+56 -72 3 0
+12 -77 57 0
+-2 -20 24 0
+-45 23 8 0
+-17 -7 61 0
+53 -13 -55 0
+-44 57 -39 0
+-94 68 -81 0
+-98 -66 100 0
+73 83 61 0
+81 -52 -16 0
+-18 27 -52 0
+-14 -13 68 0
+-85 64 -76 0
+85 91 -35 0
+-48 1 26 0
+58 53 -36 0
+-9 22 66 0
+-86 -1 95 0
+13 70 4 0
+21 62 -23 0
+-54 -82 11 0
+43 -99 -42 0
+40 61 58 0
+47 -35 12 0
+-73 1 87 0
+-54 -1 -92 0
+84 32 -81 0
+83 80 17 0
+-82 60 -73 0
+18 -82 -54 0
+15 -31 -100 0
+-87 79 -22 0
+23 87 -41 0
+77 -7 14 0
+-2 17 -3 0
+-56 36 10 0
+-45 -28 -83 0
+-27 -18 -73 0
+22 -34 5 0
+-58 85 21 0
+40 -96 77 0
+53 -95 45 0
+-22 -88 58 0
+-92 78 48 0
+99 70 -14 0
+61 69 -49 0
+-54 71 -94 0
+-39 27 -42 0
+-11 12 -75 0
+88 6 -56 0
+56 85 -54 0
+-3 -75 42 0
+-51 13 -75 0
+-89 -20 6 0
+50 -65 19 0
+91 22 28 0
+-16 28 -24 0
+-5 -75 10 0
+-74 56 38 0
+92 -69 80 0
+-54 64 -68 0
+-30 -23 22 0
+-52 -85 -21 0
+80 37 -44 0
+32 8 30 0
+57 -71 -67 0
+18 81 -96 0
+85 87 60 0
+92 27 -59 0
+97 -74 -81 0
+-30 -41 68 0
+-69 83 1 0
+-40 7 -21 0
+-22 3 94 0
+53 -35 -11 0
+-32 -91 36 0
+19 55 84 0
+-53 -58 12 0
+42 -79 -26 0
+-72 11 -99 0
+77 -76 50 0
+-13 93 90 0
+2 64 66 0
+-36 79 -1 0
+25 -86 69 0
+83 -45 -88 0
+-67 -68 -55 0
+63 -65 -29 0
+%
+0
+

benchmarks/uf100/uf100-030.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -56 -39 -74 0
+-37 19 72 0
+8 -90 -14 0
+-62 -100 -52 0
+45 -41 -77 0
+-64 -100 36 0
+-97 -75 -84 0
+85 -71 -6 0
+63 57 39 0
+-82 -66 53 0
+-20 -38 -14 0
+-67 -95 45 0
+43 -56 -96 0
+-35 -19 10 0
+87 -37 -96 0
+-54 -14 7 0
+-38 -35 -99 0
+9 -27 -26 0
+-57 -10 -100 0
+-96 70 -92 0
+62 -99 -68 0
+67 -1 71 0
+-58 -13 66 0
+-18 -96 47 0
+-79 -48 -94 0
+-32 18 78 0
+72 -14 44 0
+84 -21 42 0
+96 -100 25 0
+44 62 51 0
+-16 -64 -25 0
+-37 -35 85 0
+-10 62 69 0
+80 6 49 0
+-8 92 93 0
+-65 45 -88 0
+61 -73 -86 0
+-93 63 24 0
+-11 -94 -39 0
+-92 -5 78 0
+-9 28 -50 0
+47 77 60 0
+95 -15 -75 0
+-52 87 -82 0
+-77 38 84 0
+60 30 -74 0
+-96 72 -67 0
+68 97 -4 0
+30 -68 66 0
+-90 -35 -50 0
+-20 -49 1 0
+83 54 98 0
+38 77 98 0
+-20 -48 80 0
+98 48 -73 0
+19 40 -11 0
+46 -16 22 0
+44 3 7 0
+54 64 73 0
+71 -47 -78 0
+5 13 -38 0
+83 79 -86 0
+36 66 -53 0
+67 -59 61 0
+70 63 56 0
+-46 10 -63 0
+53 8 -74 0
+89 -47 -61 0
+-38 -56 25 0
+-8 65 -79 0
+-14 57 94 0
+71 93 26 0
+-39 -19 -84 0
+-66 -97 28 0
+-7 -2 -87 0
+-69 -79 -55 0
+81 -25 87 0
+42 8 -35 0
+97 -72 -91 0
+47 -68 -87 0
+-32 -22 -30 0
+-80 -64 -8 0
+83 -11 17 0
+-32 61 -1 0
+3 91 72 0
+-68 65 53 0
+-34 -12 45 0
+-82 91 -4 0
+9 57 -54 0
+-94 -16 66 0
+88 -20 73 0
+77 7 32 0
+42 -88 2 0
+-37 95 -84 0
+65 -96 -12 0
+39 -47 -83 0
+-31 -64 -62 0
+-74 -26 56 0
+-1 -7 36 0
+-80 -62 -34 0
+56 30 41 0
+-94 71 -91 0
+-24 -7 -1 0
+-20 -82 -77 0
+94 45 34 0
+-21 92 -55 0
+-88 -24 -66 0
+-53 -3 -5 0
+-23 -2 67 0
+72 -51 77 0
+-31 -98 5 0
+80 46 58 0
+45 77 40 0
+-34 -53 -23 0
+32 23 30 0
+20 58 -5 0
+59 -23 8 0
+-53 -12 8 0
+14 -95 90 0
+17 26 -63 0
+-54 -52 -47 0
+20 34 -11 0
+-59 -3 -90 0
+-3 9 45 0
+-32 61 -64 0
+84 61 48 0
+19 -38 57 0
+-8 23 98 0
+-91 -11 92 0
+15 17 -94 0
+92 84 -37 0
+-40 39 16 0
+-77 26 29 0
+22 -5 -42 0
+44 2 14 0
+-27 3 20 0
+22 65 -60 0
+-59 -10 88 0
+-19 5 -6 0
+-58 -61 95 0
+7 -25 8 0
+49 9 97 0
+-71 -4 41 0
+-60 -9 29 0
+-57 -27 8 0
+-57 4 30 0
+-97 -79 -25 0
+-24 57 -74 0
+88 74 73 0
+-63 95 -69 0
+75 -2 -69 0
+20 -62 -78 0
+-14 79 21 0
+51 30 9 0
+66 -9 -41 0
+-98 -52 -88 0
+65 76 -15 0
+6 34 -49 0
+-62 -72 -21 0
+-17 -61 -75 0
+44 -92 -4 0
+-85 -23 -35 0
+70 -71 88 0
+8 58 -80 0
+-95 44 35 0
+21 -45 -19 0
+83 -61 -99 0
+-71 30 34 0
+65 -54 88 0
+-19 77 -59 0
+-80 -66 -5 0
+-74 -72 42 0
+-35 59 -31 0
+-98 82 31 0
+-100 -44 90 0
+19 -75 -100 0
+5 47 61 0
+-48 52 8 0
+-55 17 5 0
+-99 -1 -74 0
+22 78 44 0
+-10 -6 -63 0
+19 -99 -32 0
+-50 31 -67 0
+-85 15 69 0
+-27 24 5 0
+86 54 -12 0
+-28 -43 61 0
+-10 -18 -68 0
+45 57 -98 0
+41 -23 -46 0
+96 20 63 0
+71 -86 85 0
+40 72 -88 0
+-61 1 -69 0
+-15 -56 -90 0
+-11 60 76 0
+-97 74 -5 0
+-2 -42 -30 0
+61 -20 -75 0
+-97 -8 45 0
+42 77 -70 0
+36 46 45 0
+99 28 90 0
+-3 78 -67 0
+-67 2 11 0
+30 -10 -89 0
+83 5 -6 0
+22 -59 -42 0
+-53 56 -29 0
+61 82 6 0
+77 -24 -14 0
+5 87 80 0
+-49 -76 -74 0
+-50 -3 19 0
+-74 -22 15 0
+5 -46 53 0
+-93 73 23 0
+-5 49 -16 0
+-42 -97 69 0
+94 50 51 0
+-38 -34 66 0
+26 45 7 0
+88 23 56 0
+69 43 -98 0
+68 97 -23 0
+39 43 84 0
+38 60 -81 0
+51 -96 21 0
+8 68 -64 0
+79 -73 -63 0
+51 30 11 0
+-71 72 3 0
+-51 -66 6 0
+-92 -80 -72 0
+-22 -64 50 0
+-52 15 71 0
+6 -21 -76 0
+18 -23 57 0
+-27 85 -8 0
+75 62 56 0
+65 -97 -34 0
+40 -65 -4 0
+-5 91 -98 0
+-90 41 75 0
+91 13 76 0
+-65 1 -19 0
+-82 -75 42 0
+-61 -94 5 0
+49 45 -58 0
+39 -33 9 0
+-36 43 -45 0
+-31 24 55 0
+-87 70 -38 0
+-8 77 -37 0
+-61 -40 -11 0
+-14 90 -32 0
+-39 74 97 0
+-37 32 76 0
+67 -30 -81 0
+-82 56 -21 0
+82 -38 64 0
+-87 35 81 0
+-89 64 -58 0
+68 4 10 0
+29 -89 -61 0
+-24 -62 23 0
+-94 62 -53 0
+-100 -33 -45 0
+38 64 -86 0
+52 -40 -81 0
+98 -12 -24 0
+-39 -92 59 0
+72 64 37 0
+-98 59 97 0
+-77 -57 48 0
+18 -66 47 0
+-39 24 36 0
+1 88 -65 0
+-70 -2 44 0
+75 61 -5 0
+57 -35 39 0
+-49 15 -48 0
+85 14 -51 0
+-35 -20 55 0
+27 -61 1 0
+5 39 53 0
+67 -90 -43 0
+78 59 68 0
+83 41 38 0
+-78 -46 -84 0
+95 82 4 0
+76 92 36 0
+73 84 -68 0
+-59 96 16 0
+20 -10 -79 0
+-69 82 -37 0
+-19 4 -53 0
+64 95 -42 0
+6 -94 -50 0
+55 10 -93 0
+90 -82 -61 0
+87 74 94 0
+97 92 10 0
+94 -29 39 0
+26 5 -39 0
+-97 -29 -33 0
+48 -41 -61 0
+-56 77 80 0
+10 -9 -32 0
+77 -78 86 0
+-66 92 53 0
+86 97 48 0
+35 -93 4 0
+16 67 -27 0
+28 91 55 0
+-39 -71 -42 0
+99 56 88 0
+-73 36 -18 0
+94 65 -41 0
+-99 -39 45 0
+3 -90 -20 0
+36 80 45 0
+-49 -98 82 0
+-40 -68 95 0
+-34 87 -44 0
+28 -43 -86 0
+-37 23 -46 0
+27 -94 69 0
+39 -99 -11 0
+-39 -12 85 0
+-78 -19 -67 0
+-30 -3 76 0
+47 11 -15 0
+-58 72 -69 0
+30 -62 -52 0
+-90 70 -43 0
+-82 39 -72 0
+4 -34 -8 0
+77 11 52 0
+-11 32 63 0
+-38 -34 84 0
+77 68 -58 0
+42 29 -14 0
+-30 -23 -77 0
+83 78 -10 0
+59 -78 -86 0
+62 -34 -40 0
+99 -23 92 0
+-79 -1 62 0
+33 65 7 0
+-95 68 -24 0
+-52 -71 -15 0
+54 -88 -19 0
+84 79 -90 0
+-74 65 36 0
+25 -1 13 0
+29 32 -94 0
+-39 76 -71 0
+46 5 -49 0
+7 23 -46 0
+88 -28 53 0
+23 5 -64 0
+-99 86 -61 0
+-39 89 87 0
+69 -31 -59 0
+66 -62 -89 0
+51 85 68 0
+-99 1 59 0
+-6 -32 -27 0
+-62 -86 -22 0
+-41 -21 70 0
+9 -67 1 0
+-21 65 -17 0
+20 38 92 0
+8 -92 -33 0
+-11 -7 -13 0
+14 -74 62 0
+31 -17 93 0
+-8 -15 -63 0
+-46 -68 -85 0
+-70 -8 58 0
+78 2 -97 0
+-67 -48 9 0
+84 3 -19 0
+39 47 -24 0
+-94 51 -32 0
+-54 -41 52 0
+59 -5 -53 0
+2 -75 -48 0
+-49 1 -10 0
+66 95 -16 0
+-96 73 -22 0
+-47 34 -19 0
+67 34 50 0
+1 -84 4 0
+94 -22 -42 0
+79 60 -48 0
+-67 -95 10 0
+60 26 76 0
+12 -41 94 0
+62 -45 71 0
+78 32 94 0
+1 -100 -36 0
+53 -44 -20 0
+39 -64 -100 0
+-82 41 95 0
+-86 22 80 0
+-21 -47 -12 0
+-50 11 -40 0
+29 78 57 0
+-79 92 76 0
+22 30 -40 0
+13 -29 -33 0
+-19 33 100 0
+51 -31 16 0
+42 38 -18 0
+-35 32 -90 0
+-61 -45 26 0
+-83 87 43 0
+21 96 75 0
+-63 -44 -70 0
+41 -95 13 0
+-28 31 -89 0
+64 -5 -44 0
+50 8 -86 0
+56 -7 -32 0
+6 -28 -86 0
+-63 85 86 0
+-9 2 14 0
+%
+0
+

benchmarks/uf100/uf100-031.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 62 24 72 0
+-60 -61 65 0
+20 94 11 0
+-81 -72 -49 0
+-87 -2 -93 0
+44 -43 -23 0
+24 31 88 0
+-44 96 30 0
+-65 11 -99 0
+43 -8 -91 0
+-62 32 -13 0
+-100 -33 13 0
+6 -100 12 0
+-84 48 -60 0
+-81 -47 -73 0
+-61 27 -93 0
+-56 -3 -28 0
+-84 95 29 0
+14 -4 -95 0
+64 41 46 0
+-56 -94 79 0
+-62 17 -3 0
+-45 84 81 0
+-87 -64 -28 0
+56 -45 36 0
+-8 -30 31 0
+21 50 36 0
+-9 45 -20 0
+14 -5 33 0
+-36 42 59 0
+7 50 -62 0
+-57 -56 1 0
+29 -87 -46 0
+-18 89 -69 0
+65 64 96 0
+56 -42 88 0
+-68 36 -78 0
+69 57 43 0
+77 -23 7 0
+-99 -37 100 0
+32 16 -76 0
+41 -1 90 0
+75 -37 17 0
+-26 -2 -43 0
+-70 -11 78 0
+95 86 87 0
+-54 -19 30 0
+-47 -24 21 0
+-99 -2 41 0
+39 -87 96 0
+96 -44 94 0
+-63 81 -35 0
+-92 31 45 0
+64 32 84 0
+-71 -95 98 0
+-69 -95 98 0
+-40 37 93 0
+-55 -97 -33 0
+43 -24 95 0
+28 -27 97 0
+30 68 -43 0
+58 -85 36 0
+-52 14 -37 0
+47 -56 -21 0
+44 9 4 0
+89 -63 71 0
+-31 -47 -1 0
+7 49 -73 0
+-41 80 42 0
+37 66 -31 0
+43 95 27 0
+29 57 -63 0
+-88 -30 8 0
+-47 -13 20 0
+10 7 41 0
+93 7 31 0
+-33 89 -9 0
+50 41 75 0
+57 -25 -34 0
+-54 -8 -81 0
+98 -50 99 0
+-74 88 21 0
+49 98 -73 0
+-37 64 10 0
+45 -62 -16 0
+17 -53 -23 0
+-48 54 64 0
+-100 83 11 0
+-57 42 -81 0
+-75 -56 50 0
+-63 97 58 0
+61 60 91 0
+37 -27 8 0
+64 -55 45 0
+-96 22 -83 0
+48 99 -45 0
+92 -71 -72 0
+-53 24 4 0
+63 -77 72 0
+40 -94 -60 0
+-10 -27 -61 0
+37 -50 43 0
+5 18 -64 0
+-25 -79 -63 0
+-34 25 55 0
+55 57 61 0
+87 -48 69 0
+69 -60 -52 0
+-18 -93 47 0
+-41 23 56 0
+-30 -70 -59 0
+-8 -71 -18 0
+-10 -68 33 0
+-30 -17 -93 0
+-7 38 4 0
+65 -62 -89 0
+94 59 43 0
+85 44 9 0
+17 36 25 0
+-92 -18 -58 0
+14 -45 52 0
+74 -63 -61 0
+-58 -59 39 0
+-75 92 -79 0
+-20 -93 -8 0
+68 1 33 0
+-21 -76 64 0
+75 50 -96 0
+58 -91 -63 0
+26 -8 56 0
+-21 -53 43 0
+54 -92 21 0
+-55 -47 -63 0
+-22 -17 -69 0
+47 79 65 0
+-45 -32 -2 0
+-32 -38 64 0
+65 -10 82 0
+-5 -82 59 0
+-30 12 90 0
+44 58 32 0
+-18 77 54 0
+-17 93 -18 0
+-40 -24 60 0
+-10 26 36 0
+99 64 -6 0
+46 -27 99 0
+25 -47 24 0
+-63 -90 -61 0
+-71 12 -20 0
+-67 96 74 0
+42 32 51 0
+-47 -64 52 0
+73 50 -7 0
+18 81 5 0
+-5 16 32 0
+-3 -54 67 0
+58 41 -70 0
+28 84 6 0
+27 -34 96 0
+-67 -76 -60 0
+-33 57 26 0
+-5 -67 -62 0
+30 4 -56 0
+50 -65 -6 0
+-91 -62 51 0
+22 -93 -61 0
+68 -96 37 0
+-2 99 -17 0
+30 84 18 0
+-12 -19 75 0
+67 91 26 0
+98 7 -13 0
+-47 -37 82 0
+17 -25 98 0
+48 71 46 0
+-56 100 5 0
+98 -24 -50 0
+-93 -5 22 0
+-90 85 -41 0
+-14 -67 71 0
+-73 44 3 0
+-20 22 53 0
+-54 -26 -15 0
+91 -90 -66 0
+32 90 51 0
+5 -21 83 0
+-37 -18 -29 0
+100 41 -87 0
+-96 6 -76 0
+-46 -69 -42 0
+36 -75 11 0
+-25 18 27 0
+-14 6 -53 0
+-86 -15 74 0
+-13 22 80 0
+-44 -53 23 0
+-64 95 22 0
+-3 -61 -34 0
+-23 47 67 0
+-8 -21 -64 0
+-36 -19 34 0
+-63 37 99 0
+12 -28 -6 0
+-98 6 12 0
+-6 -10 40 0
+-50 -32 33 0
+-88 52 -42 0
+31 -48 -96 0
+1 -91 -84 0
+-31 61 -96 0
+84 -80 23 0
+-22 50 -63 0
+30 65 47 0
+-3 1 -30 0
+-72 45 -44 0
+-58 98 52 0
+-92 -36 -64 0
+-53 -28 -64 0
+-39 56 -65 0
+-52 -14 22 0
+68 38 34 0
+-34 -9 -83 0
+-96 16 -8 0
+-22 54 -16 0
+-63 -73 -71 0
+-20 -35 88 0
+-100 -87 -14 0
+-63 79 92 0
+32 59 -60 0
+-5 -7 54 0
+25 -10 55 0
+18 62 -95 0
+-7 -57 99 0
+-9 -52 65 0
+61 -2 99 0
+-61 -2 -74 0
+90 -26 -76 0
+28 -77 11 0
+-31 63 -57 0
+40 79 54 0
+57 74 48 0
+-11 37 87 0
+84 83 -51 0
+40 99 -11 0
+74 96 -17 0
+-68 83 10 0
+-8 66 -57 0
+-34 6 -45 0
+40 -54 -80 0
+13 -60 92 0
+92 39 84 0
+-22 44 -78 0
+-41 -72 5 0
+67 95 -73 0
+43 -57 -19 0
+35 -78 -29 0
+32 -100 8 0
+9 19 -17 0
+33 71 66 0
+-64 -59 -67 0
+73 28 31 0
+-66 -78 -8 0
+19 96 5 0
+-7 42 -80 0
+83 -10 55 0
+3 -66 74 0
+41 33 -97 0
+35 -25 -79 0
+48 67 -29 0
+-22 -84 76 0
+74 42 97 0
+-47 41 -13 0
+-30 72 -75 0
+16 98 -90 0
+63 58 48 0
+-61 2 -66 0
+-73 54 -15 0
+-81 79 -32 0
+17 62 -60 0
+71 66 -54 0
+43 65 -83 0
+-83 -94 -44 0
+-57 60 71 0
+51 31 -78 0
+-7 8 45 0
+42 -70 13 0
+-14 -60 28 0
+50 14 -66 0
+36 -53 12 0
+93 70 -57 0
+-87 -71 52 0
+-33 -8 89 0
+68 14 -59 0
+14 -69 -13 0
+73 75 -46 0
+-12 -99 46 0
+-92 -30 48 0
+-26 -58 -27 0
+-43 4 29 0
+-31 1 -85 0
+-52 41 -95 0
+-38 -95 22 0
+98 -1 -70 0
+84 -27 -63 0
+23 -13 91 0
+-4 41 -61 0
+90 -76 59 0
+-23 -58 35 0
+51 -67 46 0
+-5 1 41 0
+-15 11 71 0
+-39 98 84 0
+-31 32 -2 0
+83 -75 50 0
+-55 -92 29 0
+-25 -2 -47 0
+-3 15 -53 0
+29 41 93 0
+-14 88 -90 0
+-91 -70 -19 0
+-88 58 -1 0
+-85 -48 -8 0
+99 -61 29 0
+91 67 -5 0
+75 -14 -13 0
+26 -28 68 0
+-92 -9 -30 0
+-61 -66 59 0
+30 -60 2 0
+29 -39 59 0
+-9 3 56 0
+99 -2 -25 0
+-26 24 57 0
+19 -42 85 0
+65 5 -89 0
+52 55 -68 0
+24 -29 80 0
+-40 -82 -66 0
+22 84 -20 0
+56 -68 100 0
+-10 43 99 0
+55 74 58 0
+77 -62 -96 0
+21 -80 44 0
+36 -42 15 0
+-80 -95 -48 0
+-8 -27 -71 0
+-80 -38 54 0
+-36 100 -91 0
+27 75 18 0
+-47 -90 -98 0
+-92 76 -97 0
+56 -21 -95 0
+21 33 74 0
+88 -39 -89 0
+9 27 -88 0
+-77 -13 -31 0
+30 -94 -24 0
+-60 22 -72 0
+-59 -73 -75 0
+-73 -79 60 0
+57 -12 47 0
+-59 -16 12 0
+-81 -14 -23 0
+39 43 -28 0
+85 -80 -59 0
+60 16 -70 0
+25 -3 72 0
+-37 66 40 0
+15 -57 -67 0
+-23 54 82 0
+-58 -28 -9 0
+89 -74 -36 0
+62 25 1 0
+-35 -100 -93 0
+-1 22 20 0
+22 78 59 0
+95 -30 -4 0
+-92 16 88 0
+18 71 -30 0
+-76 49 20 0
+-26 -53 -17 0
+14 77 88 0
+-80 -98 -58 0
+98 8 64 0
+26 -92 -61 0
+-84 -12 44 0
+58 9 3 0
+87 -6 -8 0
+38 -70 5 0
+-14 -22 -13 0
+65 50 10 0
+34 -6 14 0
+-46 -38 45 0
+-51 20 -87 0
+-77 34 -6 0
+-88 -72 -22 0
+2 14 77 0
+-54 96 64 0
+16 -100 -65 0
+-86 32 19 0
+-64 9 -98 0
+56 8 91 0
+58 -77 -37 0
+68 -91 85 0
+17 -79 -71 0
+-61 34 1 0
+36 74 15 0
+68 -63 -13 0
+-89 -52 -79 0
+-13 100 50 0
+-75 -96 -53 0
+-82 90 45 0
+33 -85 -12 0
+34 77 49 0
+82 63 -32 0
+50 -20 63 0
+73 -77 6 0
+-67 -5 -7 0
+75 -84 72 0
+-55 77 84 0
+53 -58 49 0
+31 33 -21 0
+-59 -16 99 0
+61 -68 32 0
+54 44 4 0
+67 -83 68 0
+-59 -28 60 0
+-73 -23 25 0
+%
+0
+

benchmarks/uf100/uf100-032.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -3 54 12 0
+-14 -37 79 0
+4 -89 62 0
+60 85 10 0
+-17 7 30 0
+-43 -28 -64 0
+-79 -4 37 0
+65 66 91 0
+29 71 -31 0
+88 32 86 0
+-28 66 38 0
+91 -99 -32 0
+28 20 -60 0
+-64 76 -41 0
+-73 2 87 0
+68 46 -76 0
+-34 -27 94 0
+60 -81 68 0
+89 -63 90 0
+-84 -30 5 0
+-80 -56 69 0
+50 -94 -33 0
+-91 19 -67 0
+-73 -27 -29 0
+-66 39 16 0
+-94 88 59 0
+68 92 -13 0
+-86 -26 91 0
+17 57 55 0
+31 -86 -49 0
+49 -45 7 0
+79 -39 14 0
+1 16 -23 0
+-84 78 -100 0
+-42 54 -41 0
+44 10 -100 0
+10 -74 57 0
+-62 85 -36 0
+-65 -97 -46 0
+-49 32 8 0
+-78 75 -20 0
+56 15 29 0
+-32 -100 98 0
+-35 50 -9 0
+35 -62 -31 0
+-52 29 36 0
+-27 -61 -56 0
+-69 -4 -94 0
+-78 -6 28 0
+85 -20 -2 0
+76 -14 -80 0
+51 -13 47 0
+-100 37 -23 0
+-71 -81 -99 0
+38 -51 -5 0
+-91 -41 -80 0
+56 3 78 0
+21 8 -83 0
+36 -72 67 0
+19 7 84 0
+-89 37 90 0
+33 -63 -43 0
+55 86 -59 0
+-23 -64 -31 0
+22 16 -6 0
+55 -27 -88 0
+85 27 58 0
+78 91 7 0
+96 51 -98 0
+26 -61 11 0
+-83 -20 -75 0
+65 -48 95 0
+-44 -53 22 0
+-86 85 100 0
+-78 -37 -99 0
+37 52 84 0
+-80 87 -95 0
+5 52 21 0
+-76 -88 94 0
+14 48 43 0
+-77 -73 -62 0
+8 63 -70 0
+-71 -41 30 0
+-1 42 -19 0
+100 31 -37 0
+53 -21 45 0
+-98 -89 91 0
+-45 -61 67 0
+6 53 -76 0
+-14 -47 -24 0
+-23 -41 -88 0
+-96 52 57 0
+-13 64 -8 0
+-13 -44 -12 0
+81 82 -6 0
+-72 55 -34 0
+-27 18 -39 0
+31 -16 -20 0
+98 -9 -1 0
+-69 -78 -50 0
+-67 53 -36 0
+87 39 -75 0
+82 -52 -94 0
+-59 -88 -98 0
+-28 65 -71 0
+59 5 -95 0
+91 -55 26 0
+-97 28 -98 0
+57 5 -85 0
+44 67 49 0
+-80 9 7 0
+-26 3 -77 0
+-55 15 -81 0
+39 -70 3 0
+2 -30 -71 0
+-52 32 -85 0
+-80 -31 100 0
+-9 -36 33 0
+-87 26 16 0
+-94 51 -32 0
+40 52 14 0
+21 88 49 0
+-38 53 -65 0
+16 28 78 0
+-34 -10 -77 0
+-48 14 29 0
+81 -57 -25 0
+59 -14 -22 0
+-76 100 90 0
+-81 65 -17 0
+-34 77 4 0
+99 19 -97 0
+92 7 -88 0
+-75 -6 71 0
+-72 -39 -67 0
+-78 -30 73 0
+22 90 -30 0
+-92 3 84 0
+50 -91 -19 0
+-23 27 16 0
+-86 -92 41 0
+-70 95 20 0
+-76 -5 35 0
+-72 -33 -40 0
+-67 -75 21 0
+94 50 -27 0
+-65 -77 95 0
+-16 51 -12 0
+1 -82 -27 0
+-35 38 54 0
+91 14 -67 0
+17 -12 51 0
+19 -12 -77 0
+24 63 67 0
+-29 -38 -76 0
+-99 84 -10 0
+-39 17 -69 0
+-16 -46 77 0
+78 99 2 0
+-83 -77 42 0
+-54 57 18 0
+-21 61 -35 0
+54 -65 -9 0
+-69 -34 82 0
+74 61 -7 0
+-49 72 21 0
+85 57 -2 0
+-82 99 -16 0
+-74 -98 -7 0
+-86 -40 -45 0
+-57 -3 -35 0
+19 -54 -27 0
+-71 55 -72 0
+-60 -18 -97 0
+-51 -59 -4 0
+-58 -8 61 0
+-64 3 -83 0
+63 -94 -11 0
+34 40 73 0
+-94 55 -4 0
+54 8 61 0
+44 -64 -48 0
+-82 17 64 0
+47 -83 -19 0
+6 -42 67 0
+-56 -100 82 0
+13 64 74 0
+20 -34 -8 0
+-58 -67 33 0
+40 -85 -62 0
+26 43 -53 0
+34 -24 16 0
+-52 -82 -67 0
+9 51 -17 0
+62 -67 -81 0
+76 98 10 0
+-80 39 45 0
+-27 -97 -88 0
+-44 64 -32 0
+57 -66 -25 0
+5 -64 -94 0
+-36 -71 -38 0
+-87 -92 80 0
+-55 -29 98 0
+-44 -45 -69 0
+-65 87 21 0
+-58 37 82 0
+-78 -3 38 0
+-91 31 50 0
+-92 60 -83 0
+18 -93 -51 0
+50 8 88 0
+78 80 -6 0
+-37 27 13 0
+24 -7 89 0
+71 85 -9 0
+-72 73 -68 0
+-64 -82 -50 0
+-51 33 12 0
+-92 42 34 0
+96 18 86 0
+64 -10 -81 0
+-2 33 -66 0
+36 53 95 0
+74 -7 55 0
+-9 -82 -19 0
+-2 -50 67 0
+66 83 -68 0
+-94 69 22 0
+-2 -90 44 0
+-57 -6 -11 0
+-32 -2 46 0
+33 -49 10 0
+-71 -75 12 0
+-29 65 18 0
+2 -76 21 0
+-8 -83 22 0
+-81 13 53 0
+33 -84 -8 0
+-72 -4 -35 0
+4 -78 -30 0
+-46 -98 63 0
+72 32 -54 0
+-58 -53 51 0
+-35 -68 29 0
+-24 -60 -83 0
+-33 -30 70 0
+-37 -68 -52 0
+58 49 25 0
+-33 48 89 0
+67 -41 -5 0
+-21 26 18 0
+-10 58 -81 0
+-33 7 20 0
+-79 48 -80 0
+11 76 37 0
+4 45 -56 0
+35 44 -34 0
+86 -38 89 0
+38 73 -50 0
+14 -50 -34 0
+80 -68 3 0
+11 23 -81 0
+26 24 23 0
+-18 -66 89 0
+-26 96 78 0
+18 -25 -10 0
+57 69 -22 0
+23 -39 82 0
+-62 71 -76 0
+-78 64 -54 0
+97 -41 -24 0
+6 -17 -52 0
+-85 76 -3 0
+-77 81 -26 0
+-11 -9 27 0
+-64 -61 90 0
+70 -72 65 0
+-86 84 93 0
+-44 -27 94 0
+-34 -90 -33 0
+-9 18 57 0
+47 -75 -95 0
+29 -82 77 0
+34 -14 53 0
+-52 -17 -20 0
+81 -85 -91 0
+-60 29 -70 0
+48 -69 47 0
+50 -24 30 0
+-33 -3 31 0
+26 67 -92 0
+-12 64 2 0
+-47 -66 -10 0
+9 39 -23 0
+-53 73 -76 0
+-89 -51 30 0
+-54 -79 96 0
+96 -7 -79 0
+4 8 6 0
+-99 -100 19 0
+-37 -71 -95 0
+-98 -4 41 0
+-7 55 -85 0
+-63 -14 57 0
+-88 60 -21 0
+-98 -12 59 0
+-61 66 -60 0
+61 79 -67 0
+-97 -1 86 0
+-56 77 6 0
+-41 -36 58 0
+-18 59 86 0
+38 74 89 0
+-77 -14 27 0
+9 -23 92 0
+60 39 -65 0
+38 55 22 0
+34 -70 9 0
+-49 51 40 0
+-91 22 29 0
+-13 96 66 0
+-40 -51 -57 0
+97 9 59 0
+-31 -79 -84 0
+78 46 -19 0
+-34 41 -49 0
+-1 58 -13 0
+46 16 95 0
+37 51 -5 0
+17 99 4 0
+89 38 -73 0
+99 -37 -47 0
+-98 41 82 0
+18 82 -53 0
+-81 -18 -72 0
+-16 -42 14 0
+78 -77 -87 0
+-90 -84 -22 0
+72 94 47 0
+-98 -95 66 0
+-46 -95 59 0
+-9 -61 -13 0
+-77 75 -84 0
+64 17 -52 0
+58 38 62 0
+-41 53 35 0
+37 21 -79 0
+49 -93 -37 0
+91 -54 98 0
+-10 21 -77 0
+11 -84 36 0
+64 -19 -67 0
+4 16 -76 0
+22 -39 -19 0
+58 -91 3 0
+-18 72 29 0
+-100 81 -30 0
+49 -27 -13 0
+90 89 -100 0
+-90 -66 71 0
+-38 -17 3 0
+77 69 1 0
+3 84 50 0
+-76 97 5 0
+56 -95 -79 0
+-57 -24 -95 0
+-80 -66 -33 0
+-4 -74 -50 0
+-70 65 -54 0
+-88 95 53 0
+44 77 -63 0
+3 -15 -17 0
+1 -98 61 0
+-7 -21 -14 0
+-18 82 -48 0
+-9 91 -43 0
+24 -32 -93 0
+-28 67 85 0
+37 -23 56 0
+3 -100 -32 0
+-17 78 -69 0
+38 72 -30 0
+17 39 -63 0
+-38 63 -2 0
+-43 -15 -83 0
+52 81 -29 0
+19 77 -49 0
+44 23 99 0
+-84 -62 88 0
+-69 -97 -15 0
+3 23 -60 0
+-8 62 -75 0
+17 -52 4 0
+41 90 29 0
+95 40 44 0
+-48 -33 -82 0
+86 37 55 0
+-59 -97 -39 0
+14 95 -57 0
+70 -15 40 0
+36 -8 -83 0
+-97 72 95 0
+87 72 -36 0
+93 -59 84 0
+-49 -70 -19 0
+39 19 -86 0
+-79 -32 -45 0
+12 -69 -30 0
+38 87 34 0
+25 -84 -3 0
+21 11 4 0
+79 -10 -70 0
+81 94 22 0
+86 -79 3 0
+-52 -23 -22 0
+41 -86 4 0
+-83 -71 44 0
+5 -74 -19 0
+41 -69 38 0
+81 -40 59 0
+-95 -35 10 0
+-33 61 -72 0
+1 17 38 0
+79 83 -90 0
+53 6 17 0
+36 -2 45 0
+46 32 -84 0
+81 9 -13 0
+39 7 -37 0
+%
+0
+

benchmarks/uf100/uf100-033.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -22 -46 66 0
+-68 58 -47 0
+-39 -34 -68 0
+69 -34 -40 0
+-2 -70 -47 0
+77 -79 29 0
+92 41 83 0
+-18 55 62 0
+76 -85 50 0
+-69 -95 -15 0
+-28 30 -27 0
+-60 -44 -34 0
+-15 14 23 0
+-76 14 89 0
+-59 -2 -9 0
+-72 80 -91 0
+-50 9 -38 0
+-45 21 10 0
+-7 -95 -52 0
+10 44 61 0
+-78 -89 93 0
+-62 36 -50 0
+95 64 -76 0
+-43 38 -90 0
+53 -43 20 0
+26 38 -18 0
+-68 -47 -8 0
+-62 -29 38 0
+8 97 -23 0
+-54 72 -18 0
+92 -70 -79 0
+-69 44 37 0
+-40 71 -31 0
+11 44 87 0
+31 -99 89 0
+-2 -57 -91 0
+71 35 10 0
+10 50 91 0
+31 -38 71 0
+34 2 -13 0
+43 51 -34 0
+99 2 34 0
+29 -19 95 0
+46 89 59 0
+31 -39 -30 0
+-21 3 -30 0
+-54 34 -63 0
+32 -71 90 0
+47 35 38 0
+-34 81 82 0
+-42 -45 72 0
+52 -14 -95 0
+-70 27 56 0
+42 -51 -47 0
+81 66 -44 0
+49 53 -57 0
+99 47 84 0
+7 30 4 0
+-43 -96 49 0
+70 -76 99 0
+-99 -29 -59 0
+45 75 38 0
+-76 18 70 0
+88 61 10 0
+-69 19 -81 0
+73 -30 -90 0
+-22 -29 -41 0
+-99 32 -70 0
+-84 100 -49 0
+-99 -5 18 0
+40 -45 -79 0
+95 -98 92 0
+-87 55 -80 0
+-45 -7 91 0
+92 -98 32 0
+58 17 48 0
+-98 -40 -20 0
+38 61 -31 0
+-9 -62 -61 0
+-26 -47 58 0
+60 13 -51 0
+29 46 35 0
+-24 -72 -71 0
+-9 -97 50 0
+-29 -21 51 0
+-21 37 -19 0
+66 72 11 0
+-10 -44 18 0
+67 -6 -3 0
+-20 -3 -19 0
+-77 -9 -32 0
+60 -45 71 0
+55 8 33 0
+1 -12 41 0
+36 -89 -57 0
+-83 -87 -84 0
+36 -11 -2 0
+-22 9 -74 0
+-92 -43 -33 0
+-94 67 -28 0
+-83 -31 63 0
+95 -6 -21 0
+-22 70 61 0
+-68 55 32 0
+-70 7 76 0
+76 88 50 0
+-57 41 51 0
+64 -81 -25 0
+6 -47 96 0
+-75 -65 -80 0
+48 -59 85 0
+-46 -44 -20 0
+-51 36 -8 0
+96 75 -68 0
+75 -99 -52 0
+-94 28 -99 0
+21 -79 -35 0
+23 17 -26 0
+2 -29 70 0
+77 61 93 0
+-17 -58 41 0
+-16 69 -67 0
+78 -51 83 0
+-10 -59 66 0
+20 -37 88 0
+-55 -76 -75 0
+-28 87 -33 0
+51 19 -18 0
+70 36 -33 0
+62 34 -29 0
+67 -100 64 0
+6 22 -20 0
+4 -67 80 0
+96 69 -42 0
+21 66 89 0
+-37 82 33 0
+-34 -28 -49 0
+-14 -70 31 0
+100 86 99 0
+-96 -34 -68 0
+-18 20 -65 0
+78 53 -15 0
+91 20 50 0
+-52 -12 25 0
+53 49 -73 0
+-3 51 -75 0
+-54 79 -46 0
+-49 96 -71 0
+-38 69 95 0
+-1 -71 96 0
+29 -94 -79 0
+98 -15 -59 0
+-94 32 -60 0
+47 68 -44 0
+-90 31 33 0
+-13 33 -18 0
+72 -34 -93 0
+-93 70 8 0
+-28 81 5 0
+-35 -12 -65 0
+91 10 2 0
+-87 72 71 0
+-57 95 17 0
+2 75 -31 0
+41 81 -65 0
+-74 39 -71 0
+-13 34 43 0
+30 70 -39 0
+96 36 59 0
+79 -83 86 0
+-5 62 71 0
+-46 49 -51 0
+34 -62 -72 0
+3 16 29 0
+27 6 -51 0
+76 9 -31 0
+-61 76 -65 0
+-54 74 70 0
+-63 -43 -41 0
+99 13 67 0
+5 2 13 0
+-11 -75 -14 0
+73 -21 -27 0
+68 44 -10 0
+69 -33 8 0
+-40 86 36 0
+89 31 -23 0
+-56 78 -10 0
+-50 -87 -34 0
+-55 -63 -1 0
+96 -37 -69 0
+80 -77 19 0
+91 35 2 0
+91 67 7 0
+-92 80 -63 0
+75 -37 -98 0
+-32 47 63 0
+-74 40 -77 0
+96 -30 -60 0
+-2 46 64 0
+26 -13 42 0
+-8 88 57 0
+-12 -44 -89 0
+-82 -13 42 0
+85 11 -90 0
+-75 61 37 0
+5 2 -75 0
+54 50 -76 0
+23 46 99 0
+90 -22 15 0
+14 31 -46 0
+-16 -52 -93 0
+-78 -47 -49 0
+10 27 9 0
+5 59 -48 0
+-58 59 -3 0
+-84 57 -87 0
+52 -97 34 0
+14 93 -42 0
+55 -12 -38 0
+-60 -12 25 0
+56 64 86 0
+-28 -89 32 0
+76 6 7 0
+97 -82 -25 0
+1 43 -91 0
+55 61 -34 0
+76 -31 -60 0
+21 -67 -58 0
+-42 82 67 0
+46 17 -93 0
+7 96 -59 0
+11 -92 71 0
+-39 50 -81 0
+-8 16 -32 0
+-20 -49 -74 0
+63 87 -30 0
+-14 -33 -83 0
+-6 -89 15 0
+-51 63 -64 0
+64 56 44 0
+9 -74 21 0
+29 -90 75 0
+-76 -78 -14 0
+38 -14 -31 0
+97 -60 23 0
+-75 6 -9 0
+37 -72 75 0
+-37 58 -25 0
+19 -86 -2 0
+16 83 -57 0
+-73 -98 59 0
+66 30 -74 0
+86 77 -15 0
+-99 -46 47 0
+-98 10 17 0
+-8 21 38 0
+69 66 -60 0
+99 91 77 0
+76 -100 49 0
+-56 -97 53 0
+12 59 21 0
+80 95 -88 0
+39 36 -84 0
+-19 24 -85 0
+-11 -2 81 0
+-64 85 91 0
+-6 -14 11 0
+-87 90 83 0
+-55 24 40 0
+-1 -3 4 0
+28 -62 27 0
+18 -9 54 0
+-97 -50 83 0
+-22 -78 -69 0
+-84 69 73 0
+23 -61 10 0
+92 90 -13 0
+45 -98 -23 0
+41 85 54 0
+-78 29 91 0
+99 -38 -84 0
+13 78 45 0
+98 -68 42 0
+97 36 91 0
+-72 -23 -64 0
+-86 -71 16 0
+-25 91 80 0
+-15 13 -71 0
+-62 -29 1 0
+-88 50 68 0
+29 -98 -10 0
+47 -93 -79 0
+-29 77 6 0
+-65 94 66 0
+-10 -33 94 0
+16 -12 -4 0
+-14 3 64 0
+-86 -58 2 0
+-30 -21 -29 0
+39 -96 -7 0
+39 88 -2 0
+-13 28 -61 0
+2 -5 47 0
+-38 25 24 0
+40 -59 -5 0
+36 -30 -65 0
+-96 -85 6 0
+-46 -63 29 0
+96 -4 -50 0
+29 -10 28 0
+-9 92 49 0
+-51 -25 -5 0
+81 27 -28 0
+-34 15 -97 0
+-52 -62 77 0
+100 -3 -24 0
+-69 -27 -77 0
+-38 -63 85 0
+-58 -6 -18 0
+-21 41 14 0
+-29 -20 -11 0
+-5 37 -14 0
+39 47 59 0
+26 69 36 0
+95 44 -65 0
+17 70 -5 0
+14 26 9 0
+-23 -45 -65 0
+12 92 -43 0
+72 30 9 0
+22 -55 19 0
+100 96 -65 0
+-27 46 -15 0
+65 -39 73 0
+-74 -59 -38 0
+32 18 31 0
+-90 -44 8 0
+25 -78 77 0
+-21 33 43 0
+1 -14 -88 0
+14 -28 100 0
+-57 67 88 0
+-96 -46 -17 0
+76 -5 -17 0
+48 99 -71 0
+19 -50 -94 0
+62 51 -38 0
+88 -11 -4 0
+89 -59 -94 0
+62 -25 90 0
+-99 -79 -76 0
+63 59 21 0
+-59 -96 47 0
+-52 -88 45 0
+-54 90 -26 0
+-85 28 -26 0
+40 -82 -16 0
+-99 -85 97 0
+-12 -71 -13 0
+93 18 67 0
+-69 -89 -43 0
+90 5 48 0
+-56 43 21 0
+-79 -16 75 0
+69 -66 -55 0
+-50 52 47 0
+59 35 -16 0
+-42 96 4 0
+66 27 -23 0
+78 87 61 0
+91 -71 95 0
+-49 22 75 0
+25 69 -10 0
+-36 96 84 0
+54 14 88 0
+-58 -38 79 0
+-93 -23 -64 0
+-81 13 -59 0
+48 77 85 0
+33 89 -35 0
+29 61 -18 0
+50 -5 15 0
+-2 53 -14 0
+49 91 -31 0
+-54 -89 74 0
+17 -87 -9 0
+35 -94 -70 0
+59 -9 -32 0
+91 -93 -15 0
+66 -12 57 0
+41 85 -12 0
+-7 -49 -84 0
+-49 13 87 0
+-62 5 -42 0
+-44 83 -12 0
+25 63 -65 0
+27 -19 -28 0
+-88 44 95 0
+-23 -85 13 0
+-64 4 13 0
+55 -28 97 0
+97 -90 26 0
+6 -87 -64 0
+9 83 72 0
+-52 -11 35 0
+-98 -40 65 0
+2 -55 17 0
+48 -85 -3 0
+-98 95 -45 0
+2 -68 -37 0
+29 -28 -39 0
+23 41 -83 0
+97 -5 -1 0
+-5 -84 -8 0
+76 -67 -100 0
+86 27 15 0
+-90 72 -41 0
+-71 18 -65 0
+34 30 38 0
+39 -80 5 0
+26 -77 -29 0
+-41 -89 -48 0
+42 31 86 0
+-60 -36 40 0
+35 -15 23 0
+-41 80 -91 0
+-46 61 79 0
+61 -83 -70 0
+-57 49 -7 0
+%
+0
+

benchmarks/uf100/uf100-034.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 46 -18 82 0
+-98 -2 73 0
+-85 17 10 0
+-39 68 7 0
+-51 99 83 0
+-7 88 62 0
+-100 4 30 0
+9 -85 -27 0
+24 -15 -33 0
+59 38 72 0
+86 -12 2 0
+76 -100 11 0
+15 -80 -96 0
+5 -22 -86 0
+-10 11 -81 0
+-37 27 96 0
+-60 -25 13 0
+80 -76 -20 0
+-25 94 76 0
+-71 55 -59 0
+45 43 1 0
+-42 -87 51 0
+-79 30 -21 0
+-89 75 87 0
+-14 -7 -87 0
+46 2 -34 0
+72 84 -46 0
+-67 17 -27 0
+-81 -4 -51 0
+-100 -81 93 0
+77 99 -51 0
+70 16 76 0
+13 -4 30 0
+-16 72 48 0
+53 39 96 0
+94 100 -47 0
+36 -80 6 0
+-24 8 46 0
+98 63 8 0
+-60 81 85 0
+3 -19 8 0
+41 -98 -47 0
+-33 1 -35 0
+84 10 78 0
+87 19 10 0
+-45 63 26 0
+-34 23 41 0
+69 -65 -34 0
+-73 -35 91 0
+-76 -49 85 0
+35 -55 -28 0
+63 2 12 0
+12 97 -79 0
+87 82 -51 0
+-13 -93 29 0
+1 18 -75 0
+100 -9 -55 0
+56 -62 84 0
+95 -63 -12 0
+-26 13 48 0
+75 11 -48 0
+2 -38 56 0
+5 -15 -26 0
+-34 -53 69 0
+-6 -65 71 0
+-34 85 48 0
+84 61 -43 0
+83 -13 -9 0
+65 -86 52 0
+56 71 68 0
+-26 64 27 0
+-15 -29 10 0
+-52 -51 -31 0
+60 -23 69 0
+-14 11 4 0
+-24 63 97 0
+100 51 70 0
+-27 59 90 0
+41 -78 71 0
+42 -3 -37 0
+-78 -8 -36 0
+-15 -57 22 0
+24 -93 87 0
+61 -91 -83 0
+-57 -40 -74 0
+67 63 65 0
+-73 51 79 0
+22 -60 -37 0
+-13 -32 -77 0
+66 20 -16 0
+-97 -79 -63 0
+-83 53 -50 0
+5 -67 44 0
+27 -87 48 0
+-79 -48 30 0
+-94 84 21 0
+-54 -27 -3 0
+93 67 32 0
+-60 28 94 0
+41 57 -33 0
+-28 -27 -96 0
+36 -98 51 0
+-26 78 -16 0
+-4 69 -84 0
+1 72 -49 0
+9 33 -18 0
+-1 -51 -86 0
+1 -16 -48 0
+-73 -76 -26 0
+-49 74 28 0
+88 16 -66 0
+-93 -21 31 0
+-49 -72 35 0
+-54 62 -83 0
+-36 -67 30 0
+-97 -51 -53 0
+-42 49 -92 0
+93 -76 35 0
+35 25 85 0
+73 40 69 0
+-39 -1 82 0
+-63 -5 86 0
+-18 -70 -87 0
+-76 31 -83 0
+64 20 27 0
+64 -61 -31 0
+-83 -14 -97 0
+-80 85 43 0
+25 -13 70 0
+-94 -37 -21 0
+-32 -19 -81 0
+61 -83 71 0
+-9 -36 87 0
+100 -85 95 0
+1 -95 49 0
+-72 -95 -25 0
+-27 -32 77 0
+41 69 63 0
+52 43 -20 0
+58 -51 72 0
+13 -44 30 0
+32 22 -34 0
+-36 -59 62 0
+-33 -38 -48 0
+30 42 48 0
+-36 -60 -62 0
+-67 28 -80 0
+-93 -72 56 0
+59 -2 -79 0
+-4 -83 -51 0
+-20 10 -32 0
+51 -35 -68 0
+-43 42 -21 0
+-56 -13 41 0
+66 48 -5 0
+86 51 -65 0
+6 -86 74 0
+-78 19 59 0
+-29 42 -61 0
+-56 -55 68 0
+-57 -36 -88 0
+-79 -56 65 0
+90 69 -60 0
+70 -72 30 0
+-93 -18 -91 0
+-83 46 -11 0
+-29 98 38 0
+-35 -40 97 0
+83 -58 -11 0
+48 80 -91 0
+14 -23 25 0
+5 22 -42 0
+-71 50 32 0
+7 26 -77 0
+-90 85 -44 0
+-60 -36 -6 0
+-29 65 20 0
+-62 77 84 0
+-12 -51 -52 0
+-52 58 -73 0
+-79 -98 -32 0
+83 -10 -55 0
+36 42 -39 0
+-46 47 -33 0
+-86 -87 -58 0
+-54 61 -93 0
+75 27 -84 0
+92 -64 5 0
+12 29 86 0
+44 -10 -7 0
+-97 22 -48 0
+62 81 20 0
+8 2 -12 0
+52 -43 23 0
+57 31 -63 0
+28 -46 -99 0
+77 32 -11 0
+29 -45 -69 0
+93 19 86 0
+86 -35 90 0
+-100 93 60 0
+-90 85 -43 0
+57 -35 30 0
+-89 -68 23 0
+-7 83 63 0
+-11 31 21 0
+81 18 13 0
+10 -73 54 0
+-44 -88 -97 0
+-95 -68 75 0
+84 74 -36 0
+33 25 -82 0
+65 -58 -72 0
+47 41 57 0
+35 -1 86 0
+-15 41 -24 0
+-16 78 92 0
+-96 88 -98 0
+-36 -51 34 0
+-10 28 -42 0
+-45 53 -40 0
+35 19 -63 0
+-66 -11 -73 0
+-58 12 29 0
+-32 14 -50 0
+73 53 39 0
+-97 -55 -60 0
+45 47 -85 0
+96 -68 -73 0
+-46 -91 -90 0
+82 37 -51 0
+62 45 27 0
+-96 -48 -55 0
+42 -60 -33 0
+-91 30 82 0
+78 7 83 0
+1 88 -77 0
+-35 -5 -28 0
+-54 26 53 0
+-77 30 -66 0
+-5 88 97 0
+-19 17 11 0
+75 -78 24 0
+95 20 -34 0
+84 82 4 0
+40 45 1 0
+-59 50 -35 0
+88 20 56 0
+-19 -16 43 0
+26 -47 -29 0
+42 -36 13 0
+-60 -30 94 0
+72 -85 -58 0
+-51 -14 -95 0
+-40 91 -4 0
+38 61 35 0
+-94 -63 35 0
+-25 -28 17 0
+-61 -6 -26 0
+12 38 83 0
+15 -44 -63 0
+-55 -87 -28 0
+22 -98 -12 0
+-51 -40 -73 0
+68 6 9 0
+51 -36 -58 0
+79 40 37 0
+90 -50 -7 0
+69 38 26 0
+12 82 26 0
+-35 -83 -82 0
+-43 -74 5 0
+-88 -70 -82 0
+81 -40 7 0
+-26 93 3 0
+-98 47 16 0
+44 -81 -85 0
+-82 47 34 0
+33 21 44 0
+-60 53 16 0
+96 -2 75 0
+22 -24 -94 0
+71 54 99 0
+-8 -49 -60 0
+-75 48 40 0
+-19 5 45 0
+7 38 47 0
+-53 14 -73 0
+90 -26 38 0
+-36 52 -74 0
+-18 -61 87 0
+86 -61 -40 0
+52 -14 97 0
+13 54 40 0
+76 38 68 0
+-31 70 18 0
+79 85 59 0
+-63 60 -38 0
+99 -79 93 0
+-24 20 -76 0
+3 -62 -55 0
+-40 33 64 0
+-39 -7 -70 0
+30 92 -73 0
+30 65 73 0
+91 -39 66 0
+-25 -98 -52 0
+-99 34 -2 0
+63 -40 87 0
+-90 -91 92 0
+67 88 -32 0
+58 22 -4 0
+45 -51 -1 0
+77 -1 83 0
+-1 53 2 0
+-29 -36 96 0
+13 -27 -42 0
+16 18 -9 0
+-12 7 71 0
+5 -19 85 0
+36 -11 70 0
+-51 -84 65 0
+-50 15 -55 0
+-29 43 92 0
+32 42 28 0
+49 84 -20 0
+57 -65 -74 0
+58 -6 88 0
+-97 -93 -61 0
+98 23 -40 0
+-35 88 -71 0
+45 -62 49 0
+-92 -40 -11 0
+-97 49 -67 0
+-55 -34 81 0
+-81 94 7 0
+-37 93 -73 0
+91 -3 95 0
+75 78 95 0
+-100 -90 65 0
+100 65 -18 0
+-17 53 -58 0
+45 28 -71 0
+-85 4 -30 0
+-10 45 55 0
+98 25 2 0
+81 47 70 0
+-7 81 -35 0
+-30 -3 67 0
+-24 -91 -57 0
+15 -62 7 0
+33 -57 83 0
+9 -2 99 0
+-7 -9 20 0
+86 -91 -92 0
+24 -84 -18 0
+66 33 52 0
+-67 -44 48 0
+83 -94 36 0
+-4 -53 -94 0
+-52 18 46 0
+64 -14 77 0
+62 -29 55 0
+-37 -77 35 0
+-75 -84 55 0
+-30 31 67 0
+-20 -65 -29 0
+-8 -42 19 0
+3 -88 -90 0
+-40 34 53 0
+43 31 -63 0
+25 28 53 0
+-28 -49 -61 0
+93 87 64 0
+-69 -79 87 0
+6 10 82 0
+-39 -72 92 0
+-88 28 -94 0
+-69 -13 -32 0
+67 37 -51 0
+35 26 -50 0
+-88 79 66 0
+12 26 -73 0
+74 -71 -12 0
+69 -35 7 0
+87 99 -49 0
+-30 35 69 0
+41 26 32 0
+11 5 -4 0
+-92 -78 -8 0
+-22 83 70 0
+60 49 -51 0
+-35 -84 90 0
+100 7 26 0
+-76 21 11 0
+54 42 89 0
+-39 -72 -56 0
+54 -35 -82 0
+-64 100 85 0
+23 -78 -35 0
+40 14 95 0
+-36 -75 -79 0
+-90 -18 13 0
+49 25 12 0
+-47 -37 91 0
+35 10 -64 0
+-36 74 -15 0
+55 5 -26 0
+-40 29 -8 0
+-90 -33 -35 0
+69 46 99 0
+81 -18 49 0
+100 10 -47 0
+99 65 92 0
+-61 -7 66 0
+-65 34 94 0
+97 -21 55 0
+87 -65 19 0
+-96 -88 9 0
+-22 55 -33 0
+36 -14 -33 0
+66 73 -93 0
+30 5 22 0
+-92 33 -98 0
+-26 42 -46 0
+-57 -65 -9 0
+-61 -59 -58 0
+11 -9 81 0
+43 49 -51 0
+-31 74 13 0
+%
+0
+

benchmarks/uf100/uf100-035.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 76 99 21 0
+28 53 32 0
+75 -39 -84 0
+-16 95 47 0
+92 10 62 0
+-51 24 -11 0
+98 -73 4 0
+38 -65 54 0
+-6 -99 -41 0
+87 -82 61 0
+-60 49 -33 0
+21 17 50 0
+-39 84 -5 0
+-39 -10 -85 0
+-30 -48 -57 0
+100 55 3 0
+-9 -45 -39 0
+98 -7 -68 0
+-88 38 81 0
+47 46 -90 0
+-58 -36 -39 0
+82 76 -7 0
+-4 32 -82 0
+43 -21 18 0
+-65 40 80 0
+-38 -1 52 0
+39 -42 94 0
+21 66 -58 0
+-82 79 12 0
+34 66 -44 0
+-29 56 88 0
+-98 71 -91 0
+-19 37 -17 0
+-67 20 32 0
+82 -53 98 0
+-12 -95 72 0
+48 -73 -74 0
+89 -82 -27 0
+-59 25 84 0
+23 83 56 0
+36 19 -16 0
+-11 65 63 0
+75 -91 -9 0
+65 55 -91 0
+51 -66 -75 0
+28 21 100 0
+-34 39 -82 0
+24 -97 -75 0
+-98 62 -25 0
+-80 -61 34 0
+35 95 -40 0
+53 -72 6 0
+-18 92 26 0
+-63 22 -85 0
+-55 89 54 0
+8 78 -14 0
+15 -65 -23 0
+-49 17 82 0
+-97 -71 27 0
+75 -12 -25 0
+-48 -7 -45 0
+13 -68 22 0
+27 37 36 0
+14 -8 -15 0
+-75 -64 -84 0
+67 39 90 0
+-68 14 -11 0
+9 -75 35 0
+90 97 53 0
+-76 11 -5 0
+42 -76 34 0
+-74 55 -48 0
+82 -53 -71 0
+61 -86 -50 0
+-55 66 96 0
+-55 -67 -81 0
+-23 -71 -22 0
+66 -35 18 0
+90 12 -100 0
+24 80 -56 0
+25 -94 48 0
+-73 -4 -16 0
+-60 -39 -4 0
+-91 64 -67 0
+81 27 72 0
+-18 -70 -4 0
+10 48 -89 0
+-94 -2 -1 0
+53 -69 39 0
+-10 -40 67 0
+-92 -94 -83 0
+-81 -68 5 0
+32 -86 49 0
+7 -36 -96 0
+-86 63 -95 0
+65 36 47 0
+-11 -90 -9 0
+12 67 4 0
+-50 85 -26 0
+81 2 75 0
+98 81 10 0
+48 22 57 0
+-13 70 16 0
+6 5 71 0
+81 -44 -24 0
+-11 -70 79 0
+-3 2 32 0
+-72 -16 5 0
+32 -78 -29 0
+-52 -60 15 0
+45 84 -72 0
+-34 42 -53 0
+1 -73 72 0
+-29 -91 -21 0
+28 44 59 0
+45 -63 -16 0
+68 -20 -96 0
+77 -86 69 0
+91 -19 18 0
+-11 2 -53 0
+1 87 34 0
+-71 39 -66 0
+68 -10 -32 0
+6 -18 -77 0
+-28 94 39 0
+98 24 -43 0
+84 -97 1 0
+12 -55 34 0
+-2 -75 50 0
+64 19 -35 0
+-11 14 95 0
+15 -12 18 0
+-40 73 59 0
+-6 -18 -3 0
+97 -60 13 0
+-2 73 -42 0
+18 -41 81 0
+-39 -96 15 0
+26 75 48 0
+22 -26 -4 0
+62 -58 -38 0
+-71 72 -4 0
+93 45 55 0
+-37 -69 97 0
+29 -18 52 0
+97 12 65 0
+-97 85 -91 0
+59 29 -41 0
+37 -72 51 0
+60 84 64 0
+-18 12 26 0
+-1 42 -24 0
+87 1 88 0
+-9 -51 94 0
+-6 -44 34 0
+84 -71 61 0
+-48 54 -49 0
+32 -31 91 0
+42 66 56 0
+86 -31 83 0
+68 -84 -7 0
+-36 40 -13 0
+-74 -43 87 0
+70 4 10 0
+65 25 -66 0
+-83 12 49 0
+-48 -76 -80 0
+16 -33 -34 0
+-46 -66 99 0
+-91 55 64 0
+-22 -84 -19 0
+-11 -20 -36 0
+81 -95 27 0
+9 -43 -89 0
+46 88 34 0
+16 65 -18 0
+94 46 -9 0
+-24 17 -83 0
+-74 39 22 0
+-41 -91 7 0
+9 15 27 0
+-43 95 25 0
+-95 -47 45 0
+-16 96 80 0
+-52 -22 95 0
+66 86 30 0
+57 -30 -70 0
+-23 -6 -78 0
+-86 -98 -48 0
+-87 -11 -84 0
+85 27 -40 0
+60 97 -4 0
+-12 48 -69 0
+-41 -1 48 0
+50 52 -17 0
+87 18 4 0
+100 92 -42 0
+66 33 13 0
+85 63 -28 0
+-39 100 -46 0
+32 18 97 0
+80 44 20 0
+-87 12 -74 0
+-27 -31 58 0
+-49 -1 7 0
+-74 87 -56 0
+98 2 -42 0
+57 10 100 0
+-26 -36 76 0
+91 -39 97 0
+-7 81 -91 0
+-73 5 32 0
+-46 36 -19 0
+-2 -80 -40 0
+-75 10 17 0
+-6 49 -91 0
+85 -97 98 0
+-36 32 60 0
+-19 -10 -85 0
+-36 68 64 0
+-62 44 -55 0
+45 25 -76 0
+66 76 94 0
+31 48 11 0
+69 -42 71 0
+-37 55 -53 0
+71 -52 -17 0
+8 -59 -33 0
+3 15 10 0
+-16 98 57 0
+95 -66 5 0
+-39 -27 -62 0
+12 -80 -14 0
+6 -83 14 0
+-32 -11 -40 0
+38 92 -35 0
+53 78 -19 0
+-70 -45 -71 0
+-82 95 35 0
+38 41 78 0
+67 -30 -81 0
+-61 -46 -90 0
+45 23 51 0
+10 5 -37 0
+43 -56 7 0
+66 -50 73 0
+18 -19 -86 0
+-87 38 -66 0
+3 76 81 0
+-72 -47 43 0
+-5 63 -55 0
+-81 -90 -79 0
+-12 40 3 0
+53 -39 -17 0
+-56 -28 -5 0
+-8 88 -58 0
+34 31 50 0
+-78 -16 -43 0
+21 -46 -18 0
+-95 35 -1 0
+-94 41 71 0
+-12 36 -50 0
+64 25 -70 0
+85 -25 -8 0
+-77 -56 -23 0
+60 -48 -97 0
+-50 -10 -34 0
+53 34 7 0
+-84 25 -35 0
+79 -3 52 0
+-56 -40 -54 0
+-51 18 61 0
+-66 69 -72 0
+-73 -29 17 0
+43 59 -63 0
+-99 78 -22 0
+-1 -64 -35 0
+50 49 31 0
+3 -12 65 0
+-31 -18 79 0
+-62 59 95 0
+-57 -9 -5 0
+-57 -43 -34 0
+-22 -67 -83 0
+-6 16 76 0
+-2 -72 94 0
+38 12 11 0
+-28 59 46 0
+33 -67 -76 0
+74 58 -77 0
+-84 44 57 0
+-79 78 23 0
+93 47 83 0
+47 -41 94 0
+-83 -30 4 0
+44 63 90 0
+11 19 7 0
+58 1 -73 0
+-68 85 -20 0
+7 90 -6 0
+56 -92 -47 0
+-74 3 6 0
+-6 94 -14 0
+-58 -1 36 0
+-54 -70 -32 0
+-44 -36 -71 0
+-77 54 65 0
+95 41 94 0
+-60 -77 -28 0
+-38 -8 59 0
+48 -10 -74 0
+81 -76 8 0
+45 -52 -82 0
+-65 20 76 0
+82 53 37 0
+-79 -69 13 0
+6 68 87 0
+54 -58 -95 0
+36 -61 -75 0
+-41 -35 -42 0
+-81 54 31 0
+-4 11 -86 0
+33 77 -55 0
+-83 -47 -11 0
+-48 -99 -98 0
+-52 57 27 0
+-100 53 -44 0
+83 75 -44 0
+-88 85 -2 0
+-62 -90 59 0
+-32 29 92 0
+92 -11 93 0
+2 79 10 0
+100 4 96 0
+62 63 27 0
+55 54 34 0
+-86 4 -55 0
+14 -40 29 0
+34 -84 48 0
+-68 -47 11 0
+100 -21 -86 0
+77 52 1 0
+82 -43 -79 0
+55 100 47 0
+-50 -97 78 0
+-94 90 65 0
+-77 99 82 0
+-17 12 55 0
+57 -76 19 0
+35 -28 44 0
+57 -82 24 0
+52 37 -45 0
+-45 30 86 0
+19 -82 -84 0
+85 19 -88 0
+-62 87 58 0
+-31 -60 -54 0
+50 39 97 0
+43 -57 -3 0
+-86 79 5 0
+49 -68 23 0
+-24 -84 -91 0
+44 8 -23 0
+-62 85 16 0
+-51 -96 -88 0
+92 18 62 0
+45 47 -99 0
+19 67 66 0
+1 70 94 0
+27 85 -99 0
+-8 32 85 0
+-84 90 -55 0
+41 -43 -45 0
+15 85 -21 0
+11 28 -39 0
+-77 50 -10 0
+70 -3 -44 0
+2 26 -10 0
+97 -47 -79 0
+72 -65 8 0
+-89 51 99 0
+-53 81 20 0
+-63 -6 -30 0
+67 -48 -8 0
+24 37 -26 0
+-81 36 -50 0
+96 -86 42 0
+19 45 51 0
+10 84 49 0
+79 -52 -51 0
+-5 63 -34 0
+-16 -38 53 0
+-3 71 -79 0
+55 29 79 0
+-17 25 57 0
+-66 -33 2 0
+65 -2 81 0
+51 61 4 0
+24 -69 -52 0
+-8 -89 -23 0
+3 21 -84 0
+48 84 73 0
+-61 -52 93 0
+88 5 74 0
+-37 -13 -33 0
+-10 79 -94 0
+-31 13 -37 0
+-20 65 -61 0
+72 -49 -40 0
+47 68 18 0
+16 23 -9 0
+-37 -57 -10 0
+-15 -34 39 0
+-71 -27 45 0
+28 -49 -47 0
+-49 15 68 0
+31 -57 69 0
+-19 -67 71 0
+61 36 -75 0
+-34 -44 -4 0
+33 -25 11 0
+-13 88 81 0
+71 -6 88 0
+-89 6 -11 0
+27 66 -69 0
+39 67 75 0
+52 61 93 0
+50 84 38 0
+-74 -100 14 0
+49 20 1 0
+%
+0
+

benchmarks/uf100/uf100-036.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 60 -54 -51 0
+-24 84 -20 0
+-64 -57 -23 0
+-20 -11 7 0
+-94 39 -47 0
+-47 -60 17 0
+-80 -6 99 0
+-55 -29 -86 0
+39 -5 -96 0
+-53 -62 25 0
+-63 -98 -85 0
+-94 -74 73 0
+21 28 -66 0
+-91 -44 55 0
+-73 42 84 0
+23 -4 32 0
+74 -76 -99 0
+85 -88 99 0
+-100 -84 48 0
+77 43 -60 0
+-63 21 -26 0
+-44 79 50 0
+75 34 20 0
+-24 -11 71 0
+55 -22 84 0
+9 -25 22 0
+84 38 4 0
+-54 3 83 0
+-97 51 -19 0
+-74 -83 -20 0
+58 -6 80 0
+-23 -38 -7 0
+-9 -69 38 0
+78 -46 -66 0
+-18 -57 -84 0
+32 -60 -71 0
+15 -22 -8 0
+77 -86 42 0
+62 -45 -82 0
+-90 -7 -12 0
+38 13 26 0
+-78 -38 47 0
+-58 -36 -10 0
+35 12 23 0
+-71 28 -19 0
+-49 38 12 0
+99 22 73 0
+-70 -64 66 0
+-57 96 -28 0
+90 -83 -93 0
+8 -13 -30 0
+55 86 97 0
+57 -1 66 0
+-39 36 23 0
+31 5 -17 0
+15 21 -95 0
+20 95 -67 0
+-19 78 -98 0
+12 39 -34 0
+-34 30 -85 0
+72 63 60 0
+-36 97 8 0
+-71 -96 -2 0
+-66 35 90 0
+-68 72 -45 0
+-19 100 -50 0
+19 52 -49 0
+31 75 -62 0
+-10 -96 92 0
+-14 63 2 0
+-46 34 30 0
+-48 -31 98 0
+64 88 76 0
+-83 29 -1 0
+5 -41 -59 0
+-36 46 8 0
+11 -90 49 0
+-9 -49 93 0
+-89 57 -40 0
+86 35 8 0
+19 77 -54 0
+-44 -52 -84 0
+-99 -68 -19 0
+2 41 -49 0
+9 -16 -15 0
+-24 78 -31 0
+-72 47 -24 0
+26 38 50 0
+-37 -30 -41 0
+-65 -80 86 0
+-35 -20 22 0
+-38 69 71 0
+-44 -50 -48 0
+94 30 -5 0
+-5 -80 -56 0
+-34 -93 -71 0
+-80 -95 -35 0
+61 -99 8 0
+-83 85 30 0
+63 24 -23 0
+68 47 74 0
+5 82 -27 0
+98 -93 -81 0
+6 -83 -57 0
+80 31 99 0
+-84 -17 -58 0
+89 -59 -42 0
+-97 96 -67 0
+49 8 -5 0
+23 -49 -80 0
+-9 -13 49 0
+-55 26 51 0
+65 20 -91 0
+-90 -29 7 0
+-75 94 -73 0
+-45 -27 82 0
+-2 47 -73 0
+-76 80 16 0
+24 10 65 0
+55 79 30 0
+-95 -77 -75 0
+-24 71 13 0
+93 -98 7 0
+46 88 37 0
+-47 -72 -19 0
+-25 -93 -27 0
+-66 -93 -67 0
+6 -82 85 0
+40 -36 77 0
+-92 25 -35 0
+-92 -16 12 0
+57 -77 -73 0
+-41 48 -46 0
+-94 74 -29 0
+86 -11 6 0
+6 -71 44 0
+-24 -18 -4 0
+57 94 -17 0
+96 41 29 0
+7 96 58 0
+-41 21 -7 0
+11 -60 86 0
+84 13 -33 0
+-56 11 21 0
+-31 -41 26 0
+25 -94 -62 0
+-100 88 59 0
+-25 -87 27 0
+-38 43 -52 0
+89 57 -27 0
+55 70 -74 0
+-15 -1 39 0
+87 -11 27 0
+55 -6 -57 0
+92 -53 -40 0
+-99 21 -55 0
+-23 52 57 0
+1 12 54 0
+-42 -79 -28 0
+81 -77 43 0
+-5 -95 -30 0
+-15 89 19 0
+-15 -50 -55 0
+90 19 59 0
+7 98 20 0
+-59 -22 -10 0
+-55 -96 65 0
+-17 81 64 0
+51 -38 -60 0
+-52 62 -74 0
+-88 -69 -13 0
+74 -11 -89 0
+52 -100 -36 0
+56 -22 -15 0
+-83 37 -64 0
+42 -16 -68 0
+12 -83 51 0
+2 66 41 0
+-73 -59 47 0
+78 72 59 0
+-97 68 -23 0
+-26 -18 77 0
+81 -69 8 0
+-47 59 -4 0
+-15 -23 -66 0
+80 60 -59 0
+-97 50 82 0
+15 7 18 0
+-68 -75 62 0
+65 -82 -29 0
+-21 36 -53 0
+44 34 -27 0
+-74 21 -59 0
+-95 -11 61 0
+-63 -47 -9 0
+85 -98 100 0
+14 21 -71 0
+92 20 98 0
+-36 -5 52 0
+24 -81 -32 0
+100 55 97 0
+-50 -52 -5 0
+81 17 79 0
+-67 -32 71 0
+86 16 17 0
+-30 97 10 0
+15 -80 48 0
+85 93 8 0
+81 51 99 0
+28 -58 89 0
+-59 -18 -28 0
+-11 97 35 0
+-88 -85 4 0
+24 80 73 0
+25 -51 -72 0
+-44 54 -77 0
+-27 -32 -56 0
+-72 -78 41 0
+97 20 -70 0
+-44 -92 56 0
+-1 -40 92 0
+-98 -93 -6 0
+30 61 3 0
+-2 31 61 0
+55 93 -94 0
+24 49 -21 0
+-65 -18 -74 0
+32 6 16 0
+76 -12 81 0
+39 37 -23 0
+14 -70 21 0
+-15 49 58 0
+-43 -52 39 0
+-8 -61 60 0
+19 -36 78 0
+12 81 -93 0
+73 29 26 0
+63 60 -97 0
+50 26 43 0
+51 -33 75 0
+52 85 23 0
+21 89 -66 0
+-92 -81 -42 0
+69 31 -84 0
+51 90 30 0
+-67 70 87 0
+-27 -34 92 0
+74 -72 -91 0
+-74 28 3 0
+-55 89 32 0
+-87 -81 19 0
+-77 -96 66 0
+-78 -62 -18 0
+40 50 5 0
+85 63 33 0
+-67 34 -26 0
+-17 -84 -91 0
+28 -30 40 0
+22 -38 -67 0
+69 -65 -36 0
+-47 48 17 0
+-68 49 -8 0
+-36 58 -90 0
+-92 24 25 0
+-32 19 -70 0
+-50 66 99 0
+-90 -6 79 0
+58 -99 -67 0
+-34 67 93 0
+62 56 -61 0
+-82 73 -47 0
+-10 29 -90 0
+-98 84 52 0
+33 64 92 0
+68 83 -71 0
+-9 -95 67 0
+39 -85 -34 0
+81 71 -44 0
+58 -66 -37 0
+64 -59 -41 0
+-29 95 49 0
+100 88 -8 0
+93 97 -51 0
+9 86 50 0
+4 98 -99 0
+98 -61 80 0
+-69 -55 17 0
+56 81 -30 0
+90 -25 -44 0
+-79 74 75 0
+62 -15 69 0
+-69 30 -78 0
+18 -60 -46 0
+5 -55 -87 0
+26 72 31 0
+-8 9 64 0
+-99 18 -53 0
+-43 -21 -18 0
+50 73 38 0
+93 46 2 0
+72 54 58 0
+58 29 25 0
+68 48 -86 0
+86 88 5 0
+14 -54 -36 0
+9 -53 43 0
+1 11 75 0
+-79 -64 -50 0
+32 86 -53 0
+71 -21 14 0
+91 66 -33 0
+8 -59 -57 0
+-98 39 -8 0
+93 24 -25 0
+100 51 99 0
+97 -73 77 0
+-12 89 -84 0
+26 -5 97 0
+-6 -59 31 0
+-87 39 14 0
+89 -20 2 0
+-30 -88 -11 0
+-24 -100 66 0
+-63 24 60 0
+9 -97 88 0
+48 -78 -53 0
+-76 27 41 0
+55 48 -35 0
+-22 -66 23 0
+-30 67 -17 0
+-37 -96 -4 0
+61 19 97 0
+1 -89 -67 0
+42 59 90 0
+-52 -84 69 0
+-9 -67 -22 0
+55 77 74 0
+2 -7 73 0
+-64 -58 -29 0
+38 58 -4 0
+25 -40 46 0
+-87 -74 97 0
+89 -99 75 0
+-74 56 -43 0
+98 -88 4 0
+-57 11 -74 0
+-77 -82 -94 0
+-52 -72 62 0
+-25 28 -95 0
+-41 -19 96 0
+16 1 -97 0
+81 -90 -88 0
+-96 35 55 0
+-92 -29 -68 0
+-78 -23 -8 0
+-96 97 98 0
+-86 83 -96 0
+57 -22 -94 0
+52 -70 26 0
+8 34 31 0
+14 -3 9 0
+18 -81 93 0
+-72 12 40 0
+-63 -75 88 0
+97 1 -77 0
+39 31 -86 0
+-59 62 -51 0
+43 27 9 0
+-70 25 -15 0
+-55 19 36 0
+-20 65 -5 0
+-26 65 -48 0
+-46 -79 90 0
+-81 56 -64 0
+-54 69 99 0
+7 70 99 0
+97 63 70 0
+7 -84 97 0
+19 25 -100 0
+-67 -7 80 0
+-62 -25 12 0
+70 -25 -86 0
+21 -48 75 0
+-53 4 69 0
+33 83 -14 0
+25 -99 -94 0
+52 -42 80 0
+29 -75 -91 0
+47 -44 -79 0
+22 28 78 0
+-4 -63 -14 0
+53 -51 -27 0
+-76 17 56 0
+42 -67 -90 0
+-14 2 -13 0
+6 40 15 0
+4 89 -63 0
+-11 -97 -68 0
+13 5 54 0
+-87 38 -36 0
+-52 -35 11 0
+79 -57 -36 0
+-93 -98 55 0
+-47 -76 21 0
+-34 -64 82 0
+-41 -16 -45 0
+99 60 55 0
+92 -94 39 0
+-63 -1 -78 0
+29 34 -18 0
+-21 -44 -97 0
+64 94 38 0
+-60 -20 -33 0
+-1 28 -86 0
+32 39 19 0
+32 70 -65 0
+6 98 -53 0
+82 -76 -100 0
+-100 -75 92 0
+-71 85 -42 0
+-11 -66 -60 0
+-36 100 92 0
+-69 24 -84 0
+32 -37 24 0
+-92 69 -67 0
+-92 -69 17 0
+3 63 -92 0
+-29 -94 -28 0
+-4 82 25 0
+35 75 -97 0
+%
+0
+

benchmarks/uf100/uf100-037.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -75 34 -98 0
+65 12 60 0
+-12 -57 -16 0
+78 -90 40 0
+4 -10 -1 0
+-94 -18 67 0
+-33 -67 -92 0
+-75 50 -8 0
+38 29 -9 0
+49 31 60 0
+-18 43 63 0
+16 44 -84 0
+99 82 -26 0
+-75 80 94 0
+-34 72 -44 0
+38 36 100 0
+37 -91 -2 0
+43 79 -4 0
+23 100 -62 0
+40 95 20 0
+-71 -53 -49 0
+-88 -11 -86 0
+-67 97 -62 0
+-38 -67 82 0
+-75 12 100 0
+-7 -15 68 0
+50 -73 51 0
+-18 -28 1 0
+62 35 -12 0
+49 9 96 0
+63 -9 55 0
+71 -13 21 0
+65 -1 -27 0
+7 -33 -83 0
+98 -75 62 0
+8 86 -57 0
+8 62 -9 0
+-54 73 -84 0
+51 -24 -14 0
+-100 71 54 0
+64 -24 -16 0
+16 -68 26 0
+7 50 -91 0
+81 47 -85 0
+-14 90 18 0
+-38 -28 63 0
+-73 -56 -53 0
+-5 1 93 0
+66 11 -63 0
+14 38 -71 0
+79 50 -4 0
+69 -81 -48 0
+-7 -82 100 0
+-15 -42 -40 0
+58 5 1 0
+4 -13 -62 0
+99 23 50 0
+45 50 -9 0
+73 63 26 0
+-75 97 -22 0
+87 29 69 0
+-18 -35 -46 0
+95 -26 -38 0
+89 -42 -48 0
+-31 29 83 0
+-8 91 -37 0
+100 57 -7 0
+-33 19 -13 0
+56 11 -24 0
+-90 55 6 0
+81 -15 99 0
+-89 91 94 0
+-83 68 -37 0
+78 -94 -69 0
+-78 -87 -48 0
+-92 -40 -70 0
+28 45 -51 0
+-39 23 -54 0
+34 -96 -85 0
+96 -75 69 0
+-98 49 68 0
+-27 -66 70 0
+64 -25 -32 0
+-10 34 46 0
+76 -31 -17 0
+72 -22 -40 0
+66 25 33 0
+8 36 74 0
+35 69 70 0
+5 36 29 0
+-21 82 -24 0
+-24 86 8 0
+-98 -37 -54 0
+-95 96 -58 0
+77 -29 97 0
+7 -98 87 0
+12 81 92 0
+-38 35 58 0
+80 -1 15 0
+-98 42 67 0
+-100 -53 -41 0
+-92 94 78 0
+-5 51 -48 0
+-82 -22 54 0
+34 56 60 0
+-44 49 59 0
+-81 26 34 0
+72 -15 97 0
+-73 59 27 0
+-88 72 4 0
+32 70 68 0
+-96 29 -41 0
+26 52 84 0
+19 87 -80 0
+-90 29 -69 0
+-3 -48 -60 0
+78 59 91 0
+-6 -38 81 0
+-10 2 96 0
+-87 36 -64 0
+45 31 -28 0
+-66 -80 -49 0
+-85 -4 -99 0
+-74 -2 83 0
+-5 78 -65 0
+-49 -76 24 0
+67 45 4 0
+-76 85 -6 0
+55 -24 -99 0
+67 -98 -68 0
+24 -15 -76 0
+-71 -59 -99 0
+-77 49 84 0
+-80 77 57 0
+69 81 47 0
+36 -34 28 0
+-65 52 77 0
+61 -4 99 0
+78 65 97 0
+83 12 91 0
+-42 -83 36 0
+-88 57 -68 0
+15 81 -97 0
+33 3 -47 0
+40 19 2 0
+-33 -90 32 0
+-84 46 82 0
+45 24 81 0
+-23 -69 8 0
+-59 -38 63 0
+9 -1 -100 0
+64 53 4 0
+46 -49 -37 0
+32 -12 42 0
+84 -39 78 0
+-57 7 47 0
+15 -10 -69 0
+-31 1 22 0
+-41 -59 24 0
+-22 82 43 0
+-45 83 -47 0
+-8 -54 -2 0
+-50 -2 -58 0
+82 -10 43 0
+-9 13 23 0
+92 56 -33 0
+31 55 -25 0
+90 -80 -97 0
+-31 33 -76 0
+16 -46 -80 0
+88 89 -47 0
+91 -58 -49 0
+11 81 59 0
+74 59 -41 0
+-17 -47 24 0
+87 -72 10 0
+-27 -83 -95 0
+54 9 -66 0
+-20 90 -51 0
+-39 -56 30 0
+-83 -38 -87 0
+29 -97 -61 0
+-8 25 -67 0
+66 56 73 0
+99 55 67 0
+43 -100 55 0
+-7 20 -22 0
+-26 50 -18 0
+76 89 10 0
+60 4 -81 0
+-45 75 -97 0
+24 -11 -9 0
+-39 -4 1 0
+9 71 12 0
+44 79 -20 0
+21 50 27 0
+7 72 42 0
+-65 55 22 0
+88 19 100 0
+81 -86 -35 0
+25 -40 13 0
+-48 -59 85 0
+-27 30 26 0
+-80 -59 31 0
+94 -76 22 0
+15 3 52 0
+-71 -93 -97 0
+-59 -81 2 0
+-26 53 -1 0
+93 -25 -72 0
+-26 -68 -54 0
+16 65 90 0
+-85 -78 -25 0
+28 87 -50 0
+-25 35 -5 0
+-47 -75 25 0
+-98 -66 85 0
+-32 63 82 0
+54 77 -30 0
+-83 30 -7 0
+-46 -72 -30 0
+-90 -70 47 0
+-78 89 87 0
+3 99 11 0
+5 -84 -46 0
+-66 -17 43 0
+76 -77 85 0
+46 -28 -31 0
+-67 90 -74 0
+93 26 58 0
+-9 -3 46 0
+-67 -73 -10 0
+92 -40 -87 0
+-98 38 -64 0
+45 8 11 0
+-33 55 49 0
+11 72 19 0
+-79 14 53 0
+40 32 -61 0
+-88 -48 82 0
+-45 -83 -81 0
+-40 -72 -58 0
+72 71 93 0
+47 -76 -60 0
+-81 -67 -10 0
+-89 10 43 0
+55 43 -75 0
+-92 -73 -37 0
+-11 43 49 0
+32 -30 -94 0
+1 81 -67 0
+48 4 12 0
+89 -7 -86 0
+98 -1 -25 0
+-73 2 -4 0
+-25 -44 75 0
+-61 -35 27 0
+-86 -45 49 0
+-53 67 38 0
+-50 -86 -10 0
+48 -76 -96 0
+-46 -27 -16 0
+-15 -85 -17 0
+1 -7 -52 0
+-46 -33 50 0
+7 -32 76 0
+-84 -100 -69 0
+-72 87 52 0
+73 -50 -14 0
+90 -33 29 0
+39 -94 -45 0
+57 -78 -99 0
+93 48 58 0
+-51 9 56 0
+-61 -22 -76 0
+2 100 -56 0
+46 -71 28 0
+-15 88 -53 0
+79 83 96 0
+-77 -7 51 0
+-15 98 10 0
+21 90 -94 0
+53 47 77 0
+-93 97 90 0
+-16 -8 44 0
+-77 75 -37 0
+11 66 70 0
+-93 -67 -50 0
+-76 -65 66 0
+68 -2 -46 0
+-11 -36 22 0
+8 -46 -72 0
+-4 -27 -23 0
+48 63 55 0
+-16 83 51 0
+-46 27 48 0
+69 32 74 0
+13 47 -61 0
+-26 -65 21 0
+-30 -93 18 0
+93 -99 -61 0
+68 -34 -17 0
+76 86 6 0
+94 48 -88 0
+-50 58 59 0
+-100 -30 -11 0
+-45 -38 -10 0
+20 -55 -69 0
+49 -84 -37 0
+-2 48 -22 0
+-72 -14 -89 0
+-59 -18 -97 0
+52 99 30 0
+9 73 -3 0
+10 -11 -47 0
+-91 42 74 0
+38 -84 65 0
+9 4 -42 0
+-58 -32 38 0
+59 87 57 0
+66 -9 -69 0
+-87 -25 76 0
+96 67 -32 0
+3 63 -86 0
+86 -81 -50 0
+68 -53 -76 0
+29 79 88 0
+-33 -26 13 0
+18 65 81 0
+66 90 -84 0
+-83 100 22 0
+22 -64 93 0
+-56 -1 49 0
+-87 -82 -76 0
+-70 49 54 0
+46 -1 4 0
+-100 -52 -34 0
+69 23 57 0
+-14 -10 97 0
+-60 -34 -9 0
+-61 -3 -58 0
+-97 -13 16 0
+-34 10 61 0
+-79 53 -14 0
+22 -2 -27 0
+84 23 86 0
+22 -16 59 0
+42 -14 -55 0
+7 58 -50 0
+14 -55 -94 0
+24 68 -78 0
+56 -30 -13 0
+61 9 -7 0
+-12 18 -43 0
+54 -51 31 0
+-2 15 -83 0
+-77 -81 -20 0
+-82 -56 96 0
+74 82 -25 0
+92 97 13 0
+37 46 19 0
+10 -1 23 0
+17 -72 73 0
+19 33 -24 0
+5 -40 63 0
+21 99 -52 0
+82 -28 -78 0
+-21 -73 -39 0
+-36 3 -30 0
+-25 -51 -18 0
+93 89 -78 0
+-21 9 -23 0
+65 34 52 0
+100 62 -38 0
+7 45 35 0
+-3 -24 92 0
+-77 -89 28 0
+79 -51 -74 0
+65 -53 -62 0
+87 88 -27 0
+25 -15 82 0
+-35 -72 38 0
+-3 -49 73 0
+77 44 -78 0
+20 -33 -47 0
+-4 -79 -73 0
+-34 -30 39 0
+-94 -95 57 0
+-93 -47 79 0
+-29 -5 57 0
+34 55 -90 0
+73 13 11 0
+38 -99 76 0
+-97 17 89 0
+-95 -6 -71 0
+3 11 -71 0
+-81 -23 -66 0
+-10 4 69 0
+-96 -5 -55 0
+-98 66 62 0
+49 39 -29 0
+73 27 -1 0
+-8 27 -71 0
+-15 -8 -84 0
+-26 -90 -21 0
+5 7 95 0
+10 98 -69 0
+77 44 13 0
+25 36 32 0
+-62 31 -14 0
+38 -22 77 0
+74 -64 100 0
+28 -50 80 0
+-65 20 36 0
+21 -89 -71 0
+4 -9 -81 0
+-15 -26 83 0
+84 48 -99 0
+-89 -63 -35 0
+6 80 47 0
+-43 59 23 0
+-15 30 89 0
+-55 76 6 0
+-67 -82 40 0
+-57 51 -61 0
+-38 59 -61 0
+73 -72 -54 0
+-97 -75 -66 0
+-42 75 10 0
+51 -97 -85 0
+%
+0
+

benchmarks/uf100/uf100-038.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -51 62 -49 0
+-54 -98 90 0
+84 55 81 0
+51 -1 -29 0
+-4 38 -82 0
+-15 58 26 0
+-63 42 -52 0
+40 -56 -81 0
+-99 -58 -29 0
+-3 96 62 0
+68 -60 -52 0
+93 -31 37 0
+44 -26 -93 0
+-24 -72 -9 0
+-33 75 -62 0
+-21 96 -23 0
+68 -19 22 0
+42 7 35 0
+-85 55 -80 0
+59 39 -25 0
+83 54 -48 0
+97 -93 -92 0
+-27 -38 -61 0
+69 56 -46 0
+99 7 91 0
+76 10 77 0
+-96 13 -94 0
+42 58 -27 0
+94 88 54 0
+-90 -35 9 0
+-3 -34 -44 0
+-80 52 72 0
+-63 -81 -61 0
+87 76 67 0
+41 -3 -37 0
+84 -85 -28 0
+-87 44 -36 0
+61 -79 55 0
+-100 -54 12 0
+69 -34 29 0
+100 -67 -96 0
+11 81 3 0
+-21 100 -97 0
+12 -20 17 0
+-50 -54 43 0
+-89 -58 -91 0
+43 96 65 0
+64 3 61 0
+-51 42 40 0
+24 80 90 0
+-89 -97 -6 0
+-16 78 -55 0
+-25 83 -61 0
+8 72 -24 0
+-94 -69 -30 0
+99 58 65 0
+93 45 23 0
+-5 30 25 0
+-48 -21 -18 0
+-22 61 -31 0
+-20 43 -57 0
+-30 -39 31 0
+95 -91 -65 0
+-66 -3 -99 0
+-46 96 -26 0
+76 66 -14 0
+19 80 -98 0
+85 28 74 0
+28 -13 32 0
+91 41 1 0
+88 92 -13 0
+-60 -42 57 0
+76 1 14 0
+-52 -60 -74 0
+-68 96 79 0
+-72 4 -38 0
+-31 -70 41 0
+28 -36 -15 0
+-83 -11 -21 0
+35 56 -71 0
+-39 -13 87 0
+75 15 83 0
+29 -30 79 0
+4 53 49 0
+-1 -43 93 0
+54 -95 45 0
+54 -45 44 0
+-80 89 77 0
+96 -35 1 0
+-80 60 52 0
+5 85 -3 0
+79 -18 -23 0
+-95 -66 -46 0
+-47 -31 93 0
+71 -49 -54 0
+-48 -65 64 0
+-76 -68 54 0
+68 77 -96 0
+-7 -76 22 0
+-1 -37 61 0
+-16 27 -5 0
+-15 -99 62 0
+-99 -66 20 0
+86 -85 -24 0
+-18 85 26 0
+18 54 -31 0
+-16 47 53 0
+21 14 -15 0
+89 -92 -78 0
+1 -17 -47 0
+-31 13 -39 0
+-14 50 18 0
+16 -47 -46 0
+23 -75 45 0
+63 87 -60 0
+93 44 67 0
+2 -18 -51 0
+-52 99 25 0
+-51 -52 -86 0
+-39 14 -59 0
+53 15 16 0
+-20 -48 37 0
+48 19 -72 0
+-68 99 63 0
+-64 -99 -100 0
+1 86 -72 0
+-94 -42 62 0
+-80 -96 27 0
+-31 26 76 0
+69 -27 25 0
+25 51 -72 0
+71 3 26 0
+11 -91 -100 0
+63 -83 88 0
+78 -22 41 0
+-28 85 70 0
+-64 85 13 0
+-94 -27 -14 0
+56 -27 49 0
+-58 42 -23 0
+-18 -72 -69 0
+98 34 -67 0
+34 16 -8 0
+-13 64 -98 0
+-64 -65 4 0
+70 -81 -19 0
+-20 -66 23 0
+-68 -10 -62 0
+47 70 34 0
+7 -95 -6 0
+-58 -51 49 0
+-65 -8 -83 0
+-34 61 69 0
+-65 82 94 0
+40 32 -19 0
+-14 -99 50 0
+-79 40 45 0
+-21 -60 98 0
+14 19 15 0
+-33 57 72 0
+51 -14 -12 0
+-38 55 -26 0
+19 38 -12 0
+-50 41 85 0
+-4 81 -58 0
+-88 -83 72 0
+86 20 3 0
+-63 20 -57 0
+40 85 -23 0
+25 -52 82 0
+14 66 -12 0
+98 -68 -63 0
+70 89 38 0
+83 -10 43 0
+32 9 65 0
+-54 -49 -13 0
+-25 -59 -30 0
+69 -36 87 0
+-27 -63 -20 0
+83 100 86 0
+94 66 69 0
+-68 56 -88 0
+-95 12 -90 0
+92 44 -31 0
+-88 95 99 0
+-93 35 78 0
+-91 9 64 0
+32 -100 18 0
+90 -72 -79 0
+19 69 85 0
+28 -35 60 0
+-14 -87 9 0
+84 98 -14 0
+37 8 66 0
+-6 -45 -17 0
+-17 -90 -93 0
+-77 -8 76 0
+99 -69 -39 0
+7 -64 73 0
+28 -34 -37 0
+35 -85 -87 0
+-87 -52 -72 0
+40 -31 -83 0
+17 50 -62 0
+-66 -73 18 0
+17 53 -99 0
+-13 -18 26 0
+54 29 48 0
+-26 -55 83 0
+-68 58 -95 0
+-97 -58 14 0
+-70 -98 62 0
+-12 -36 79 0
+-93 -98 -71 0
+-97 51 -21 0
+-53 32 19 0
+-12 -96 -1 0
+23 -3 -18 0
+-17 54 -87 0
+-51 26 -21 0
+-33 69 88 0
+-55 47 10 0
+-37 42 -3 0
+43 59 18 0
+99 -97 -72 0
+-75 -100 -57 0
+-76 -6 -39 0
+-87 -97 100 0
+-53 93 1 0
+-16 20 44 0
+76 -14 -11 0
+-25 51 68 0
+22 23 -24 0
+-63 64 -67 0
+-10 50 8 0
+-64 13 60 0
+37 71 86 0
+-31 -56 -45 0
+-28 38 -21 0
+-82 -10 4 0
+-36 27 -54 0
+30 38 70 0
+-37 73 59 0
+-38 55 -72 0
+12 30 82 0
+55 -70 9 0
+-79 -9 -77 0
+29 23 -39 0
+47 -5 45 0
+15 82 97 0
+-84 55 -10 0
+-99 -82 89 0
+-56 3 62 0
+68 -59 -16 0
+27 78 50 0
+-64 -91 5 0
+53 -82 -90 0
+79 14 -67 0
+-52 -75 38 0
+-35 13 -78 0
+34 -99 -77 0
+46 -24 -41 0
+-99 -44 12 0
+-43 35 -94 0
+-81 36 92 0
+44 -54 -26 0
+79 -38 -21 0
+17 71 29 0
+-47 79 41 0
+-39 85 11 0
+-40 58 -64 0
+-37 -87 -82 0
+73 -31 96 0
+-47 44 55 0
+7 41 -88 0
+56 76 -50 0
+-80 71 86 0
+28 -99 76 0
+-30 46 -85 0
+-87 -39 -28 0
+66 12 -40 0
+-15 -10 -45 0
+45 98 -70 0
+61 51 13 0
+-33 -21 84 0
+-24 -61 -52 0
+-38 -90 -92 0
+54 -34 -60 0
+90 -15 -30 0
+48 -93 -85 0
+72 76 40 0
+-6 -76 -5 0
+58 11 -28 0
+97 24 -96 0
+-90 74 48 0
+-54 -77 76 0
+9 6 91 0
+-7 -60 34 0
+-73 16 -11 0
+-89 15 14 0
+17 -96 90 0
+18 1 95 0
+-37 62 -3 0
+-85 12 -11 0
+-61 -100 -66 0
+-88 -80 -81 0
+-82 7 -77 0
+19 74 -41 0
+16 29 91 0
+77 -85 -100 0
+28 47 42 0
+-84 -6 -37 0
+-40 100 -48 0
+60 -36 20 0
+50 -38 -29 0
+-12 8 -35 0
+83 -99 64 0
+94 -98 -45 0
+-32 -38 -2 0
+96 -37 -100 0
+11 -98 87 0
+-4 -34 -100 0
+-12 -46 57 0
+23 -18 -73 0
+-86 -65 -97 0
+-66 99 81 0
+-54 47 64 0
+-12 -26 62 0
+-3 4 66 0
+34 -13 -100 0
+-13 64 87 0
+-24 71 -77 0
+-4 36 -16 0
+-14 -7 1 0
+15 41 -45 0
+4 89 -49 0
+90 -95 -60 0
+-49 -1 29 0
+60 99 22 0
+-55 68 -50 0
+56 11 -40 0
+77 19 53 0
+98 82 39 0
+-68 93 -35 0
+-25 -88 30 0
+-26 42 -47 0
+-23 -22 95 0
+-14 -55 8 0
+88 49 -35 0
+85 62 55 0
+-51 62 82 0
+-73 50 49 0
+94 -38 61 0
+-44 -77 91 0
+-45 -85 89 0
+40 49 85 0
+-49 -17 -61 0
+-4 -77 23 0
+-6 -22 -89 0
+23 44 -73 0
+36 83 -19 0
+-32 -53 -80 0
+-77 54 40 0
+-11 24 39 0
+-88 -43 81 0
+30 89 5 0
+-12 41 62 0
+-53 10 -66 0
+9 20 8 0
+-85 -6 69 0
+-88 96 12 0
+-1 55 -62 0
+73 -98 4 0
+22 98 31 0
+56 -29 55 0
+-47 -81 -15 0
+79 73 -13 0
+34 8 56 0
+-49 -68 -42 0
+-28 -52 15 0
+1 -23 -89 0
+-75 -60 -34 0
+-45 -34 76 0
+-44 -20 -88 0
+-71 25 36 0
+-94 8 34 0
+-43 -97 -75 0
+44 29 -9 0
+40 -73 -99 0
+12 29 22 0
+-58 -8 -35 0
+-7 32 55 0
+-57 -52 -68 0
+46 11 69 0
+-40 -50 -54 0
+89 54 -75 0
+82 53 95 0
+75 -92 54 0
+39 3 -35 0
+-33 86 22 0
+54 -36 71 0
+-92 -41 70 0
+89 -52 -96 0
+66 32 56 0
+-73 -72 88 0
+-11 13 70 0
+-98 33 70 0
+-72 7 -97 0
+-21 15 -23 0
+-77 -87 -33 0
+-98 -90 4 0
+-97 69 -76 0
+12 -8 1 0
+99 -96 -63 0
+82 48 64 0
+6 -9 33 0
+53 73 72 0
+22 -50 -16 0
+72 -57 -86 0
+-12 -59 4 0
+18 -78 -24 0
+54 -39 73 0
+34 89 61 0
+39 82 -75 0
+-81 27 -10 0
+98 -19 60 0
+-21 23 -86 0
+-4 81 -40 0
+-82 -68 32 0
+8 -73 -75 0
+%
+0
+

benchmarks/uf100/uf100-039.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ 89 -52 55 0
+-16 24 -95 0
+-1 93 87 0
+82 3 -43 0
+15 16 80 0
+-96 19 -89 0
+-99 40 7 0
+-85 -7 -12 0
+73 -44 -54 0
+-12 98 93 0
+29 -32 -42 0
+1 -82 5 0
+26 60 -18 0
+89 3 23 0
+20 30 4 0
+-36 -50 -72 0
+43 -68 36 0
+-58 100 -70 0
+-54 -27 2 0
+-83 89 -50 0
+-26 36 -21 0
+51 55 -87 0
+59 -28 -65 0
+-87 -91 -66 0
+46 48 35 0
+-58 -83 25 0
+-6 49 -66 0
+-88 8 -21 0
+-16 -28 77 0
+67 -37 83 0
+5 -26 14 0
+41 -85 57 0
+1 64 -15 0
+-7 32 -83 0
+19 -80 -10 0
+32 85 -4 0
+53 -55 68 0
+17 -63 8 0
+-86 -91 -55 0
+41 -93 46 0
+27 -26 11 0
+-13 24 79 0
+25 -49 -3 0
+55 65 -78 0
+76 72 43 0
+-48 62 -58 0
+-91 -56 61 0
+96 38 -4 0
+-83 82 68 0
+-67 85 -61 0
+-36 54 -60 0
+75 -22 48 0
+36 88 -74 0
+-30 -98 -71 0
+-15 56 -69 0
+73 -80 -28 0
+-24 -47 -81 0
+-7 -16 -61 0
+70 -85 -73 0
+-24 -96 -17 0
+-66 -44 40 0
+52 -100 58 0
+-5 -78 55 0
+41 -27 -94 0
+-74 -91 70 0
+-50 48 -85 0
+-1 92 61 0
+-97 -28 -10 0
+-62 32 -94 0
+-29 19 51 0
+40 59 82 0
+84 49 14 0
+-76 -4 -65 0
+52 -16 88 0
+-5 -100 -52 0
+-90 -38 -19 0
+93 -45 15 0
+44 65 -25 0
+-65 1 -95 0
+86 51 -65 0
+97 -96 -100 0
+-83 -60 -5 0
+18 10 58 0
+21 83 -8 0
+81 -20 4 0
+7 -53 -6 0
+-67 51 -31 0
+65 7 23 0
+26 7 -38 0
+-21 61 95 0
+-73 70 -10 0
+45 89 12 0
+81 100 15 0
+-33 -31 -47 0
+-62 -92 -48 0
+-60 30 -34 0
+-50 -54 -59 0
+-70 -50 -94 0
+-25 -85 -29 0
+58 -16 92 0
+70 32 -79 0
+74 50 40 0
+27 -82 58 0
+18 -91 94 0
+45 19 65 0
+-85 -93 -67 0
+-49 69 17 0
+-97 28 -10 0
+64 67 58 0
+-54 -46 71 0
+75 -62 73 0
+-87 25 -57 0
+71 -54 -95 0
+88 -64 -37 0
+51 27 -11 0
+-27 92 -41 0
+-39 -16 23 0
+-80 -61 2 0
+-45 73 65 0
+-46 -68 -65 0
+-35 14 73 0
+-73 52 18 0
+43 -26 -68 0
+45 25 10 0
+71 -9 -12 0
+62 10 -66 0
+10 73 -85 0
+-47 45 60 0
+36 -90 -45 0
+86 -85 -3 0
+73 90 62 0
+19 85 14 0
+-70 -49 -65 0
+97 -82 -12 0
+33 -82 -74 0
+-32 -66 -44 0
+22 93 40 0
+41 86 -91 0
+-82 -42 -66 0
+-83 -15 44 0
+-10 -82 -2 0
+10 95 -69 0
+-92 -71 69 0
+67 -58 56 0
+95 -34 54 0
+-75 -99 -85 0
+52 62 -54 0
+-4 -2 54 0
+88 -51 87 0
+82 78 -71 0
+39 -91 59 0
+82 19 -73 0
+-18 42 -85 0
+-1 2 21 0
+-25 -26 -82 0
+55 99 -89 0
+-24 4 73 0
+-79 56 -53 0
+-34 28 70 0
+58 39 40 0
+36 -87 99 0
+-79 23 -24 0
+63 -98 17 0
+-83 95 -71 0
+65 5 -23 0
+5 80 43 0
+24 82 -65 0
+9 96 80 0
+70 93 -35 0
+25 9 88 0
+4 18 10 0
+-88 -45 95 0
+35 1 23 0
+-55 96 -25 0
+-72 61 -76 0
+-90 -11 7 0
+11 -44 -73 0
+-33 29 -66 0
+-87 97 -11 0
+58 -82 55 0
+5 -1 -50 0
+15 -100 49 0
+52 -24 -79 0
+92 63 -56 0
+81 6 60 0
+78 26 49 0
+-4 -44 -5 0
+65 14 -22 0
+-13 12 -50 0
+47 95 3 0
+55 7 -50 0
+9 -37 -23 0
+12 -53 99 0
+-21 -9 30 0
+-68 24 -37 0
+95 -84 73 0
+23 95 42 0
+30 -20 -83 0
+-46 75 -88 0
+-18 -13 88 0
+-21 78 -99 0
+99 -44 -81 0
+-70 18 -8 0
+31 -91 -36 0
+83 -93 -70 0
+-58 -54 -85 0
+-49 19 51 0
+58 -24 47 0
+-40 59 44 0
+41 7 -17 0
+-97 -2 46 0
+52 -1 40 0
+-42 -46 70 0
+96 -95 98 0
+-62 94 -28 0
+71 -1 74 0
+-37 34 26 0
+-23 -78 60 0
+31 -61 -9 0
+-49 62 -54 0
+49 10 58 0
+-48 63 73 0
+87 -62 -86 0
+-59 84 12 0
+-28 60 73 0
+-39 86 22 0
+35 55 11 0
+-15 -13 -11 0
+-51 -17 -47 0
+73 -12 -18 0
+-57 31 40 0
+26 -62 1 0
+-85 -83 -40 0
+59 -33 -15 0
+-64 67 10 0
+-36 67 -34 0
+22 71 -21 0
+-50 -91 -71 0
+88 44 -87 0
+1 -13 -47 0
+13 30 -25 0
+6 27 40 0
+-15 -99 37 0
+39 -76 66 0
+-5 -79 28 0
+9 2 -51 0
+2 -53 83 0
+88 -94 30 0
+46 17 -94 0
+-27 -46 51 0
+76 6 -42 0
+-82 -40 43 0
+96 -69 -15 0
+43 38 9 0
+-9 75 -95 0
+99 4 97 0
+-30 -12 -75 0
+93 -72 25 0
+100 -40 55 0
+-58 85 78 0
+44 -42 10 0
+-76 -11 52 0
+7 -76 -99 0
+49 -83 34 0
+-5 48 94 0
+-88 -45 -78 0
+-37 61 -70 0
+16 18 29 0
+10 -97 -94 0
+53 -4 33 0
+-82 -73 -77 0
+-19 -7 23 0
+-42 11 -51 0
+-82 -34 -97 0
+-60 -29 -99 0
+25 57 58 0
+-64 35 34 0
+-20 65 -39 0
+-71 -16 -98 0
+-62 51 -3 0
+45 -67 34 0
+-30 32 85 0
+93 38 72 0
+-95 79 21 0
+-67 -7 62 0
+-47 12 71 0
+31 44 -71 0
+-22 100 27 0
+99 26 -14 0
+-31 -84 65 0
+-96 -100 -44 0
+-6 11 2 0
+-65 47 9 0
+27 -38 -64 0
+-98 -87 65 0
+94 75 -17 0
+-95 46 7 0
+5 -87 78 0
+52 5 54 0
+-97 42 -96 0
+-79 97 -49 0
+-92 28 -35 0
+30 29 43 0
+-23 94 -25 0
+-86 -6 11 0
+56 45 11 0
+93 32 -73 0
+84 -60 -25 0
+-47 -89 -60 0
+-41 50 73 0
+-65 -87 84 0
+-20 84 -55 0
+88 94 45 0
+79 66 -100 0
+-6 78 14 0
+17 -94 32 0
+-24 -89 6 0
+64 -69 10 0
+19 -59 96 0
+-82 -1 11 0
+-40 -96 32 0
+-93 -20 -89 0
+15 -61 38 0
+54 87 -76 0
+-82 -85 72 0
+-31 -20 45 0
+-63 -84 -60 0
+-21 97 -18 0
+-76 74 -72 0
+-23 -5 61 0
+-44 -27 -60 0
+-29 52 35 0
+-45 -25 13 0
+49 58 7 0
+-96 31 34 0
+-96 -67 57 0
+6 -84 98 0
+-58 -17 26 0
+4 27 -65 0
+-40 -42 4 0
+-3 93 94 0
+6 -53 32 0
+5 51 -20 0
+38 24 -26 0
+-75 73 14 0
+-5 48 -4 0
+-47 13 -4 0
+83 -21 -47 0
+100 -88 91 0
+98 65 96 0
+22 47 -89 0
+-76 -92 9 0
+76 -53 -44 0
+-89 -54 -82 0
+-3 -77 -36 0
+40 9 -24 0
+24 -10 60 0
+-56 -64 82 0
+-95 -74 -90 0
+-48 -56 46 0
+-60 94 -42 0
+52 -47 -85 0
+41 34 36 0
+59 28 95 0
+-18 51 -4 0
+95 -94 -52 0
+-12 29 -20 0
+69 80 -32 0
+26 61 -92 0
+-68 -27 -46 0
+-29 84 73 0
+-54 31 78 0
+70 -95 -96 0
+-66 25 -59 0
+-53 -13 -95 0
+-78 -13 -68 0
+-100 46 18 0
+-93 -88 39 0
+87 54 62 0
+14 -64 18 0
+-92 -40 14 0
+-46 -90 -52 0
+7 59 58 0
+82 -34 100 0
+-49 -93 74 0
+-69 -92 -76 0
+89 -96 55 0
+-10 65 80 0
+13 92 60 0
+-23 -84 31 0
+33 20 -22 0
+74 91 68 0
+49 40 91 0
+55 20 93 0
+-53 -54 -11 0
+14 -83 -81 0
+-7 -64 73 0
+-100 -41 43 0
+-92 23 69 0
+11 -89 55 0
+-83 85 -87 0
+46 -26 41 0
+-20 -100 73 0
+-12 -82 65 0
+81 -76 -90 0
+39 80 -45 0
+3 88 -90 0
+76 -26 -90 0
+-90 -99 62 0
+55 -59 -3 0
+4 -32 79 0
+13 60 9 0
+-92 78 39 0
+62 -15 25 0
+-50 -23 -62 0
+52 70 86 0
+-50 31 3 0
+72 24 83 0
+-36 -66 -23 0
+63 -39 -14 0
+-79 -42 -50 0
+8 -21 99 0
+-15 -51 -54 0
+4 -97 24 0
+18 20 50 0
+-12 -22 -82 0
+30 93 -73 0
+58 17 -2 0
+-69 17 59 0
+-4 -61 -35 0
+%
+0
+

benchmarks/uf100/uf100-04.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -100 -37 -87 0
+79 -20 94 0
+99 -6 -55 0
+-26 99 47 0
+-36 -85 -99 0
+50 -81 29 0
+-2 -57 -37 0
+-14 76 -96 0
+56 32 92 0
+17 51 -2 0
+8 -51 63 0
+-52 -88 -97 0
+-79 -96 -50 0
+-68 20 88 0
+-76 -38 -53 0
+60 -61 -5 0
+-63 48 -79 0
+-33 -15 57 0
+38 56 -41 0
+-27 -91 -100 0
+33 28 14 0
+28 -13 -58 0
+68 -5 -8 0
+-45 24 -51 0
+47 -75 57 0
+100 86 53 0
+-22 -50 -15 0
+-72 24 -91 0
+75 -93 1 0
+-91 -23 -48 0
+-69 -62 24 0
+-2 -34 41 0
+52 -15 -17 0
+4 54 93 0
+-20 54 64 0
+-38 -91 -1 0
+88 -73 18 0
+-54 4 -22 0
+-64 -37 -57 0
+-85 21 -61 0
+-90 35 -100 0
+-39 78 1 0
+-20 -34 29 0
+54 -4 49 0
+-7 55 -37 0
+-67 95 15 0
+49 84 98 0
+-57 -70 62 0
+97 13 33 0
+-61 -29 -57 0
+-78 62 56 0
+12 76 85 0
+-37 -81 -4 0
+-27 62 -76 0
+62 -67 26 0
+79 41 83 0
+36 -44 85 0
+-54 -89 -91 0
+-19 -13 18 0
+92 33 -91 0
+39 -29 96 0
+30 98 72 0
+25 71 -12 0
+-71 45 -11 0
+14 31 -15 0
+-59 86 -93 0
+-82 36 -54 0
+-76 -74 -41 0
+-85 59 -12 0
+-76 -61 81 0
+55 -24 13 0
+-4 58 54 0
+-27 -86 -77 0
+34 -57 -24 0
+-96 27 -33 0
+4 72 -20 0
+-35 -23 -55 0
+-92 -6 51 0
+-33 -7 80 0
+-28 48 -58 0
+-57 27 -47 0
+74 -79 -89 0
+93 59 74 0
+67 60 54 0
+77 44 -53 0
+-8 61 3 0
+20 11 -24 0
+76 -32 -49 0
+97 -42 35 0
+56 -64 -94 0
+-84 -5 -59 0
+-32 -78 8 0
+-46 62 -78 0
+69 -8 -94 0
+53 13 45 0
+44 -4 46 0
+99 -21 -81 0
+52 21 27 0
+-82 -83 45 0
+57 -37 14 0
+-42 26 38 0
+-90 27 48 0
+-35 85 -44 0
+99 -96 40 0
+-44 28 61 0
+92 -69 -68 0
+56 45 -22 0
+-27 50 -39 0
+-28 -9 48 0
+-92 -96 -46 0
+-95 -45 -42 0
+-58 30 -42 0
+-34 60 6 0
+-24 58 -25 0
+89 -17 72 0
+7 64 69 0
+-45 -83 72 0
+44 -96 -64 0
+-66 -91 -51 0
+67 -50 -93 0
+63 89 25 0
+74 -81 -33 0
+49 -12 -91 0
+-5 26 49 0
+31 82 59 0
+84 82 -30 0
+-57 86 47 0
+-84 -79 -25 0
+-31 -96 10 0
+89 81 7 0
+88 -86 8 0
+82 50 6 0
+-42 -22 14 0
+-51 26 -1 0
+-86 93 32 0
+19 27 20 0
+-46 -24 63 0
+-86 -93 22 0
+5 -10 42 0
+56 -39 88 0
+-67 5 -41 0
+-37 71 16 0
+-74 -14 -38 0
+-78 -81 95 0
+39 -6 -80 0
+-48 20 63 0
+-42 49 80 0
+73 -10 -15 0
+-63 61 67 0
+-99 82 -23 0
+-36 55 96 0
+-8 84 -56 0
+88 13 -1 0
+-87 85 -44 0
+-70 41 -69 0
+-68 -55 -31 0
+71 60 -57 0
+18 34 10 0
+2 -23 -16 0
+-32 45 98 0
+76 -4 71 0
+80 -38 83 0
+34 83 -63 0
+-75 3 -21 0
+48 -80 -41 0
+61 -56 81 0
+54 -42 86 0
+65 -13 33 0
+26 30 -37 0
+-43 67 64 0
+60 73 -99 0
+-88 -58 -3 0
+-24 -59 94 0
+89 -13 -79 0
+-9 -1 -65 0
+16 -44 -49 0
+-76 72 11 0
+-60 68 63 0
+-3 12 61 0
+79 46 20 0
+-19 34 47 0
+21 25 2 0
+-35 63 14 0
+46 -19 -48 0
+25 77 29 0
+-49 39 80 0
+-26 -53 -28 0
+-91 18 87 0
+33 -52 -70 0
+64 28 82 0
+-57 -86 8 0
+78 -17 89 0
+-78 -65 -62 0
+-86 85 -48 0
+-9 -87 -26 0
+19 51 58 0
+-63 -80 66 0
+-96 61 -3 0
+53 -11 -39 0
+99 -75 49 0
+-97 83 -94 0
+-3 72 -76 0
+7 -18 20 0
+64 28 55 0
+64 -27 -95 0
+55 48 -43 0
+45 -5 23 0
+-78 -79 63 0
+-42 -51 -66 0
+16 17 -21 0
+70 83 19 0
+-63 -75 -25 0
+-30 -73 -76 0
+-30 12 -14 0
+89 23 84 0
+-81 3 94 0
+20 -77 -100 0
+41 -92 66 0
+-79 13 -47 0
+60 97 76 0
+54 -86 12 0
+72 -4 -71 0
+88 56 -30 0
+-82 -52 -11 0
+-34 -56 40 0
+-29 46 -61 0
+48 -35 -90 0
+83 -70 11 0
+-77 55 -2 0
+-51 62 -16 0
+-39 66 -23 0
+-85 88 -87 0
+29 -88 38 0
+-88 -76 -64 0
+-50 14 -54 0
+42 -55 65 0
+-24 -84 -4 0
+-27 -77 10 0
+52 -84 -41 0
+28 29 -55 0
+72 -74 -61 0
+35 52 -81 0
+59 -18 -63 0
+75 -45 67 0
+-5 87 -71 0
+56 -89 63 0
+-93 -34 84 0
+-27 26 42 0
+73 24 80 0
+-81 44 25 0
+41 -59 31 0
+36 67 64 0
+-43 -68 56 0
+-19 -30 -28 0
+-36 49 9 0
+3 41 70 0
+62 -80 -10 0
+56 42 -18 0
+15 44 -4 0
+8 78 20 0
+-28 -41 61 0
+-41 -36 -86 0
+1 16 -26 0
+-92 -41 95 0
+-67 90 -14 0
+-7 34 -92 0
+73 -100 59 0
+24 76 68 0
+34 43 13 0
+-95 16 63 0
+-88 -55 -6 0
+-28 -58 71 0
+-28 5 7 0
+13 80 -52 0
+74 -2 93 0
+-50 70 -68 0
+-26 52 -12 0
+27 -64 97 0
+-43 -71 22 0
+-72 69 31 0
+77 55 84 0
+98 35 -59 0
+-1 -58 60 0
+-39 34 -89 0
+90 -99 -53 0
+34 -39 11 0
+-24 -81 -55 0
+79 -90 44 0
+56 -26 -68 0
+-28 -75 -94 0
+37 28 -95 0
+68 58 22 0
+-29 36 -51 0
+-22 48 54 0
+-93 8 -43 0
+-10 -30 -93 0
+24 -41 -28 0
+53 -19 9 0
+90 -6 79 0
+92 65 19 0
+33 46 51 0
+96 -26 -65 0
+97 24 -74 0
+36 -17 64 0
+25 -51 100 0
+65 19 -82 0
+38 -40 -9 0
+57 -59 3 0
+-88 100 47 0
+-87 -38 57 0
+22 -46 60 0
+-86 -98 43 0
+-74 -56 65 0
+-6 73 28 0
+58 -11 -79 0
+55 17 -5 0
+-17 -5 -62 0
+66 73 16 0
+-58 55 -74 0
+25 -63 8 0
+-63 31 21 0
+-32 61 45 0
+-54 86 -16 0
+70 -74 19 0
+40 -83 -88 0
+-51 49 94 0
+-11 48 99 0
+98 -94 5 0
+-78 -32 -94 0
+21 -14 35 0
+-72 -12 -69 0
+3 93 -31 0
+20 -45 65 0
+46 37 58 0
+91 -53 45 0
+45 -32 -16 0
+96 -99 91 0
+-98 20 83 0
+89 90 78 0
+78 19 63 0
+27 -87 -56 0
+41 95 -51 0
+-69 -19 70 0
+-92 70 4 0
+78 93 -51 0
+64 -42 -81 0
+71 -25 -75 0
+72 -23 -15 0
+56 -65 -59 0
+-11 -74 41 0
+14 30 -15 0
+3 -37 -68 0
+96 -15 -78 0
+92 -52 38 0
+-41 94 -91 0
+16 -58 8 0
+-24 93 58 0
+55 12 -63 0
+6 -40 -2 0
+-62 30 78 0
+31 -26 -80 0
+60 -79 -63 0
+66 -24 92 0
+79 -62 -80 0
+66 98 -43 0
+-48 -34 44 0
+-46 67 -76 0
+-28 60 -46 0
+36 -76 65 0
+79 -46 30 0
+86 -11 -71 0
+42 -26 -17 0
+-33 20 17 0
+24 -11 -66 0
+18 -36 -28 0
+-24 8 -37 0
+93 -46 -21 0
+-80 -83 1 0
+-99 95 45 0
+-63 -50 -70 0
+-56 -11 -75 0
+87 -56 -25 0
+-88 45 57 0
+22 -40 67 0
+-67 -4 72 0
+13 -3 -14 0
+-92 -20 -17 0
+-86 -28 -49 0
+-96 8 -98 0
+64 78 55 0
+-73 -47 48 0
+-79 42 33 0
+87 -26 44 0
+11 -94 21 0
+59 -19 9 0
+59 26 90 0
+-19 -91 82 0
+67 73 47 0
+23 18 -39 0
+-75 -83 -13 0
+27 -55 92 0
+55 79 -94 0
+57 96 -52 0
+-48 -29 77 0
+-80 47 -84 0
+58 -57 -34 0
+52 -27 73 0
+-26 20 99 0
+36 -70 33 0
+-13 35 -51 0
+76 85 38 0
+-3 85 -36 0
+-79 56 18 0
+81 -68 -10 0
+-19 -93 100 0
+-50 -64 11 0
+96 -76 -29 0
+30 14 -48 0
+-86 -14 -97 0
+-18 -86 -60 0
+37 38 97 0
+-19 85 68 0
+80 -65 -40 0
+15 -56 -99 0
+72 -73 -77 0
+18 96 -88 0
+54 -38 82 0
+-48 -68 -81 0
+-72 10 -6 0
+62 93 -34 0
+%
+0
+

benchmarks/uf100/uf100-040.cnf

@@ -0,0 +1,441 @@
+c This Formular is generated by mcnf
+c
+c    horn? no 
+c    forced? no 
+c    mixed sat? no 
+c    clause length = 3 
+c
+p cnf 100  430 
+ -47 30 -3 0
+-21 26 -83 0
+32 44 94 0
+-30 70 97 0
+-29 31 -75 0
+-50 -81 2 0
+-11 -99 -55 0
+-88 92 23 0
+11 57 14 0
+36 -65 -49 0
+-83 -13 64 0
+-14 -76 -40 0
+-47 56 91 0
+13 -47 76 0
+-45 -90 75 0
+76 -83 50 0
+80 81 -90 0
+19 -95 -15 0
+28 77 -99 0
+-14 47 41 0
+-26 -15 -24 0
+-91 -33 72 0
+-39 -71 -15 0
+5 7 -55 0
+-54 24 3 0
+-35 39 57 0
+49 -5 -43 0
+-40 -23 65 0
+-33 -80 -51 0
+43 36 -84 0
+86 65 35 0
+-52 -72 53 0
+-90 -32 60 0
+98 19 -15 0
+-8 -47 -33 0
+88 78 -28 0
+70 -72 23 0
+58 56 46 0
+-53 -7 -50 0
+-65 -62 -2 0
+-60 -41 -71 0
+-38 -32 61 0
+74 12 -83 0
+52 81 -98 0
+56 -13 -58 0
+-70 -6 21 0
+-95 -100 -71 0
+29 -64 -81 0
+-99 73 69 0
+56 34 -31 0
+-63 -13 -2 0
+-94 63 69 0
+63 -46 -84 0
+-14 -92 -48 0
+1 -46 2 0
+28 22 57 0
+-98 -99 89 0
+-87 -25 52 0
+-46 -80 35 0
+-62 72 64 0
+20 -52 -66 0
+47 55 -80 0
+-99 42 -37 0
+14 89 16 0
+69 12 13 0
+41 -24 -95 0
+-98 19 6 0
+-64 -29 -65 0
+-80 11 62 0
+36 85 23 0
+-91 -58 51 0
+36 62 -41 0
+63 3 -1 0
+-1 -82 8 0
+-73 -13 9 0
+-22 52 83 0
+95 71 9 0
+7 74 -50 0
+4 -1 33 0
+35 36 -23 0
+-68 53 -34 0
+97 -19 -40 0
+52 -60 25 0
+-53 -71 -26 0
+95 -16 -24 0
+100 -27 6 0
+3 -74 49 0
+93 30 62 0
+-42 -83 -99 0
+-55 -62 -97 0
+32 78 -81 0
+67 -14 31 0
+-18 -48 -38 0
+8 -5 52 0
+-87 27 -81 0
+-38 35 -19 0
+-39 62 6 0
+-72 64 53 0
+-59 32 -73 0
+52 30 73 0
+72 69 -90 0
+-79 -72 34 0
+-58 -38 55 0
+16 31 78 0
+-49 95 64 0
+-51 96 -25 0
+70 -91 62 0
+-7 42 85 0
+-75 -42 -53 0
+-10 91 -46 0
+42 12 -6 0
+2 -14 57 0
+-12 -40 89 0
+48 -7 6 0
+83 -78 93 0
+8 11 22 0
+-9 45 -59 0
+-69 61 -97 0
+-89 -82 69 0
+-97 -64 -14 0
+99 100 94 0
+65 -20 82 0
+-80 53 92 0
+38 -99 -6 0
+-43 -90 51 0
+39 -78 -41 0
+-69 -63 -73 0
+-82 67 11 0
+98 -80 19 0
+90 -28 -1 0
+82 -22 -58 0
+76 -23 19 0
+6 56 71 0
+-36 26 -93 0
+-65 -17 -6 0
+45 -39 -10 0
+-58 -37 -87 0
+-80 91 15 0
+-63 -42 -68 0
+33 59 -13 0
+26 -69 -8 0
+-100 28 -6 0
+-45 83 -82 0
+-2 -96 29 0
+-65 84 83 0
+-46 -48 75 0
+22 -83 -72 0
+-18 -12 -57 0
+87 73 86 0
+39 -7 21 0
+27 -29 -90 0
+45 4 55 0
+90 48 33 0
+36 33 77 0
+-58 85 25 0
+20 32 38 0
+82 -77 -22 0
+-57 82 99 0
+-93 -64 78 0
+88 44 9 0
+-21 -42 -46 0
+-76 -32 55 0
+50 23 -30 0
+-94 -5 22 0
+95 -62 -50 0
+-18 -94 -13 0
+-43 26 -94 0
+-45 73 -83 0
+-32 -14 -100 0
+60 -80 35 0
+-81 -1 -94 0
+7 -77 50 0
+48 -73 -92 0
+54 -8 -85 0
+-66 -71 -93 0
+57 54 100 0
+-6 25 27 0
+-64 -76 -99 0
+41 -50 -100 0
+-83 -22 62 0
+-74 54 -68 0
+24 -9 10 0
+-76 -27 12 0
+-67 21 59 0
+57 29 36 0
+-32 77 -87 0
+-85 74 -98 0
+31 -99 -87 0
+52 41 88 0
+-25 -63 -62 0
+-93 11 -41 0
+-69 -95 -64 0
+27 -19 -86 0
+-81 13 99 0
+-2 47 67 0
+-27 -100 -57 0
+57 47 61 0
+-7 -39 67 0
+51 -32 -42 0
+55 -1 11 0
+68 -90 -16 0
+-91 13 -40 0
+-99 41 91 0
+94 83 -74 0
+99 87 75 0
+26 -75 -28 0
+-35 89 97 0
+27 38 70 0
+59 96 85 0
+-6 29 4 0
+18 63 -86 0
+29 39 73 0
+55 -39 -49 0
+26 15 -47 0
+27 53 7 0
+41 -50 6 0
+-10 24 -48 0
+94 3 -99 0
+93 -53 69 0
+17 90 -68 0
+-67 -59 50 0
+82 -95 68 0
+-89 70 18 0
+42 4 -97 0
+-25 -60 -48 0
+92 50 26 0
+-85 3 -5 0
+-67 19 -51 0
+29 -47 66 0
+85 -82 -70 0
+99 65 2 0
+36 89 -25 0
+-21 -7 -74 0
+-34 21 -27 0
+-9 -30 65 0
+30 -62 2 0
+-53 -21 95 0
+33 -82 42 0
+86 -87 -54 0
+-95 -29 -59 0
+3 53 97 0
+-87 59 98 0
+96 -2 75 0
+-87 41 -62 0
+-93 -22 -89 0
+47 97 -32 0
+47 -16 29 0
+-77 -75 50 0
+59 -64 -45 0
+-80 55 -93 0
+-48 -52 83 0
+-50 -41 28 0
+-27 62 -82 0
+80 -72 -22 0
+-95 72 38 0
+-73 -88 -95 0
+-67 -18 30 0
+-1 -22 -77 0
+-40 78 -62 0
+-45 -95 -26 0
+25 54 53 0
+8 -76 38 0
+53 -71 -56 0
+-19 -93 31 0
+-35 -99 26 0
+-25 5 -60 0
+98 -31 44 0
+69 21 85 0
+78 69 -31 0
+-39 84 -83 0
+70 -67 -30 0
+-42 -21 77 0
+-9 -40 71 0
+-28 -7 -56 0
+60 74 58 0
+69 -2 -57 0
+54 -12 -97 0
+77 -9 -91 0
+95 -94 -74 0
+43 31 -38 0
+-28 2 -75 0
+39 -69 -78 0
+86 -76 77 0
+17 -47 67 0
+-48 -19 10 0
+-83 67 -21 0
+-66 -11 -95 0
+-41 75 -57 0
+81 -74 -17 0
+-56 39 16 0
+2 -1 74 0
+-81 63 18 0
+56 68 81 0
+12 -11 -81 0
+25 -13 10 0
+48 -78 29 0
+29 -81 89 0
+52 11 83 0
+39 -33 -24 0
+-91 85 -93 0
+-27 -73 47 0
+-81 -23 -27 0
+-84 -20 93 0
+79 90 48 0
+-82 -99 93 0
+-43 -25 -90 0
+-37 61 -7 0
+46 -14 93 0
+-53 -59 34 0
+-8 43 41 0
+17 59 63 0
+-91 85 4 0
+-70 93 47 0
+7 -84 85 0
+82 -91 88 0
+60 7 62 0
+-65 -3 95 0
+100 69 -35 0
+-72 -39 49 0
+-2 -60 23 0
+-92 -40 19 0
+-64 -27 34 0
+1 94 2 0
+100 -12 72 0
+81 -69 -9 0
+15 49 -30 0
+-64 66 18 0
+30 -24 4 0
+64 59 55 0
+-85 -87 90 0
+84 4 -95 0
+4 -99 -62 0
+31 -25 -9 0
+78 -19 26 0
+54 39 19 0
+-90 16 11 0
+81 -31 45 0
+27 83 65 0
+3 96 -39 0
+-60 81 -31 0
+-86 -14 78 0
+-43 79 -37 0
+-28 -47 -71 0
+11 84 83 0
+-41 71 91 0
+34 35 29 0
+-18 -73 5 0
+42 -87 -71 0
+-100 89 36 0
+-92 79 -19 0
+97 -84 1 0
+-53 -13 -4 0
+-81 8 50 0
+4 19 -17 0
+87 -92 -34 0
+-72 -71 -67 0
+4 48 75 0
+70 86 -50 0
+-48 -41 -88 0
+-20 -66 -81 0
+36 42 25 0
+66 17 -68 0
+82 93 -58 0
+-100 61 35 0
+-76 -44 -81 0
+11 32 92 0
+54 100 22 0
+-94 -21 -38 0
+-46 51 11 0
+-95 -14 -79 0
+26 80 7 0
+23 -68 -42 0
+90 84 -2 0
+-78 -81 4 0
+24 57 56 0
+-78 -57 5 0
+-26 97 -87 0
+48 -31 -60 0
+3 36 76 0
+48 93 3 0
+27 -80 -33 0
+36 -50 39 0
+-50 -21 -75 0
+2 15 -44 0
+-55 86 -73 0
+84 -62 76 0
+67 8 -79 0
+-20 -61 -91 0
+63 -61 84 0
+-87 -22 8 0
+56 -62 -5 0
+61 45 -85 0
+-9 -69 56 0
+-69 26 76 0
+-74 -19 66 0
+25 -33 -6 0
+-6 -24 -27 0
+86 -72 45 0
+57 -39 -33 0
+76 65 -83 0
+-86 -71 -94 0
+-73 -6 82 0
+75 83 -16 0
+26 81 58 0
+89 81 -5 0
+16 -98 59 0
+-79 -4 98 0
+-53 83 58 0
+-98 -87 -69 0
+-78 89 -66 0
+48 34 -90 0
+23 -17 -90 0
+62 47 -73 0
+63 -15 -66 0
+-17 47 -54 0
+-74 -76 5 0
+50 5 -61 0
+30 87 2 0
+81 70 34 0
+-11 -18 -51 0
+36 72 55 0
+85 84 -42 0
+1 -52 -54 0
+-21 -34 29 0
+59 -91 47 0
+88 91 -17 0
+79 -16 -35 0
+87 -61 -9 0
+100 83 -96 0
+58 97 66 0
+%
+0
+